poj 1011 小棍问题

/*
*              poj 1011 经典的全搜题 by sunmoonstar
*
* 题目大意：给出一些长度不大于 50 的木棍， 要求你把这些小木棍拼成
*             长度相同木棍，当然长度越小越好。
*
* 解题思路：这个题最近做了很多次，我比较有发言权了。
*             思想很简单，一个接一个的把木棍拼起来，最后把木棍用光。
*             关键的地方是几个剪枝技巧：
*             
*             设所有木棍的总长度为 Sum, 最终的答案是 L。
*             1. 首先要明白， Sum一定要能被 L 整除。
*             2. L 一定 大于等于 题目给出的最长的木棍的长度 Max。
*                  由上述两点，我们想到，可以从 Max 开始递增地枚举 L,
*                直到成功地拼出 Sum/L 支长度为 L 的木棍。
*
*             搜索中的剪枝技巧：
*             3. 将输入的输入从大到小排序，这么做是因为一支长度为 K
*                的完整木棍，总比几支短的小木棍拼成的要好。
*                形象一些：
*                  如果我要拼 2 支长为8的木棍，第一支木棍我拼成
*                          5 + 3
*                  然后拼第二支木棍但是失败了，而我手中还有长为 2 和 1
*                  的木棍，我可以用 5 + 2 + 1 拼好第一支，再尝试拼第二
*                  支，仔细想一想，就会发现这样做没意义，注定要失败的。     
*                  我们应该留下 2+1 因为 2+1 比 3 更灵活。
*             4. 相同长度的木棍不要搜索多次， 比如：
*                我手中有一些木棍, 其中有 2 根长为 4 的木棍， 当前搜索
*                状态是 5+4+.... (即表示长度为 5,4,2 的三支拼在一起,
*                ...表示深层的即将搜索的部分), 进行深搜后不成功，故我
*                没必要用另一个 4 在进行 5+4+...
*             5. 将开始搜索一支长为 L 的木棍时，我们总是以当前最长的未
*                被使用的 木棍开始，如果搜索不成功，那么以比它短的开始
*                那么也一定不能取得全局的成功。因为每一支题目给出的木棍
*                都要被用到。
*                如果，有
*                    4
*                    5 4 4 3 2
*                  想拼成长为 6 的木棍，那么从 5 开始， 但是显然没有能与 5
*                  一起拼成 6 的，那么我就没必要去尝试从 4 开始的，因为
*                  最终 5 一定会被遗弃。在拼第 2 3 ... 支木棍时，一样。
*             6. 最后的最简单的一个就是，
*                      for(int i = 0; i < n; i++)
*                          for(int j = 0; j < n; j++)
*                               {}
*                与
*                      for(int i = 0; i < n; i++)
*                          for(int j = i+1; j < n; j++)
*                               {}
*                的区别，这个不多说了。
*             7. 我用过的另一个剪枝，但是对 poj 的数据效果一般，
*                用一个数组， Sum[i] 保存 第 i 个木棍之后，即比第 i 枝
*                木棍短或与之相等所有的木棍的长度之和。
*                试想，如果剩余的所有木棍加在一起都不能和我当前的状态拼
*                出一直长为 L 的木棍(从长度来看)，还有必要搜下去么？
*                        
*/

// 思路大致如此，具体代码需要大家自己实现。
// 欢迎大家讨论 

/*
*
* 最变态的数据:
*           64
*           40 40 30 35 35 26 15 40 40 40 40 40 40 40 40 40 40 40 40 40 40 
*
*           40 40 43 42 42 41 10 4 40 40 40 40 40 40 40 40 40 40 40 40 40 
*
*           40 25 39 46 40 10 4 40 40 37 18 17 16 15 40 40 40 40 40 40 40 
*
*           40
*
*           0
*
* 运行结果:
*           # time cat input/1011.txt | ./a
*           454
*
*           real    0m3.175s
*           user    0m2.901s
*           sys     0m0.046s
*
*/
#include <iostream>
#include <functional>
#include <algorithm>
#include <cstring>

namespace {
    using namespace std;

    const int SET_SIZE_MAX = 64;
    bool visit[SET_SIZE_MAX];
    
    int s[SET_SIZE_MAX];
    int s_size;
    
    bool sticks(int cur_group, int target_group, int pos, int left, int target_len)
    {
        // 所有的小棍拼接成功，返回成功
        if (cur_group == target_group)
        {
            return true;
        }

        // 本次小棍拼接成功，进入下一个小棍的拼接
        if (left == 0)
        {
            return sticks(cur_group+1, target_group, 0, target_len, target_len);
        }

        // 从上次使用最后一个小木棒开始搜素
        for (int i=pos; i<s_size; i++)
        {
            if (visit[i]) continue;
            if (s[i]>left) continue;

            // 找到第一个满足条件的木棒，使用之
            visit[i] = true;
            if (sticks(cur_group, target_group, i+1, left-s[i], target_len))
            {
                return true; // 使用该木棒证明是正确的，不再搜素，返回成功
            }
            visit[i] = false;

            // 使用木棒不可行时，判断是否拼接的第一个木棒，或者是否拼接的最后一个木棒
            if (left==target_len || left==s[i])
            {
                return false;
            }

            while (s[i+1] == s[i]) ++i; // 千万不能写成 while(s[++i] == s[i])的样子, 会导致跨越一个元素的!!!
        }

        return false;
    }
}

int main()
{
    int n;
    while (cin>>n && n!=0)
    {
        int sum = 0;
        s_size = n;
        for (int i=0; i<n; i++)
        {
            cin >> s[i];
            sum += s[i];
        }

        sort(s, &s[n], greater<int>());
        memset(visit, 0, sizeof(visit));
        for (int i=s[0]; i<=sum; i++)
        {
            if (sum%i != 0) continue; // 外部剪枝^_^
            
            if (sticks(0, sum/i, 0, i, i))
            {
                cout << i << endl;
                break; // 别忘了找到就退出
            }
        }
    }
    
    return 0;
}