poj 1011

poj 1011 深度优先加遍历
思路：
解空间树为一对多（只要没有被使用），使用dfs，若不剪枝，时间复杂度为o（n！），太大。
剪枝策略：
1，最小长度为最大的小段长度到总长度之间，且一定整除总长度。
2，若前一个不满足，而循环找的下一个和前一个相同，则必定也不满足。
3，若是已经拼好的前几段或刚开始，去找下一个小棍的第一段，若第一个不满足，则没必要去找下一个，因为若能刚好拼接完成，则这个一定属于某段，而现在无法找到包含这段的小棍。

ps：这道题我前前后花了三天，也是第一个完成的dfs+剪枝，还参考的而网上的代码，我要说的是ac真他妈的难，但我领悟了，错了就一定有错，不要觉得自己的测试数据能行，就始终认为没有问题，况且不知自己的逻辑的不完整。以后不要一个没完的通过测试找错误，那样一般很难找到，且有时候，找到了也不知道为什么，还不如好好看看自己程序的有什么错误。在脑子里模拟一遍。还有我不是很明白到底给递归传什么变量，是写个全局变量，还是直接传进去，后来觉得其实都一样。当然，程序的效率不高，对于第一个dfs，我也没太多的要求。希望以后能改进。

<pre name="code" class="cpp">#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
 // #define LOCAL
class sticks
{
	friend void A(class sticks a,int n);
public:
	int a[65];
	int b[65];
	bool backtrack(int left_num);
	int l;//小棍长度
	int cl;//当前小棍长度
	int sum;
	int n;//小段数
	
};

bool sticks:: backtrack(int left_num)//剩下的小棍数
{
	if(left_num==0)
		return 1;
	for (int i = 0; i < n; ++i)
	{
		if (b[i]==0)
		{
			if (cl+a[i]==l)
			{
				int g=cl;
				b[i]=1;
				cl=0;
				if(backtrack(left_num-1)==1)
					return 1;

				b[i]=0;
				cl=g;

				for(;i+1<n;i++)
				if(b[i]==0 && a[i]!=a[i+1])
					break;

			}
			if (cl+a[i]<l)
			{
				b[i]=1;
				cl+=a[i];
				if(backtrack(left_num)==1)
					return 1;
				b[i]=0;
				cl-=a[i];
				for(;i+1<n;i++)
				if(b[i]==0 && a[i]!=a[i+1])
					break;
				
			}

			if(cl==0)
				break;	
		}
		
	}
	return 0;
}

bool cmp(int a,int b)
{
	return a>b;
}

void A(class sticks a,int n)
{
	a.sum=0;
	for (int i = 0; i < n; ++i)
	{
		a.sum+=a.a[i];
	}
	a.cl=0;
	a.n=n;
	memset(a.b,0,sizeof(a.b));
	sort(a.a,a.a+n,cmp);
	
	int m=a.a[0];
	for(int i=m;i<=a.sum;i++)
	{
		if(a.sum%i==0)
		{
			a.l=i;
			a.cl=0;
			if(a.backtrack(a.sum/i)==1)
				{
					cout<<i<<endl;
					break;
				}
			else
				{
					memset(a.b,0,sizeof(a.b));
				}
		}
	}

}

int main(int argc, char const *argv[])
{
	#ifdef LOCAL
	freopen("input","r",stdin);
	#endif

	int n;
	
	while(scanf("%d",&n),n!=0)
	{
		class sticks a;
		for (int i = 0; i < n; ++i)
		{
			scanf("%d",&a.a[i]);
		}
		A(a,n);
	}
	return 0;
}