如何在C中找到矩阵中元素的所有唯一位置集？

对于5×5矩阵，我需要解决以下问题，但为了解释，我将使用一个3×3矩阵的示例：

A = { { 1, 3, 2 }
     ,{ 3, 2, 3 } 
     ,{ 0, 4, 5 } };

我需要找到所有不同的3个位置集（因为矩阵是3x3），这些位置与其他位置集不共享行或列，计算每个位置集的A元素的总和，并打印这些总和的最小值

Position = (0,0),(1,1),(2,2) sum = 1+2+5 = 8
           (0,0),(1,2),(2,1) sum = 1+3+4 = 8
           (0,1),(1,0),(2,2) sum = 3+3+5 = 11
           (0,1),(1,2),(2,0) sum = 3+3+0 = 6
           (2,0),(1,1),(0,2) sum = 0+2+2 = 4
           .       
           .       
           .       

（我认为你理解了主要原则）

所以输出必须包括：（2,0），（1,1），（0,2）最小和=4

---

请记住：我实际上需要对5×5矩阵执行此操作。

一种功能性的方法，尽管很幼稚，但它是使用6 for循环（5嵌套）。从0循环到2，顶部循环将其迭代#存储在int中（例如称为firstRow）。类似地，第二个循环将存储firstCol。第三个循环将用于存储第二行，因此如果

secondRow==firstRow

，则需要

继续。对于最后两个循环，您需要对照其他两个循环的索引进行检查。在最里面的嵌套循环中，使用3个坐标对调用findSum函数

testCoords(*arr1, *arr2, *arr3)
{
    #get the sum
}

#algorithm defined for n = 3 
mySearch(n)
{
    int coord1[2], coord2[2], coord3[2]; #assume 3by3
    int minSum = n * MAX_VAL, obsSum;

    for (int r1 = 0; r1 < n; r1++)
    {
        coord1[0] = r1;

        for (int c1 = 0; c1 < n; c1++)
        {
            coord1[1] = c1;

            for (int r2 = 0; r2 < n; r2++)
            {
                if (r1 != r2)
                {
                    coord2[0] = r2;

                    for (int c2 = 0; c2 < n; c2++)
                    {
                        if (c1 != c2)
                        {
                            coord2[1] = c2;

                            for (int r3 = 0; r3 < n; r3++)
                            {
                                if (r1 != r3 && r2 != r3)
                                {
                                    coord3[0] = r3;

                                    for (int c3 = 0; c3 < n; c3++)
                                    {
                                        coord3[1] = c3;

                                        obsSum = testCoords(coord1, coord2, coord3);
                                        if (obsSum < minSum)
                                        {

                                            minSum = obsSum;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

}

testCoords（*arr1，*arr2，*arr3）
{
#得到总数
}
#为n=3定义的算法
我的研究（n）
{
int coord1[2]，coord2[2]，coord3[2]；#假设3by3
int minSum=n*最大值，obsum；
对于（int r1=0；r1

这对于n=3或n=5这样的小数组来说是很好的，但是迭代的次数很快就会变得可笑，因为它的n^（n*2）。例如，即使使用5x5矩阵，也要进行1000万次迭代（更不用说冗长的算法了）。一个更具动态性的算法或者一个树实现可能很适合这里。例如，递归方法可以找到一个索引对（消除一行和一列），然后使用结果（n-1）*（n-1）2d数组调用自己——如下所示：

int minSum=n*MAX\u VAL；
合作搜索（整数**矩阵，n）
{
int thiscord[2]；
如果（n==1）
{
返回矩阵[0][0]；
}
其他的
{
对于（int i=0；i

<3>对于3x32D数组，递归方法将查看顶层上的9个坐标对，然后在下一级，我们将处理2x2D数组，所以我们只考虑4个坐标对，然后在底层，我们只返回在我们的1x1“2D数组”中的任何值。复杂性为n^2*（n-1）^2*。*1.但是请记住，每个“步骤”都需要更新矩阵，这是一个操作密集的过程。
这里还有另一个建议：矩阵中要使用的所有位置集都可以表示为一个单位矩阵的排列，其“1”项告诉您要添加哪些矩阵元素。然后取所有排列的和集合的最小值。您可以使用简单数组表示置换，因为在NxN单位矩阵的置换中只有N个元素等于1。所以调用数组p，其中p（i）告诉您要使用第i行上的哪一列

这里的基本观察结果是，你需要NxN单位矩阵的所有置换，你可以把它们表示为（0,1，…，N-1）的置换

伪代码可能如下所示：

Given: an NxN matrix (2-D array), M, for which you want the minimal sum of N
       elements with no subset falling on the same row or column

minsum = N * max entry in M (just initialized to guarantee >= min sum sought)
foreach permutation p of (0,1,...,N-1):
   sum = 0
   for i = 0:N-1:
      sum += M(i,p(i))
      if sum >= minsum: break; # (if we already know this isn't a new min, move on)
   if sum < minsum: minsum = sum
print("minimum sum = ", minsum)

给定：一个NxN矩阵（2-D数组），M，你想要N的最小和
没有子集的元素落在同一行或列上
minsum=N*以M为单位的最大条目（刚刚初始化以保证>=最小求和）
（0,1，…，N-1）的foreach置换p：
总和=0
对于i=0:N-1:
总和+=M（i，p（i））
如果总和>=分钟：中断；#（如果我们已经知道这不是新的min，请继续）
如果总和<最小值：最小值=总和
打印（“mi
Given: an NxN matrix (2-D array), M, for which you want the minimal sum of N
       elements with no subset falling on the same row or column

minsum = N * max entry in M (just initialized to guarantee >= min sum sought)
foreach permutation p of (0,1,...,N-1):
   sum = 0
   for i = 0:N-1:
      sum += M(i,p(i))
      if sum >= minsum: break; # (if we already know this isn't a new min, move on)
   if sum < minsum: minsum = sum
print("minimum sum = ", minsum)