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); 
}