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

e.g。

首先执行

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）处的元素。

e.g。

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语言实现的是在矩阵上检查“行数列”。

我真的不知道怎么做。

一些建议？

提前致谢。

Answer 1

只是想通了，为了解决这个问题，我应该采用类似于矩阵乘法的方法。

而不是

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 2

解决了！

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

Answer 3

您可以更具体地了解您要比较的行/列吗？如果我确切地知道你在比较什么，我会以什么顺序帮助你。到目前为止，这是我能给你的。这是一个用于查找数组最小值的函数

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 4

我想这会有所帮助。

“算法”应计算新矩阵的每个新元素。

顺便说一句......

您有一个输入矩阵，例如firstMatrix。

第一步：获取firstMatrix第一行中的第一个元素以及firstMatrix第一列的第一个元素：firstMatrix[0][0]和firstMatrix[0][0]

第二步：为firstMatrix的每一行和第一行重复“第一步”：

/* 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 }
                  }

MaxMin矩阵组成

4 个答案: