2

我有一个 8x8 矩阵，在选择我想要的行之后，我想得到它的三个最小元素，并随机选择这三个元素之一。问题是我不知道如何处理这三个元素。我只知道如何获得最小元素，即以下代码。

int piezas[8][8] = {
0, 2, 2, 5, 3, 2, 1, 1,
0, 4, 5, 2, 4, 3, 0, 0,
0, 4, 2, 2, 1, 2, 3, 2,
0, 3, 1, 5, 1, 2, 3, 4,
2, 5, 6, 5, 3, 1, 2, 7,
8, 2, 0, 0, 0, 2, 1, 1,
1, 2, 2, 1, 1, 6, 3, 4,
};

int myrow = 3; // the row I want to analyze
int index;
int min=0;

for (index=0;index<8;index++) {
    printf("%d", piezas[myrow][index] );
    if(piezas[myrow][index]<min)
        min=piezas[myrow][index];
    printf("\t\t");
}
printf("min: %d", min);

我想要的输出是，如果初始矩阵是：

int piezas[8][8] = {
0, 2, 2, 5, 3, 2, 1, 1,
0, 4, 5, 2, 4, 3, 0, 0,
0, 4, 2, 2, 1, 2, 3, 2,
0, 3, 1, 5, 1, 2, 3, 4,
2, 5, 6, 5, 3, 1, 2, 7,
8, 2, 0, 0, 0, 2, 1, 1,
1, 2, 2, 1, 1, 6, 3, 4,
};

我选择第 3 行：

0, 3, 1, 5, 1, 2, 3, 4,

算法必须选择

0, 1, 1

并随机选择这三个之一。

有人可以给我任何关于我该怎么做的想法吗？从今天早上开始，我就一直坚持这个。谢谢

4

7 回答 7

2

我会尝试对行进行排序，然后随机选择三个第一个元素中的一个。

// integer comparator
int compare(int * a, int * b) {return *a - *b;}

// allocate memory to hold the copy
int rowCopy[sizeof(piezas[myrow])/sizeof(int)];
// copy the row
memcpy(rowCopy, piezas[myrow], sizeof(piezas[myrow]));
// sort it
qsort(rowCopy, sizeof(piezas[myrow])/sizeof(int), sizeof(rowCopy[0]), compare);
// initialize the random number generator
srand(time(NULL));
// return randomly one of the first 3 elements
return rowCopy[rand() % 3]
于 2013-05-13T09:16:34.080 回答
1 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define SIZE_ROW 8
#define N_MIN 3


int piezas[SIZE_ROW][SIZE_ROW] = {
0, 2, 2, 5, 3, 2, 1, 1,
0, 4, 5, 2, 4, 3, 0, 0,
0, 4, 2, 2, 1, 2, 3, 2,
0, 3, 1, 5, 1, 2, 3, 4,
2, 5, 6, 5, 3, 1, 2, 7,
8, 2, 0, 0, 0, 2, 1, 1,
1, 2, 2, 1, 1, 6, 3, 4,
};

int sort(const void *x, const void *y) {
  return (*(int*)x - *(int*)y);
}

int* sort_array(int* row, int size_row){
    int* output = (int*) calloc(size_row, sizeof(int) );
    memcpy(output, row, size_row*sizeof(int) ); // copy array
    qsort (output, size_row, sizeof (int), sort);

    return output;

}

int random_pick(int* array, int size_row){
    return array[ rand() % size_row ]; // possible buffer overflow if size_row too big.
}

int main(void){
    srand(time(NULL));

    int myrow = 3; // the row I want to analyze
    int* sorted_row = NULL;


    int i,j;


    sorted_row = sort_array(piezas[myrow],SIZE_ROW );

    printf("N mins : \n");
    for(i=0;i<N_MIN;i++){
        printf(" %d ", sorted_row[i] );
    }
    printf("\n");

    printf("Random Pick : %d \n", random_pick(sorted_row, N_MIN) );


}
于 2013-05-13T09:34:08.450 回答
0

在 tmp_array（8 个元素）中创建一行的副本，然后qsort(tmp_array)，最后rand() % 3用作您的答案元素编号。

于 2013-05-13T09:15:36.910 回答
0

简单的解决方案是你有三个变量 min1、min2、min3 来保存三个最小变量。

于 2013-05-13T09:15:36.760 回答
0

取一个数组 numbers[3] 并将这三个值保存在其中。现在

int length = sizeof(numbers) / sizeof(int);
int randomNumber = numbers[rand() % length];
于 2013-05-13T09:21:41.803 回答
0

一般来说，您可以使用堆排序来获取数组中的N个最小元素，例如您选择的行，您不需要对所有元素进行排序。但请记住不要将排序结果保存在行本身中。并使用 rand() 来选择其中之一。

于 2013-05-13T09:42:09.680 回答
0 
#include <stdio.h>

int main(void){
    int piezas[8][8] = {
        0, 2, 2, 5, 3, 2, 1, 1,
        0, 4, 5, 2, 4, 3, 0, 0,
        0, 4, 2, 2, 1, 2, 3, 2,
        0, 3, 1, 5, 1, 2, 3, 4,
        2, 5, 6, 5, 3, 1, 2, 7,
        8, 2, 0, 0, 0, 2, 1, 1,
        1, 2, 2, 1, 1, 6, 3, 4,
    };

    int myrow = 3; // the row I want to analyze
    int index;
    int min[3]={99,99,99};//or INT_MAX at <limits.h>
    for (index=0;index<8;index++) {
        printf("%d", piezas[myrow][index] );
        int i, temp = piezas[myrow][index];
        for(i=0;i<3;++i){
            if(temp<=min[i]){
                int wk = min[i];
                min[i]=temp;
                temp = wk;
            }
        }
        printf(" ");
    }
    printf("min:");
    for(index=0;index<3;++index)
        printf(" %d", min[index]);
    return 0;
}
于 2013-05-13T10:07:46.390 回答