编程之美-格格取数

这个题目看到想着把矩阵分行解决，后来头都想破了，也没想到好的解决办法，看到博客有说是二分图求最小边权覆盖集问题，但本人不了解二分图，最终采用暴力求解方法：
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;

}
`