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);
        }
    }
}