Java-POJ1011-sticks

很经典的搜索题，直接爆搜会卡在连续相同长度的木棍，可以先排序，预处理该长度不行直接跳下一长度木棍的位置

但此题特殊，木棍长度小于50，我们可以直接桶排序

还有就是关于回溯的理解：

我们写的dfs为的是判断ans是否可行，可行解自然已经被记录下来了，并且一路return即，若回溯到了相同or类似情况，说明必定不能符合题意

TIPS：桶排序+可行性剪枝

 package poj.ProblemSet;

 import java.util.Scanner;

 public class poj1011 {
     public static final int MAXN = 100;
     public static int[] bucket = new int[MAXN];
     public static int  ans, flag, sum, maxn, minn;

     public static void dfs(int res, int sum, int p) {
         if (res == 0||flag==1) { flag = 1;return; }
         if (sum == ans) { dfs(res - 1, 0, maxn);return;}
         for (int i = p; i >= minn; i--) {
             if (bucket[i]>0 && i + sum <= ans) {
                 bucket[i]--;
                 dfs(res, sum + i, i);//(*)
                 bucket[i]++;
                 if (sum == 0 || sum + i == ans) break;
                 //执行此句说明(*)行尝试失败，因此到达当前情况的搜索均可剪枝
             }
         }
     }

     public static void main(String[] args) {
         Scanner cin = new Scanner(System.in);
         for (int n = cin.nextInt(); n != 0; n = cin.nextInt()) {
             sum = flag = maxn = 0;minn = MAXN;
             for (int i = 0; i < MAXN; i++) bucket[i] = 0;
             for(int i=1;i<=n;i++) {
                 int temp = cin.nextInt();
                 bucket[temp]++;
                 sum += temp;
                 maxn = Math.max(maxn, temp);
                 minn = Math.min(minn, temp);
             }
             int INF = sum / 2;
             for (int i = maxn; i <= INF; i++)
                 if (sum % i == 0) {
                     ans = i;
                     dfs(sum / i, 0, maxn);
                     if(flag==1)break;
                 }
             if (flag == 1) System.out.println(ans);
             else System.out.println(sum);
         }
     }
 }