POJ 1011-Sticks

http://poj.org/problem?id=1011&lang=default&change=true

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    static boolean[] used;
    static int len;
    static int[] s;
    static int sum;
    static int max;
    static int parts;

    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        while ((len = Integer.parseInt(reader.readLine())) != 0) {
            s = new int[len];
            StringTokenizer take = new StringTokenizer(reader.readLine());
            int index = 0;
            used = new boolean[len];
            sum = 0;
            while (take.hasMoreTokens()) {
                s[index] = Integer.parseInt(take.nextToken());
                sum += s[index++];
            }
            //对木棍长度进行排序
            Arrays.sort(s);
            max = s[len - 1];
            
            //木棒长度肯定是大于木棍长度的，必然从最长的开始进行合并
            for (; max <= sum; max++) {
                //只有当木棒长度能够被sum整除时，该木棒长度才算合理
                if (sum % max == 0) {
                    parts = sum / max;
                    //搜索按木棍长度，从大往小进行, 这样可以避免不变要的搜索
                    if (search(0, len - 1, 0)) {
                        System.out.println(max);
                        break;
                    }
                }
            }
        }
    }

    /**
     * 尝试搜索使木棍能够凑成一个木棒
     * @param res 当前这在合成的木棒的已合成的长度
     * @param next 下一个需要搜索的木棍下标
     * @param cpl 已经合成的木棒数
     * @return 
     */
    private static boolean search(int res, int next, int cpl) {
        // res = max 说明当前已经合成一个木棒
        // cpl++    res置0    
        // next置为len-2, 因为此时len-1这个木棍肯定已经被用掉了，下次搜索肯定从len-2开始，其实这个并不重要，因为每次开始搜索的时候都会检查当前搜索的木棍used[next]
        if (res == max) {
            cpl++;
            res = 0;
            next = len - 2;
        }
        // 表明当前所有木棒已经合成完毕，返回
        if (cpl == parts) {
            return true;
        }
        
        // 当前还有木棍没有合并完，需进一步合并
        while (next >= 0) {
            // 如果当前木棍没有被使用过
            if (used[next] == false) {
                // 已合并+ s[next】 <= max 说明当前木棍可以加入到当前正在合并的木棒中
                if (res + s[next] <= max) {
                    used[next] = true;
                    // 搜索成功返回
                    if (search(res + s[next], next - 1, cpl)) {
                        return true;
                    }
                    // 搜索不成功，回溯
                    used[next] = false;
                    // 当前正在合并的木棒长度res = 0， 且剩余木棍中并不能再合成木棒，搜索失败
                    if (res == 0) {
                        break;
                    }
                    // 可以合成一个当前的，但是剩余的不能合成一个木棒，搜索失败
                    if (res + s[next] == max) {
                        break;
                    }
                    // 其他情况仍然可以搜索
                }

                int i = next - 1;
                while (i >= 0 && s[i] == s[next]) {
                    i--;
                }
                next = i;
                int l_s = 0;
                while (i >= 0) {
                    if (!used[i]) {
                        l_s += s[i];
                    }
                    i--;
                }

                if (l_s < max - res) {
                    break;
                }
                continue;
            }
            next--;

        }
        return false;
    }

}