剪格子-Java

题目描述：

历届试题  剪格子  
时间限制：1.0s     内存限制：256.0MB 
     
问题描述 
如下图所示，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 5
10 20 30 1
1 1 40 1 
1 60 50 1 
1 150 1 1 
1 1 1 348

样例输出2：

7

参考解答：

import java.util.Scanner;
import java.util.Vector;
import java.util.Arrays;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int[] arr = new int[m * n];
		for (int i = 0; i < m * n; i++) {
			arr[i] = sc.nextInt();
		}
		System.out.println(species(arr, m, n));
	}
	
	private static int species(int[] arr, int m, int n) {
		if (arr.length <= 2) {
			return 1; 
		}
		boolean[] visited = new boolean[m * n];
		Arrays.fill(visited, false);
		int species = 0;
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		int target = sum / 2;
		sum = 0;
		int difference = target - sum;
		Vector<Integer> storage = new Vector<Integer>();
		storage.add(0);
		visited[0] = true;
		while (storage.size() != 0) {
			int delete_index = 0;
			int index = storage.get(delete_index);
			for (int i = 1; i < storage.size(); i++) {
				if ((arr[storage.get(i)] > arr[index] && arr[storage.get(i)] <= difference) || arr[index] > difference) {
					delete_index = i;
					index = storage.get(delete_index);
				}
			}	
			sum += arr[index];
			difference = target - sum;
			species++;
			storage.remove(delete_index);
			if (index + 1 < m * n && !visited[index + 1]) {
				storage.add(index + 1);
				visited[index + 1] = true;
			}
			if (index + n < m * n && !visited[index + n]) {
				storage.add(index + n);
				visited[index + n] = true;
			}				
			if (index - n >= 0 && !visited[index - n]) {
				storage.add(index - n);
				visited[index - n] = true;
			}
			if (index >= 1 && (index - 1) % n != 0 && !visited[index - 1]) {
				storage.add(index - 1);
				visited[index - 1] = true;
			}
			if (sum == target) {
				break;
			}
			
		}
		return species;
	}
	
}