蓝桥杯_剪格子

蓝桥杯_剪格子

问题描述

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

+----+--+
|10 1|52|
+--***--+
|20|30 1|
*******--+
| 1| 2| 3|
+--+--+--+

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

本题的要求就是请你编程判定：对给定的m x n 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。

如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。

如果无法分割，则输出 0。

输入格式

程序先读入两个整数 m n 用空格分割 (m,n<10)。

表示表格的宽度和高度。

接下来是n行，每行m个正整数，用空格分开。每个整数不大于10000。

输出格式

输出一个整数，表示在所有解中，包含左上角的分割区可能包含的最小的格子数目。

样例输入1

3 3
10 1 52
20 30 1
1 2 3

样例输出1

3

样例输入2

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

样例输出2

10

思路

这道题是很典型的深度优先搜索，一开始被剪刀的概念误导了，我以为一定要从边缘开始；

不过后来发现并不是，这道题其实就是分成两个区域，使得两个区域的数值相等，返回满足条件的区域中，包含左上角的区域的数量最少的情况；

那么这就很好解决了，在读取数据的时候先获取总和，然后从左上角开始dfs，搜索到一个格子的时候，判断当前总和是否达到全部总和的一半，如果已经达到则统计走过的格子数量，然后保存进ans数组中；如果超过一半那么直接返回；

最后排序ans数组，把符合条件的最少的格子数量输出即可；

我发现我dfs越来越熟练了，居然一次就ac了，开心：

#include <bits/stdc++.h>

using namespace std;

class Solution{
public:
	int rows, cols;
	int halfSum;
	int *vis;
	vector<vector<int> > graph;
	vector<int> ans;
	
	
	void dfs(int, int, int, int);
	void solve();
};

void Solution::solve() {
	int m, n, sum = 0;
	
	// 读取数据 
	cin>>m>>n;
	rows = n;
	cols = m;
	for (int i=0; i<n; i++) {
		vector<int> line;
		for (int j=0; j<m; j++) {
			int tmp;
			cin>>tmp;
			sum += tmp;
			line.push_back(tmp);
		}
		graph.push_back(line);
	}
	halfSum = sum/2;
	
	// dfs
	vis = new int[m*n];
	memset(vis, 0, m*n*sizeof(int));
	dfs(0, 0, 0, 0);
	
	// 输出
	if (ans.size()==0){
		cout<<0<<endl;
	}else {
		sort(ans.begin(), ans.end());
		cout<<ans[0]<<endl;
	}
}

void Solution::dfs(int x, int y, int sum, int count) {
	// 检查边界 
	if (x<0 || x>=rows || y<0 || y>=cols) {
		return;
	}
	// 检查是否已经访问过 
	int pos = x*cols+y;
	if (vis[pos]) {
		return;
	}
	// 检查是否达到半数，如果超过则返回，因为数字均大于0，再增加只会更大 
	sum += graph[x][y];
	++count;
	if (sum == halfSum) {
		ans.push_back(count);
	}else if (sum > halfSum) {
		return;
	}
	
	// 上下左右四个方向搜索 
	vis[pos] = 1;
	dfs(x-1, y, sum, count);
	dfs(x+1, y, sum, count);
	dfs(x, y-1, sum, count);
	dfs(x, y+1, sum, count);
	vis[pos] = 0;
}

int main(void) {
	Solution su;
	su.solve();
	return 0;
}