POJ1011

摘要：DFS，剪支很重要。

1。相同的数只要有一次碰到了但没选，接下来再碰到就不选了。

比如数据

5 2 1 5 2 1 5 2 1

在一轮寻找中第一个2没选，那么接下来的2就都不要选。

2。要先选大的数，这样就较少的接下来的可能行。别小看这个，看似漫不经心，其实很关键。没注意就会TLE，注意了就是0或16ms

所以要给原序列从大到小排序。

 

#include <iostream>
#include <stdio.h>
#include <string>
#include <string.h>
#include <set>
#include <algorithm>
#include <functional>
using namespace std;

const int size = 64;
int flag[size+1] = {0};
int data[size+1] = {0};

int sum = 0;
int max_value = 0;
int next_posi = 1;
int min_len = 0;
int search_len = 0;
int n = 0;
int flag_count = 0;

void search(int index, int value)
{
    if( index > n ){
        if(value == search_len){
            if( flag_count >=n ){
                min_len = search_len;
            }
        }
        return;
    }


    if( value == search_len ){
        flag[index] = true;
        flag_count++;
        if( data[index] == value ){
            search(index+1, search_len);
        }else{
            search(index+1, value - data[index]);
        }
        flag[index] = false;
        flag_count--;
        return;
    }

    for(int i=index; i<=n; i++){
        if( min_len != 0 ){
            break;
        }
        if(data[i]>value || flag[i]){
            continue;
        }
        if(i>0 && data[i]==data[i-1] && !flag[i-1]){
            continue;
        }
        flag[i] = true;
        flag_count++;
        if( data[i] == value ){
            int new_index = 1;
            for(; new_index<=n; new_index++){
                if(!flag[new_index]){
                    break;
                }
            }
            search(new_index, search_len);
        }else{
            search(i+1, value-data[i]);
        }

        if( min_len != 0 ){
            break;
        }
        flag[i] = false;
        flag_count--;
    }
}

int main()
{
    while(true){
        scanf("%d", &n);
        if(n == 0){
            break;
        }
        sum = 0;
        max_value = 0;
        for(int i=1; i<=n; i++){
            scanf("%d", &data[i]);
            sum += data[i];
            max_value = max_value > data[i] ? max_value : data[i];
        }
        
        sort(data+1, data+n+1, greater<int>());
        min_len = 0;
        for(int i=max_value; i<=sum/2; i++){
            if( sum % i == 0 ){
                flag_count = 0;
                memset(flag, 0, sizeof(flag));    
                search_len = i;
                search(1, search_len);
                if(min_len != 0){
                    break;
                }
            }
        }
        if( min_len == 0 ){
            min_len = sum;
        }
        printf("%d/n", min_len);
    }
    return 0;
}