POJ1011

题目：http://acm.pku.edu.cn/JudgeOnline/problem?id=1011

思路：深度搜索+剪枝，主要还是看你剪枝条件想的多不多。。。

 

1. import java.io.BufferedReader;
2. import java.io.InputStreamReader;
3. import java.util.Arrays;
4. import java.util.StringTokenizer;
6. public class Main {
8.     // 标记是否使用过这个棒子，在递归时后需要标记
9.     static boolean[] used;
10.     // 棒子总数量
11.     static int len;
12.     // 棒子的数组
13.     static int[] s;
14.     // 总长度
15.     static int sum;
16.     // 假设的原棒长
17.     static int max;
18.     // 棒子数量 = 总长度/原棒长
19.     static int parts;
21.     public static void main(String[] args) throws Exception {
22.         BufferedReader read = new BufferedReader(new InputStreamReader(
23.                 System.in));
24.         while ((len = Integer.parseInt(read.readLine())) != 0) {
25.             s = new int[len];
26.             StringTokenizer take = new StringTokenizer(read.readLine());
27.             int index = 0;
28.             sum = 0;
29.             used = new boolean[len];
30.             while (take.hasMoreTokens()) {
31.                 s[index] = Integer.parseInt(take.nextToken());
32.                 sum += s[index++];
33.             }
34.             Arrays.sort(s);
35.             // 起始假设原棒长=最长棒的长度
36.             max = s[len - 1];
37.             for (; max <= sum; max++) {
38.                 // 穷举棒子长度，只取总长度模原长度=0的情况
39.                 if (sum % max == 0) {
40.                     // 原棒的数量
41.                     parts = sum / max;
42.                     // 递归搜索
43.                     if (search(0, len - 1, 0)) {
44.                         System.out.println(max);
45.                         break;
46.                     }
47.                 }
48.             }
49.         }
50.     }
52.     public static boolean search(int res, int next, int cpl) {
53.         // 如果凑成了一根棒子，继续凑下面一个
54.         if (res == max) {
55.             // 这个是现在这个棒子的长度，初始化为0
56.             res = 0;
57.             // 这里等于len-2只是一个初始化，反正len-1肯定被占用了，我何不从len-2开始呢，反正后面还要判断有没有被使用过
58.             next = len - 2;
59.             // 这个是已经凑成的棒子数
60.             cpl++;
61.         }
62.         // 如果凑成了parts这么多棒子，那就结束了，搜索完成
63.         if (cpl == parts) {
64.             return true;
65.         }
66.         // 从后往前搜索
67.         while (next >= 0) {
68.             // 如果没有被使用的话
69.             if (used[next] == false) {
70.                 // 那么判断下这根棒子能不能放进我现在剩余的空间里面
71.                 if (res + s[next] <= max) {
72.                     // 能放得进的话，那么标记这跟棒子已经使用过了
73.                     used[next] = true;
74.                     // 继续寻找下一根
75.                     if (search(res + s[next], next - 1, cpl)) {
76.                         // 返回结果为true表示全部凑成功了
77.                         return true;
78.                     }
79.                     // 如果没有凑成功，我把这根棒子不放进去并标记为false
80.                     used[next] = false;
81.                     // 如果第一块的都没放不进去的话，那么说明找的有问题，直接退出了
82.                     if (res == 0) {
83.                         break;
84.                     }
85.                     // 如果现在本来应该尝试成功的（已经拼成了一个原棒，应该进入递归变成0的）却失败了，说明找的有问题
86.                     if (res + s[next] == max) {
87.                         break;
88.                     }
89.                 }
90.                 // 找下一块不相等的棒子
91.                 int i = next - 1;
92.                 while (i >= 0 && s[i] == s[next]) {
93.                     i--;
94.                 }
95.                 next = i;
96.                 // 如果剩下的和比我需要的棒子还小的话，就不用凑了
97.                 int l_s = 0;
98.                 for (int j = next; j >= 0; j--) {
99.                     if (!used[j]) {
100.                         l_s += s[j];
101.                     }
102.                 }
103.                 if (l_s < max - res) {
104.                     break;
105.                 }
106.                 // 继续找下面的棒子
107.                 continue;
108.             }
109.             // 说明这个棒子被用过了，找下面一个棒子
110.             next--;
111.         }
112.         // 如果从这里出来的话，表示程序不能凑完所有棒子
113.         return false;
114.     }
115. }