Poj 1011 解题报告

? ?? 这是一道经典的搜索题，我个人的理解是双重深度搜索：第一层搜索为搜索当前最短木棍的合法性(len)，即在题目所给出的木棍长度中是否能组合出当前木棍的长度，第二层搜索是建立在第一层搜索的基础上，搜索当前最短木棍数目的合法性，即假设我们能从所给的木棍长度中组合出当前最短木棍长度，记当前木棍数为t，则t+=1，同时标记那些已经用来组合当前最短木棍的木棍为“用过”，继续在没用过的木棍中搜索是否能组合另一根当前最短木棍，有则t+=1，如果t=sum/len,(sum为所有木棍长度总和）则len为所求值。

? ? 以上只是解题的大体思路，要在合法时间内完成搜索，还必须剪枝。首先将截后木棍长度按降序排列，假设当前节点号为node，当前搜索长度为s（s从0开始，一步一步增加看是否能达到len）如果node满足len[node]+s<=len && mark[node]==0,那么在搜索下一节点时只需从node+1 开始搜索，而无须从0号开始搜索，以内0——node已经被搜索而无须重复搜索，另外还要注意，如果len[node]不符合条件，那么与len[node]等长的节点也不符合条件。

? ? 下面是网上一个大牛的代码，非本人。

#include<iostream>
using namespace std;
int a[64];
int mark[64];

int sum,len,sticks,num,rest;
bool flag;

void dfs(int t,int s,int node)
{ ?
? if(t==num) flag=1;
? else if(s==len && rest%s==0 ) ?
? dfs(t+1,0,0); //第二层搜索
? else?
? for(int i=node,pre=-1;i<sticks;i++)//只需搜索node之后的节点，pre是为了在该节点不符合的情况下，避 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?// ?免搜索同等长度的节点
? {
? if( mark[i]==0&&a[i]!=pre && s+a[i]<=len )
? {
? pre=a[i];
? mark[i]=1;
? rest-=a[i];
? dfs(t,s+a[i],i+1); ?//第一层搜索
? mark[i]=0;
? rest+=a[i];?
? if(flag==1 || node==0)return ;
? }
? }
} ?
? ?
int main()
{
?while(cin>>sticks && sticks!=0)
?{
? int max=0;?
? sum=0,flag=0;?

? for(int i=0;i<sticks;i++)
? {
? cin>>a[i];
? if(max<a[i])max=a[i];
? sum+=a[i];
? if(i>=1)//?
? {
? int temp=a[i];
? int j;
? for(j=i-1;j>=0 && temp>a[j];j--)
? a[j+1]=a[j];
? a[j+1]=temp;?
? } ?
? }
? rest=sum;
? for(len=max;len<=sum ;len++)
? {
? memset(mark,0,sizeof(mark));?
?if(sum%len==0)
?{
? num=sum/len;
? dfs(0,0,0);
? }?
? if(flag==1)break;
? }
?cout<<len<<endl;
? }
}?

测试数据：
64
5 8 6 1 4 5 8 2 1 6 4 2 3 6 2 5 8 7 9 2 1 4 3 6 5 4 7 8?
2 6 5 1 4 5 3 6 5 6 2 1 4 7 8 9 5 2 1 9 4 7 5 2 3 6 9 4
5 8 9 2 4 6 3 6 9?

answer：17

3

1 5 8

answer：14

9
15 3 2 11 4 1 8 8 8

answer：20