POJ 1011

1011果然是个经典的题目啊。。。

题目大意：

Description

乔治拿来一组等长的木棒，将它们随机地砍断，使得每一节木棍的长度都不超过50个长度单位。然后他又想把这些木棍恢复到为裁截前的状态，但忘记了初始时有多少木棒以及木棒的初始长度。请你设计一个程序，帮助乔治计算木棒的可能最小长度。每一节木棍的长度都用大于零的整数表示。

Input

输入包含多组数据，每组数据包括两行。第一行是一个不超过64的整数，表示砍断之后共有多少节木棍。第二行是截断以后，所得到的各节木棍的长度。在最后一组数据之后，是一个零。

Output

为每组数据，分别输出原始木棒的可能最小长度，每组数据占一行。

-----------------------------------------------------------------------------------------------------我是华丽的分割线---------------------------------------------

一开始呢我以为这题目很简单，所以用了一个应该是贪心的算法吧，就是把木棍从大到小开始塞，塞不下就是不成功的。现在想想果然是考虑十分不周啊。。。我果然比较水。。。然后就是提交了3次，3次WA，终于让我意识到了算法的错误，代价很大！

查了查资料，发现这一一道搜索+剪枝的算法题目。所谓搜索么，就是很通用的一般算法。所谓剪枝，就是通过正确解的必要条件和非正确解的充分条件，将搜索的过程最小化。

后来就仔细研究算法去了。。。一连好几天。。。

其实搜索过程很简单，就是一个递归：（初始的棒子我把它叫做目标棒子，现在的棒子我把它们叫做剩余的棒子）

不断将剩下棒子塞进目标长度的棒子中，如果当前的目标棒子塞完了，那么就塞下一根，直到塞不下或者所有目标棒子塞完了为止。

但是剪枝有很多，否则很不容易过的。

剪枝：

1.首先给的棒子要排个序，否则的话下面的剪枝都无从谈起了。假定排序是从小到大的。

2.目标棒子的长度肯定是所有剩余棒子的和的一个约数，并且目标棒子的长度肯定不小于最大的剩余棒子。【正确解的必要条件】

3.在拼某个目标棒子的过程中，从大到小开始试，那些长度一样的就试一次。【正确解的必要条件】

4.在拼某个目标棒子的过程中，如果把当前编号是i的棒子之前的棒子（就是不长于i的棒子），包括i，都塞入这个目标棒子中也不能拼完这个目标棒子，那么，这个路径也是不对的。【非正确解的充分条件】

5.在拼某个目标棒子的过程中，如果某个长度的棒子太多，以至于就算算上还没有拼的目标棒子都不能容纳这么多的这个长度的棒子，那么，这个路径也是不对的。【非正确解的充分条件】

6.当还剩一个目标棒子没有拼的时候，就可以断定一定可以拼完了。【正确解的必要条件】

7.当一个目标棒子拼完了，拼下一根的开始的时候，如果在剩下的棒子中最长的那根没有被拼上，那么这条路径肯定不对。【非正确解的充分条件】

在这些剪枝中，其中第7、3、1都很重要，尤其是第7条，我苦思冥想都没有找到的剪枝，最后还是查别人的程序找到的，这条给我的程序优化了不少。

不过还要说一下的是，由于我用的是递归，一开始我的递归函数传递的参数太多了，结果递归深度过大导致了RE。。。应该是栈溢出吧。后来用了全局变量才解决的。。。囧。。

不说了，贴代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

int judgeRight(int *a,int len,int num,int sum){
  int nStick=sum/num;
  int i,k;
  int *stick=(int *)calloc(nStick,sizeof(int));
  
  for (i=len-1;i>=0;i--){
    k=0;
    while(stick[k]+a[i]>num){
      k++;   
      if (k>=nStick) {free(stick);return -1;}
    }
    stick[k]+=a[i];
    qsort(stick,nStick,sizeof(int),cmp_fun2);
  }
  
  for (i=0;i<nStick;i++){
    if (stick[i]!=num) {free(stick);return -1;}
  }
  
  free(stick);
  return 1;
  
}*/
//以上是我3次WA的递归函数。。。纪念一下我刺眼的错误，以此来提醒自己其实很水。

//如果在递归里面传递这些参数的话搞不好会栈溢出，第四次RE问题出在这里
int *a;
int len;
int wholeStick;
int *b;

int fillStick(int k,int stick,int left){
	int temp,i,itemp,ans;
	int j,flag;
	
	flag=0;
	if (stick==wholeStick) {
		left=left-1;
		for(j=len-1;j>=0;j--) if (a[j]!=0) break;
			
		k=j+1;
		stick=0;
		flag=1;  //这表示这个放的木棍是第一个
	}
	if (left==1) return 1;  //剪枝6：到只剩一个的时候就可以结束了
	temp=-1;	
  for (i=k-1;i>=0;i--){
    if ((a[i]!=0)&&(a[i]+stick<=wholeStick)){    //跳过已经用过的值
    	 temp=a[i];
    	 stick+=temp;
    	 
    	 for(itemp=i;itemp>=0;itemp--){
    	   if (a[itemp]!=temp) break;  //剪枝3：寻找相同值的个数
    	 }
    	 if ((i-itemp)/(wholeStick/temp)>left) return 0;  //剪枝5：粗判断
    	 
    	 if ((b[i]+stick)<wholeStick) return 0;   //剪枝4：当剩下的都填充不了了可以结束搜索了
    	 a[i]=0;
    	 
    	 ans=fillStick(i,stick,left); 	 
       if (ans){       	 
       	 return 1;
       }else {         
       	 a[i]=temp;
       	 if (flag==1) return 0;  //剪枝7：如果第一根棒子都放不进去那就肯定放不了了，最最重要的剪枝
         stick-=temp;
       }
    i=itemp+1;  //剪枝3：跳过重复的值
    }
  }
  if (i==-1) return 0;
}

int judgeRight(int num,int sum){
  int nStick=sum/num;
  int ans;
  
  wholeStick=num;
  ans=fillStick(len,0,nStick);

  return ans; 
}

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

int main(){
  int sum,nLen;
  int i;
  
  scanf("%d",&nLen);
  while(nLen!=0){
    a=(int *)calloc(nLen,sizeof(int));
    b=(int *)calloc(nLen,sizeof(int));
    sum=0;
    for (i=0;i<nLen;i++){
      scanf("%d",&(a[i]));
      sum+=a[i];
    }
    
    qsort(a,nLen,sizeof(int),cmp_fun);  //剪枝1：排序减少搜索量
    
    b[0]=a[0];
    for (i=1;i<nLen;i++){
      b[i]=b[i-1]+a[i];
    }

    if (nLen==1) printf("%d\n",a[0]);  
    else for (i=a[nLen-1];i<=sum;i++){   //a[nLen-1]最大
    	 if (sum%i==0){   //剪枝2
    	 	  len=nLen;
    	 	  if (judgeRight(i,sum)==1){
    	 	  	printf("%d\n",i);
    	 	  	break;
    	 	  }
    	 }
    }
    scanf("%d",&nLen);
    free(a);
    free(b);
  }
}