POJ 1011 Sticks ( 深搜、剪枝）

    经典搜索题，黑书上的剪枝例题。剪枝的空间很大，剪枝前写下朴素的搜索框架（黑字部分），枚举原始木棍的长度及由那些小木棍组合。原始木棍长度一定是小木棍总长度的约数，因此可以减少枚举量。

    越长的木棍对后面木棍的约束力越大，因此要把小木棍排序，按木棍长度从大到小搜索，这样就能在尽可能靠近根的地方剪枝。（剪枝一）

    如果当前木棍能恰好填满一根原始木棍，但因剩余的木棍无法组合出合法解而返回，那么让我们考虑接下来的两种策略，一是用更长的木棍来代替当前木棍，显然这样总长度会超过原始木棍的长度，违法。二是用更短的木棍组合来代替这根木棍，他们的总长恰好是当前木棍的长度，但是由于这些替代木棍在后面的搜索中无法得到合法解，当前木棍也不可能替代这些木棍组合出合法解。因为当前木棍的做的事这些替代木棍也能做到。所以，当出现加上某根木棍恰好能填满一根原始木棍，但由在后面的搜索中失败了，就不必考虑其他木棍了，直接退出当前的枚举。（剪枝二）

    显然最后一根木棍是不必搜索的，因为原始木棍长度是总木棍长度的约数。（算不上剪枝）

    考虑每根原始木棍的第一根木棍，如果当前枚举的木棍长度无法得出合法解，就不必考虑下一根木棍了，当前木棍一定是作为某根原始木棍的第一根木棍的，现在不行，以后也不可能得出合法解。也就是说每根原始木棍的第一根小木棍一定要成功，否则就返回。（剪枝四）

    剩下一个通用的剪枝就是跳过重复长度的木棍，当前木棍跟它后面木棍的无法得出合法解，后面跟它一样长度的木棍也不可能得到合法解，因为后面相同长度木棍能做到的，前面这根木棍也能做到。（剪枝五）

//172K	16MS
#include <cstdio>
#include <cstring>
#include <algorithm>
#define N 100
using namespace std ;

int flag[N] ;
int len[N] ;
int sum , len_min ;     //sum木棒总长度,len_min 最小均等分的木棒长度
int n ;     //木棒数量

bool
dfs ( int const index , int const current , int const rest )
{
    if ( len_min == rest )
    {
        return true ;
    }
    for ( int i = index ; i <= n ; i ++ )
    {
        if ( !flag[i] && len[i] <= current )
        {
            flag[i] = 1 ;
            if ( len[i] == current )
            {
                if ( dfs ( 1 , len_min , rest - len[i] ) )
                {
                    return true ;
                }
            }
            else if ( dfs ( i + 1 ,  rest - len[i] , rest - len[i] ) )
            {
                return true ;
            }
            flag[i] = 0 ;
            if ( len[i] == current )
            {
                return false ;
            }
            if ( rest == sum )
            {
                return false ;
            }
            if ( current == len_min )
            {
                return false ;
            }
            while ( len[i] == len[i+1] )
            {
                i ++ ;
            }
        }
    }
    return false ;
}


int
cmp ( const void * a , const void * b )
{
    return - ( *(int*)a - *(int*)b ) ;
}

int
Find_Len_Min ( int current_len )
{
    while ( sum % current_len )
    {
        current_len ++ ;
    }
    return current_len ;
}
/*
bool
cmp ( int a , int b )
{
    return a > b ;
}
*/

int
main ( )
{
    while ( EOF != scanf ("%d", & n ) )
    {
        if ( 0 == n )
        {
            break ;
        }
        sum = 0 ;
        for ( int i = 1 ; i <= n ; i ++ )
        {
            scanf ("%d" , &len[i] ) ;
            sum += len[i] ;
        }
        memset ( flag , 0 , sizeof ( flag ) ) ;
       // sort ( len + 1 , len + 1 + n , cmp ) ;
       qsort ( len + 1 , n , sizeof ( len[0] ) , cmp ) ;
        len_min = len[1] ;
        len_min = Find_Len_Min ( len_min ) ;
        while ( 0 ==  dfs ( 1 , len_min , sum ) )
        {
           len_min ++ ;    //没有的话TLE 纠结。。
           len_min = Find_Len_Min (  len_min ) ;
        }
        printf ("%d\n" , len_min ) ;
    }
    return 0 ;
}