POJ 1011 sticks 搜索

Sticks

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 125918		Accepted: 29372

Description

George took sticks of the same length and cut them randomly until all parts became at most 50 units long. Now he wants to return sticks to the original state, but he forgot how many sticks he had originally and how long they were originally. Please help him and design a program which computes the smallest possible original length of those sticks. All lengths expressed in units are integers greater than zero.

Input

The input contains blocks of 2 lines. The first line contains the number of sticks parts after cutting, there are at most 64 sticks. The second line contains the lengths of those parts separated by the space. The last line of the file contains zero.

Output

The output should contains the smallest possible length of original sticks, one per line.

Sample Input

9
5 2 1 5 2 1 5 2 1
4
1 2 3 4
0

Sample Output

6
5

Source

Central Europe 1995

这道题的剪枝到极致了。少一点也不行，很好的搜索题。我是看了网上的代码才A的，各种剪枝。

这个题如果A了，必须要深刻理解才行，关于各种剪枝，代码中有注释

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn = 70;
int n, arr[maxn], Sum;
bool vis[maxn];
/*cur表示当前选择棍子的序号，diff_len为这根棍子还差多长，
sum_len初始值为总长Sum, cur_len表示搜索当前棍子长度为cur_len的棍子 */
bool dfs(int cur, int diff_len, int sum_len, int cur_len)
{
    if (diff_len == 0)
    {
        sum_len -= cur_len;
        if (sum_len == 0)//判断是否所有的棍子都取完了 
        {
            return true;
        }
        for (cur = 0; vis[cur]; cur++);//剪枝1，找到剩下的最长的一根，然后接着这个往下找比他小的 
            vis[cur] = true;
        if (dfs(cur + 1, cur_len - arr[cur], sum_len, cur_len))//从最长的开始继续往下找 这个剪枝的威力很大，从不能TLE直接到A的差距 
            return true;
        vis[cur] = false;
        sum_len += cur_len;
    } 
    else
    {
        for (int i = cur; i < n; i++)
        {
            /*剪枝2，如果这个棍子的长度等于上一个棍子的长度，并且上一个还不符合要求，
            没有取，所以这个肯定也不能取，直接跳过 */
            if (i > 0 && arr[i] == arr[i - 1] && !vis[i - 1])
                continue;
            if (!vis[i] && diff_len >= arr[i])//如果没有取过，并且需要取的长度大于待取的才行，小小剪枝3，最普通的dfs也该有的
            {
                vis[i] = true;
                diff_len -= arr[i];
                if (dfs(i + 1, diff_len, sum_len, cur_len))//找下一个，普通的dfs， 剪枝4 
                    return true;
                diff_len += arr[i];
                vis[i] = false;
                if (arr[i] == diff_len)//剪枝5，如果走到这里，本次刚好凑成一根棍子，但是既然能走到这，肯定下面的失败了，所以返回上层dfs
                    break;
            }
        }
    }
    return false;
}
bool cmp(const int a, const int b)
{
    return a > b;
}
int main()
{
    while (cin >> n && n)
    {
        Sum = 0;
        for (int i = 0; i < n; i++)
        {
            cin >> arr[i];
            Sum += arr[i];
        }
        sort(arr, arr + n, cmp);//从大到小排序 
        memset(vis, false, sizeof(vis));
        int flag = 0;
        for (int i = arr[0]; i <= Sum / 2; i++) //剪枝6，这个为什么是对的，可以举反例，假设要求的i大于Sum/2的话，那么剩下的长度和为Sum-i<i，得出来i+i>Sum,与已知矛盾，所以假设不对。 
        {
            if (Sum % i == 0)
            {
                if (dfs(0, i, Sum, i))
                {
                    cout << i << endl;
                    flag = 1;
                    break;
                }
            }
        }
        if (!flag)
            cout << Sum << endl;
    }
    
    return 0;
}