【蓝桥杯】剪格子

剪格子

如图所示，3 x 3 的格子中填写了一些整数。

我们沿着图中的红色线剪开，得到两个部分，每个部分的数字和都是60。

本题的要求就是请你编程判定：对给定的m x n 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。
　　如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。
　　如果无法分割，则输出 0

程序输入输出格式要求：
　　程序先读入两个整数 m n 用空格分割 (m,n<10)
　　表示表格的宽度和高度
　　接下来是n行，每行m个正整数，用空格分开。每个整数不大于10000
　　程序输出：在所有解中，包含左上角的分割区可能包含的最小的格子数目。

例如：
　　用户输入：

　　3 3
　　10 1 52
　　20 30 1
　　1 2 3

则程序输出：

　　3

再例如：
　　用户输入：

　　4 3
　　1 1 1 1
　　1 30 80 2
　　1 1 1 100

则程序输出：

　　10

(参见下图)

资源约定：
　　峰值内存消耗 < 64M
　　CPU消耗 < 5000ms

解的分析

• 如果所有格子数值的总和是奇数，那么一定无解
• 先给最小格子数初始化一个很大的数，如果有更新，那么就输出更新之后的结果，如果到最后最小格子数还是最初的那个数的话(即没有更新)，那么便无解

思路1(能过题但是不完善)

• 从左上角的格子出发，开始搜索，直到走过的格子的数值之和等于所有格子总和的一半，然后更新最小格子数，只做了一遍 $dfs$

代码如下

#include <climits>
#include <iostream>
#include <vector>
using namespace std;

const int to[][2] = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};

vector<vector<int>> mp;//如果编译出错的话，就写成vector<vector<int> > mp;，多加一个空格
vector<vector<bool>> vis;
int m, n;
int sum;//所有格子的总和
int ans = INT_MAX;//最小格子数

void dfs(int x, int y, int step, int tmp_sum) {
    if (tmp_sum == sum) {
    //当遍历到的所有格子数值之和与总和的一半相等时，更新格子数并返回
        ans = min(ans, step);
        return;
    }
    if (tmp_sum < sum) {
    //只有当遍历到的所有格子数值之和小于总和的一半时，才继续向下走
        for (int i = 0; i < 4; i++) {
            int tx = x + to[i][0];
            int ty = y + to[i][1];
            if (tx < 0 || tx >= n || ty < 0 || ty >= m || vis[tx][ty]) continue;
            vis[tx][ty] = true;
            dfs(tx, ty, step + 1, tmp_sum + mp[tx][ty]);
            vis[tx][ty] = false;
        }
    }
}

void solve() {
    scanf("%d%d", &m, &n);
    mp.resize(n);
    vis.resize(n);
    int i = 0, j = 0;
    for (i = 0; i < n; i++) {
        mp[i].resize(m);
        vis[i].resize(m, false);
        for (j = 0; j < m; j++) {
            scanf("%d", &mp[i][j]);
            sum += mp[i][j];
        }
    }
    if (sum % 2){
    //sum是奇数时直接输出0
        printf("0\n");
    } else {
        sum /= 2;//注意sum是偶数的话就变为它的一半
        vis[0][0] = true;
        dfs(0, 0, 1, mp[0][0]);
        printf("%d\n", (ans == INT_MAX) ? 0 : ans);
    }
}

int main(void) {
    solve();
    return 0;
}

上述代码有下面两组数据不能过：

2 2
1 1
1 3
预期输出：3
代码输出：0

3 3
10 10 10
10 1 1
10 10 58
预期输出：6
代码输出：0

思路2(我认为的通解)

• 暴力 $dfs$，毕竟数据那么小
• 以每一个格子为起点，都做一遍 $dfs$，做了 $m\times n$ 遍 $dfs$

代码如下

#include <climits>
#include <iostream>
#include <set>
#include <vector>
using namespace std;

const int to[][2] = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};

vector<vector<int> > mp;
vector<vector<bool> > vis;
int m, n;
int sum;
int ans;
bool is_split;

void init() {
    ans = INT_MAX;
    int i = 0, j = 0;
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++) {
            vis[i][j] = false;
        }
    }
}

void dfs(int x, int y, int step, int tmp_sum) {
    if (tmp_sum == sum) {
        if (!vis[0][0]) {
        //如果搜出来的答案中不包含左上角的格子，则更新为所有格子数减去答案格子数
            ans = min(ans, m * n - step);
        } else {
            ans = min(ans, step);
        }
        return;
    }
    if (tmp_sum < sum) {
        for (int i = 0; i < 4; i++) {
            int tx = x + to[i][0];
            int ty = y + to[i][1];
            if (tx < 0 || tx >= n || ty < 0 || ty >= m || vis[tx][ty]) continue;
            vis[tx][ty] = true;
            dfs(tx, ty, step + 1, tmp_sum + mp[tx][ty]);
            vis[tx][ty] = false;
        }
    }
}

void solve() {
    scanf("%d%d", &m, &n);
    mp.resize(n);
    vis.resize(n);
    int i = 0, j = 0;
    for (i = 0; i < n; i++) {
        mp[i].resize(m);
        vis[i].resize(m, false);
        for (j = 0; j < m; j++) {
            scanf("%d", &mp[i][j]);
            sum += mp[i][j];
        }
    }
    if (sum % 2)
        printf("0\n");
    else {
        sum /= 2;
        //遍历每一个格子，都做一遍dfs
        for (i = 0; i < n; i++) {
            for (j = 0; j < m; j++) {
                init();
                vis[i][j] = true;
                dfs(i, j, 1, mp[i][j]);
                if (ans != INT_MAX) {
                    is_split = true;
                    break;
                }
            }
            if (is_split) break;
        }
        printf("%d\n", (ans == INT_MAX) ? 0 : ans);
    }
}

int main(void) {
    solve();
    return 0;
}