算法训练 | 剪格子（dfs + 剪枝 + 回溯）

题目描述
如下图所示，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

public class 剪格子 {
	static int [][] arr;
	static int [][] visit;
	static int m;
	static int n;
	static int total;
	static int count=Integer.MAX_VALUE;//必须初始化为最大值，否则系统自动初始化为0，就不管怎样它都是最小了
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		m=sc.nextInt();//列
		n=sc.nextInt();//行
		total = 0;
		visit=new int[n][m];
		arr=new int[n][m];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				arr[i][j]=sc.nextInt();
				visit[i][j]=0;
				total+=arr[i][j];
			}
		}
		dfs(0,0,0,0);
		System.out.println(count);
	}
	/*i:行数
	 * j:列数
	 * sum:总和
	 * num:格子数
	 * visit[][]:是否访问过
	*/
	private static void dfs(int i,int j,int sum,int num) {
		if(i>=n || j>=m || i<0 ||j<0|| sum>total/2 || visit[i][j]==1) return ;
		
		if(sum==total/2){//符合要求
			//因为可能两条线（或以上）都能满足 sum==total/2，但是题目要求输出最小格子数
			count= Math.min(count, num);//对一个二维数组剪格子，可能会进来这个if不止一次，所以是可能有多个num值的，需要取最小			
			return;			
		}
		
		//每次向前走一个格子，就把这个格子标注为已访问，置1
		visit[i][j]=1;
		
		//每次  sum+下一步要走的格子上面的数值；并且 走过的格子数num + 1
		//四种情况可以理解为兄弟关系，所以并排写
		dfs(i+1,j,sum+arr[i][j],num+1);//下
		dfs(i-1,j,sum+arr[i][j],num+1);//上
		dfs(i,j+1,sum+arr[i][j],num+1);//右
		dfs(i,j-1,sum+arr[i][j],num+1);//左
		
		//每次访问完，退出，清空访问状态，让 "当前节点" 的 "父节点" 的 "平行节点" 能够允许再访问 "当前节点"
		visit[i][j]=0;				
	}	
}

测试1：

测试2：