MaxMin矩陣組成

Question

我正在模糊分類。因爲我不是一個真正的軟件開發人員......只是意識到我無法在C語言中實現矩陣上的最大 - 最小組合。

我會盡量更清楚。

假設你已經有了一個方陣，就像這樣：

float matrix[2][2] = { 
         { 1.0, 0.4 }, 
         { 0.4, 1.0 } 
        }; 

本身的 「矩陣」 最大最小組成，yelds

result_matrix[2][2] = { 
         { 1.0, 0.4 } 
         { 0.4, 1.0 } 
         }; 

例如

首先執行

min(1.0, 0.4) = 0.4 /* first row */ 
min(1.0, 0.4) = 0.4 /* first col */ 

然後

max(0.4, 0.4) = 0.4是這樣的元件（0，0）的新的矩陣的。

例如在

min(1.0, 0.4) = 0.4; /* first row */ 
min(0.4, 1.0) = 0.4; /* second col */ 

max(0.4, 0.4) = 0.4; 

元素（0,1）

我需要實現，在C語言是什麼，是一種「行通過的cols」檢查矩陣。

我真的不知道該怎麼做。

有些建議？

在此先感謝。

Answer 1

你可以更具體一點，你比較哪些行/列？如果我確切地知道你在比較什麼，以什麼順序我可以幫助你更多。這是我迄今可以給你的。下面是找到一個數組

float min(int n, float *array) 
{ 
    int i; 
    float minval; 

    minval = *array; 

    for (i=1; i<n;i++) 
    { 
     if (array[i] < minval) 
     minval = array[i]; 
    } 

    return minval; 
} 

要在第一行的最低值的最小值的函數，你會使用

x = min(2, *matrix); 

對於其他行

x = min(NUMCOLS, *matrix+row*NUMCOLS + column)); 

而對於通過列訪問矩陣的元素使用兩個嵌套for循環

for (i = 0; i < 2; i++) 
    for (j = 0; j < 2; j++) 
     printf("%f\n", matrix[i][j]); 

看看Row-major_order

Answer 2

我想這會有所幫助。

「算法」應計算新矩陣的每個新元素。

順便說一句...

你必須輸入矩陣如firstMatrix。

步驟一：firstMatrix[0][0]和firstMatrix[0][0]

第二步：從firstMatrix第一排和firstMatrix第一欄的第一個元素獲得的第一個元素重複「第一步」爲firstMatrix每一行和col ：

/* row */ 
temp_array_1[i] = firstMatrix[i][j] 

和

/* col */ 
temp_array_2[i] = firstMatrix[j][i] 

步驟三：

for (i = 0; i < 4; i++) 
{ 
    if (temp_array_1[i] <= temp_array_2[i]) 
    { min_array[i] = temp_array_1[i]; } 

    else 
    { min_array[i] = temp_array_2[i]; } 
} 

第四步：取得min_array[i]的最大值。

這裏緊跟我的源代碼...

#include <stdio.h> 
#include <stdlib.h> 

int main(int argc, char **argv) 
{ 
    int i; 

    int j; 

    float firstMatrix[4][4] = { 
           { 1, 0.6, 0.3, 0.8 }, 
           { 0.6, 1, 0.1, 0.4 }, 
           { 0.3, 0.1, 1, 0.5 }, 
           { 0.8, 0.4, 0.5, 1 } 
          }; 


    float max = 0.0; 

    float temp_array_1[4]; 

    float temp_array_2[4]; 

    float min_array[4]; 


     for (i = 0; i < 4; i++) 
     { 
     /* row */ 
     temp_array_1[i] = firstMatrix[0][i]; 

     /* col */ 
     temp_array_2[i] = firstMatrix[i][0]; 
     } 

     for (i = 0; i < 4; i++) 
     { 
      if (temp_array_1[i] <= temp_array_2[i]) 
      { min_array[i] = temp_array_1[i]; } 

      else 
      { min_array[i] = temp_array_2[i]; } 

      for (i = 0; i < 4; i++) 
      {   
        if (min_array[i] > max) 
        { max = min_array[i]; }   
      } 
     } 

    fprintf(stdout, "\nMax element: %.1f\n", max); 

    return 0; 
} 

的一點是，我不能夠「迭代」本作的firstMatrix每個元素。

散發出來，從這個烏煙瘴氣的輸出矩陣是這樣的：

outputMatrix[4][4] = { 
        { 1.0, 0.6, 0.5, 0.8 }, 
        { 0.6, 1.0, 0.4, 0.6 }, 
        { 0.5, 0.4, 1.0, 0.5 }, 
        { 0.8, 0.6, 0.5, 1.0 } 
        } 

Answer 3

就想通了，爲了解決這個問題，我應該遵循類似於用於矩陣乘法的一個辦法。

而不是

resultMatrix[i][j] += firstMatrix[i][k] * firstMatrix[k][j]; 

我需要的是這樣的

resultMatrix[i][j] = MAX(MIN(firstMatrix[i][k], firstMatrix[k][j])); 

哪裏MIN(firstMatrix[i][k], firstMatrix[k][j])只是另一個數組。

我想。

Answer 4

解決！

這裏是max-min合成的源代碼。

#include <stdio.h> 
#include <stdlib.h> 

float get_max(float a[], int num_elements); 

int main(int argc, char **argv) 
{ 
    int i; 

    int j; 

    int k; 

    float firstMatrix[4][4] = { 
           { 1, 0.6, 0.3, 0.8 }, 
           { 0.6, 1, 0.1, 0.4 }, 
           { 0.3, 0.1, 1, 0.5 }, 
           { 0.8, 0.4, 0.5, 1 } 
          }; 


    float resultMatrix[4][4]; 

    float min_array[4]; 

     for (i = 0; i < 4; i++) 
     { 
      for (j = 0; j < 4; j++) 
      { 
        for (k = 0; k < 4; k++) 
        { 
         if (firstMatrix[i][k] <= firstMatrix[k][j]) 
         { min_array[k] = firstMatrix[i][k]; } 

         else 
         { min_array[k] = firstMatrix[k][j]; } 

        resultMatrix[i][j] = get_max(min_array, 4);           
        } 

       fprintf(stdout, "%.1f ", resultMatrix[i][j]);     
      } 

     fprintf(stdout, "\n"); 
     } 

    return 0; 
} 

float get_max(float a[], int num_elements) 
{ 
    int i; 

    float max = 0.0; 

     for (i = 0; i < num_elements; i++) 
     { 
     if (a[i] > max) 
     { max = a[i]; } 
     } 

    return(max); 
}