poj1011 减枝

这道题是黑书剪枝的例题，是用方法为调整法，但是这个方法很难掌握，还是多积累些经验吧。

首先要排个序，然后从大到小遍历回溯搜索是否可组成。

回溯中有剪枝。

1，对于一个还没有匹配任何长度（need=leng）的初始长度leng，随便搜一个小与此初始长度的木棍，如果之后的搜索不能匹配，那就不能匹配了，此时就要返回上一层修改策略。

2，还有就是如果当前选的小木棍len[i]==need时，如果这样都不能匹配，由于搜索是递减顺序那么之后都不会匹配。

加上这两个剪枝就可以在poj跑的0ms了

1. #include<stdio.h>  
2. #include<string.h>  
3. #include<queue>  
4. #include<algorithm>  
5. using namespace std;  
6. int n,len[70],sum;  
7. int part,leng;  
8. int visit[70]={0};  
9.   
10. int cmp(const void * a,const void * b){  
11.     int * aa=(int *)a;  
12.     int * bb=(int *)b;  
13.     return *aa-*bb;  
14. }  
15.   
16. int search(int now,int need,int k){//now表示已拼成几根，need表示还需要need长拼成这一根，从第k个木棍开始  
17.     int i,j;  
18.   
19.     if(need==0){  
20.         now++;  
21.         need=leng;  
22.         k=n;  
23.     }  
24.           
25.     if(now==part-1)  
26.         return 1;  
27.   
28.     for(i=k;i>=1;i--)  
29.         if(!visit[i])  
30.             if(need>=len[i]){  
31.                 visit[i]=true;  
32.                 if(search(now,need-len[i],i-1))  
33.                     return 1;  
34.                 visit[i]=false;  
35.                 if(need==leng)  
36.                     return 0;  
37.                 if(need==len[i])  
38.                     return 0;  
39.                 while(len[i-1]==len[i])  
40.                     i--;  
41.             }  
42.     return 0;  
43. }  
44.   
45. void dfs(){  
46.     int i,flag=0;  
47.     for(i=len[n];i<=sum;i++){  
48.         if(sum%i==0){  
49.             part=sum/i;  
50.             leng=i;  
51.             if(search(0,i,n))  
52.                 break;  
53.         }  
54.     }  
55.     printf("%d\n",leng);  
56. }  
57.   
58. int main(){  
59.     int i;  
60.     while(scanf("%d",&n) && n!=0){  
61.         sum=0;  
62.         memset(visit,0,sizeof(visit));  
63.         for(i=1;i<=n;i++){  
64.             scanf("%d",&len[i]);  
65.             sum+=len[i];  
66.         }  
67.         len[0]=0;  
68.         qsort(&len[1],n,sizeof(len[1]),cmp);  
69.         dfs();  
70.     }  
71. }