关于编程之美2014格格取数

个人感觉是ac了，只不过没有注册编程之美的号，所以没有办法测试，反正对于自己手写的几个例子都正确。这里偷了一下懒，就是把行数限制为64个以内，这样好做位操作。当然可以用两个长整型来表示，这样就可能比较麻烦了。有意愿的人自己去完善吧。核心思想是预处理加减枝加深搜，复杂度最坏指数级没办法。下面贴一下题目。

描述

给你一个m x n (1 <= m, n <= 100)的矩阵A (0<=a_ij<=10000)，要求在矩阵中选择一些数，要求每一行，每一列都至少选到了一个数，使得选出的数的和尽量的小。

#include <iostream>
#include <stack>
#include <bitset>
#include <set>

using namespace std;
int current_sum=0;
int total_min = 0;//total_min是用来减枝，是全局最小的一个上限
int row_number;
int colomn_number;
int** int_matrix;
int* row_covered;
int row_left;
int colomn_left;
long long  row_set[100];
long long used_row_set[100];
int temp_bitsum[100];
int count_sum(long long  row_bit_set, int current_colomn_number)
{
    int temp_sum = 0;
    int row_position = 0;
    while (row_bit_set)
    {
        temp_sum += (row_bit_set%2) * int_matrix[row_position++][current_colomn_number];
        row_bit_set=row_bit_set >> 1;
    }
    return temp_sum;
}
int all_covered()
{
    for (int i = 0; i < row_number; i++)
    {
        if (row_covered[i] == 0)
        {
            return 0;
        }
    }
    return 1;
}
void dfs(int current_colomn)
{
    long long temp_bitset = row_set[current_colomn];
    while (temp_bitset)
    {
        used_row_set[current_colomn] = temp_bitset;
        temp_bitsum[current_colomn] = count_sum(temp_bitset, current_colomn);
        if (current_sum + temp_bitsum[current_colomn] < total_min)//只有小于的时候才有必要进行下一次深度优先或者结束本次深度优先
        {
            current_sum = current_sum + temp_bitsum[current_colomn];
            for (int i = 0; i < row_number; i++)//对行进行mask
            {
                row_covered[i] += temp_bitset%2;
                temp_bitset=temp_bitset >> 1;
            }
            if (current_colomn == colomn_number-1)
            {
                if (all_covered())//如果已经全部覆盖了，则表示这次深度优先搜索成功
                {
                    total_min = current_sum ;//更新最小值
                }
                else//回溯，进行下一次试探
                {
                    //什么都不需要干
                }
                //进行下一次试探
            }
            else
            {
                
                dfs(current_colomn + 1);//对下一列做dfs
            }
            temp_bitset = used_row_set[current_colomn];
            for (int i = 0; i < row_number; i++)//回溯 对行进行unmask
            {
                row_covered[i] -= temp_bitset % 2;
                temp_bitset=temp_bitset >> 1;
            }
            current_sum -= temp_bitsum[current_colomn];//回溯 将和往回降
        }
        temp_bitset = used_row_set[current_colomn];
        temp_bitset = (temp_bitset - 1)&row_set[current_colomn];
    }
}
int main()
{

    cout << "please enter the row number" << endl;
    cin >> row_number;
    cout << "please enter the colomn number" << endl;
    //cin.get();//吃掉那一行，如果会换行的话
    cin >> colomn_number;
    cin.get();
    int_matrix = new int*[row_number];
    int_matrix[0] = new int[row_number*colomn_number];
    set<pair<int, int>> min_position;
    for (int i = 1; i < row_number; i++)
    {
        int_matrix[i] = int_matrix[i - 1] + colomn_number;
    }
    for (int i = 0; i < row_number; i++)
    {
        for (int j = 0; j < colomn_number; j++)
        {
            cin >> int_matrix[i][j];
        }
    }
    //下面记录行最小值和列最小值是为了减枝用
    int* row_min = new int[row_number];
    int* colomn_min = new int[colomn_number];
    for (int i = 0; i < row_number; i++)//寻找行最小值
    {
        row_min[i] = 0;
        for (int j = 1; j < colomn_number; j++)
        {
            if (int_matrix[i][row_min[i]]>int_matrix[i][j])
            {
                row_min[i] = j;
            }
        }
        min_position.insert(make_pair(i, row_min[i]));
    }
    for (int i = 0; i < colomn_number; i++)//寻找列最小值
    {
        colomn_min[i] = 0;
        for (int j = 1; j < row_number; j++)
        {
            if (int_matrix[colomn_min[i]][j]>int_matrix[j][i])
            {
                colomn_min[i] = j;
            }
        }
        min_position.insert(make_pair(colomn_min[i], i));
    }
    for (auto temp_pair : min_position)
    {
        total_min += int_matrix[temp_pair.first][temp_pair.second];
    }
    for (int i = 0; i < colomn_number; i++)//初始化行的位数组
    {
        row_set[i] = (1 << row_number) - 1;
    }
    for (int i = 0; i < row_number; i++)
    {
        for (int j = 0; j < colomn_number; j++)
        {
            if (int_matrix[i][j]>int_matrix[i][row_min[i]] + int_matrix[colomn_min[j]][j])
            {
                row_set[j]=row_set[j]&(~(1<<i));//标记为不可用
            }
        }
    }
    //准备开始深度优先搜索
    row_covered = new int[row_number];
    memset(row_covered, 0, sizeof(int) *row_number);
    dfs(0);
    cout << "current total min is " << total_min << endl;
}

样例数据和自己编的几组数据都过了，还待其他数据验证。