这个题目看到想着把矩阵分行解决，后来头都想破了，也没想到好的解决办法，看到博客有说是二分图求最小边权覆盖集问题，但本人不了解二分图，最终采用暴力求解方法：
1.选取最少数量个数：先把每行和每列取出的数目记录在i,j两个数组中，初始化为0，对矩阵从小到大排序，从0开始循环从矩阵中取i,j均为0的数，每取出一个数，将其行列对应的i,j值加一，并设置其对应的flag为true,循环结束时，得到min(m,n)个数，然后从剩下的没有取数的行（或列）（即i = 0或j = 0）中取该行（或列）中的最小数。
2.选取和最小的数：从大到小更新选出的数据，当其i,j均为1时，找它所处的行和列的最小值，若二者之和小于该数，则抛弃该数选出之前找到的两个数；当其i,j均大于1时，说明不需要该数，弃之；当其i=1,j>1时，说明j列不需要该数， 若该列的最小值小于该数，弃之，选出之前找到的最小值；当其i>1,j=1时，说明i行不需要该数， 若该行的最小值小于该数，弃之，选出之前找到的最小值；
3.计算和：计算flag=true的元素数值的和，即为最小值。
代码如下：
格格取数：#include<iostream>
using namespace std;
struct Node
{
int i;
int j;
int element;
bool flag = false;
// Node(int a, int b, int c, bool f = false) :i(a), j(a), element(c), flag(f){};
};
int *i;//用来保存每行取了多少个数
int *j;//用来保存每列取了多少个数
int partion(Node *A, int left, int right)
{
int x = A[right].element;
int q = left - 1;
for (int p = left; p < right; p++)
if (A[p].element <= x)
{
q++;
Node t = A[p];
A[p] = A[q];
A[q] = t;
}
q++;
Node t = A[right];
A[right] = A[q];
A[q] = t;
return q;
}void sub_sort(Node *A, int left, int right)
{
if (left < right)
{
int q = partion(A, left, right);
sub_sort(A, left, q - 1);
sub_sort(A, q + 1, right);
}
else
return;
}
void sort(Node *A, int length)
{
sub_sort(A, 0, length - 1);
}
void getnum(Node *A, int m, int n)
{
sort(A, m*n);
i = new int[m];//用来保存每行取了多少个数
j = new int[n];//用来保存每列取了多少个数
for (int p = 0; p <= m; p++)
i[p] = 0;
for (int p = 0; p <= n; p++)
j[p] = 0;
int t = 0;
for (int q = 0; q < m*n; q++)
{
if ((i[A[q].i] == 0) && (j[A[q].j] == 0))
{
i[A[q].i] ++;
j[A[q].j] ++;
A[q].flag = true;
t++;
}
}
int a = 0;
if (m != n)
{
t == m ? a = 1 : a = 0;
//a= 0表示t= n，每一列都有取值，但不是每一行都有取值
if (!a)
{
for (int p = 0; p <= m; p++)
{
if (i[p] == 0)//i[p] == 0表示p行没有取到数
{
for (int q = 0; q < m*n; q++)
{
if (A[q].i == p)
{
i[A[q].i] ++;
j[A[q].j] ++;
A[q].flag = true;
break;
}
}
}
}
}
else
{
for (int p = 0; p <= n; p++)
{
if (j[p] == 0)//j[p] == 0表示p列没有取到数
{
for (int q = 0; q < m*n; q++)
{
if (A[q].j == p)
{
i[A[q].i] ++;
j[A[q].j] ++;
A[q].flag = true;
break;
}
}
}
}
}
}
}
void updatenum(Node *A, int m, int n)
{
for (int p = m*n-1; p >= 0 ; p--)
{
if (A[p].flag)
{
Node *B = new Node[2];
int a = 0;
int b = 0;
B[0].element = -1;
B[1].element = -1;
if (i[A[p].i] == 1 & j[A[p].j] == 1)//第A[p]行列只取到一个数时，找出同一行列最小的数，若二者之和小于A[p]则进行替换
{
for (a = 0; a < p; a++)
if (A[a].i == A[p].i)
{
B[0] = A[a];
break;
}
for (b = 0; b< p; b++)
if (A[b].j == A[p].j)
{
B[1] = A[b];
break;
}
if ((B[0].element != -1) & (B[1].element != -1))
{
if (B[0].element + B[1].element < A[p].element)
{
i[A[b].i]++;
i[A[a].i]++;
j[A[b].j]++;
j[A[a].j]++;
i[A[p].i]--;
j[A[p].j]--;
A[p].flag = false;
A[b].flag = true;
A[a].flag = true;
}
}
}
else if (i[A[p].i] > 1 & j[A[p].j] > 1)
A[p].flag = false;
else if (i[A[p].i] > 1)
{
for (a = 0; a < p; a++)
if (A[a].j == A[p].j)
{
i[A[a].i]++;
j[A[a].j]++;
i[A[p].i]--;
j[A[p].j]--;
A[a].flag = true;
A[p].flag = false;
break;
}
}
else if (j[A[p].j] > 1)
{
for (b = 0; b < p; b++)
if (A[b].i == A[p].i)
{
i[A[b].i]++;
j[A[b].j]++;
i[A[p].i]--;
j[A[p].j]--;
A[b].flag = true;
A[p].flag = false;
break;
}
}
}
}
}
long long minsum(Node *A, int m, int n)
{
long long sum = 0;
for (int p = m*n - 1; p >= 0; p--)
if (A[p].flag)
sum += A[p].element;
return sum;
}
int main()
{
int T;
cin >> T;
long long *sum = new long long[T];
for (int s = 0; s < T; s++)
{
sum[s] = 0;
int m, n;
cin >> m >> n;
int p = 0;
Node *A = new Node[m*n];
for (int q = 0; q < m; q++)
{
for (int t = 0; t < n; t++)
{
A[p].i = q;
A[p].j = t;
cin >> A[p].element;
p++;
} }
getnum(A, m, n);
updatenum(A, m, n);
sum[s] = minsum(A, m, n);
}
for (int p = 0; p < T; p++)
cout << "Case " << p+1 << ": " << sum[p] << endl;
return 0;
}
`
