POJ1011解题报告

题目：

Sticks

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 75802		Accepted: 16681

Description

George took sticks of the same length and cut them randomly until all parts became at most 50 units long. Now he wants to return sticks to the original state, but he forgot how many sticks he had originally and how long they were originally. Please help him and design a program which computes the smallest possible original length of those sticks. All lengths expressed in units are integers greater than zero.

Input

The input contains blocks of 2 lines. The first line contains the number of sticks parts after cutting, there are at most 64 sticks. The second line contains the lengths of those parts separated by the space. The last line of the file contains zero.

Output

The output should contains the smallest possible length of original sticks, one per line.

Sample Input

9
5 2 1 5 2 1 5 2 1
4
1 2 3 4
0

Sample Output

6
5

题目翻译：

George带来一些长度相等的树条，随机的砍他们，知道所有的木条最多50单位长度。现在我们想让木条恢复成原来的样子，但是他忘记了他

原先带来多少根木条以及他原来的长度有多长。编写一个程序计算木条原来的最短长度。

木条最多64根。

分析：

这是一个很典型的搜索+剪枝算法题。首先，我们可以知道木条的原始长度在max~wholelength/2之间(因为如果大于wholelength/2,那么

wholelength/length=1，就只有一个木条，这是最简单的情况了)。

max=max{所有砍断木条的长度}

wholelength=木条1+木条2+...+木条n

并且木条的原始长度还能够被wholelength整除。

接下来就是用judge函数进行搜索。这其实是一个递归函数：

boolean judge(int cur,int left,int lever)

cur表示判断的树条的序号，left表示当前段的剩余长度，lever表示已经配好的树条数目。

具体的代码如下：

import java.util.Scanner;
public class Main {

	//题目中标明树枝的个数不会超过64根
	int[] stick=new int[64];
	int[] stick1=new int[64];
	int k=0;
	int sum=0;
	int num=0;
	//定义一些需要使用的变量
	int left,lever,n=0;
	//标记树枝是否已经被使用的数组
	boolean[] used=new boolean[64];
	
	//重新将used数组置为false的初始值
	public void reset()
	{
		for(int i=1;i<n;i++)
			used[i]=false;
	}
	//判断是否能找到符合条件的树枝的组合
	//cur表示当前判断的树枝id号，left本段剩下的长度，lever表示已经成功的木棒数
	//所有的计数均从0开始，如0~n-1
	public boolean judge(int cur,int left,int lever)
	{
		//如果剩下的长度为0
		if(left==0)
		{
			//没有树枝剩下了，lever=n-1
			//就表明找到了树枝的组合,返回true
			if(lever==num-1)
			{
				return true;
			}
			else
			{
				for(cur=1;used[cur];cur++);
				used[cur]=true;
				if(judge(cur,k-stick1[cur],lever+1))
					return true;
				used[cur]=false;
				return false;
			}
		}
		else
		{
			if(cur>=n-1)
				return false;
			for(int i=cur;i<n;i++)
			{
				if(used[i]==true)
					continue;
				if((stick1[i]==stick1[i-1])&&!used[i-1])
					continue;
				if(stick1[i]>left)
					continue;
				used[i]=true;
				if(judge(i,left-stick1[i],lever))
					return true;
				used[i]=false;
			}
			return false;
		}
	}
	//快速排序
	public int partion(int low,int high)
	{
		int i=low,j=high+1;
		int x=stick[i];
		while(true)
		{
			while(stick[++i]<x&&i<high);
			while(stick[--j]>x);
			if(i>=j)
				break;
			int temp;
			temp=stick[i];
			stick[i]=stick[j];
			stick[j]=temp;
		}
		stick[low]=stick[j];
		stick[j]=x;
		return j;
	}
	public void Qsort(int low,int high)
	{
		if(low<=high)
		{
			int p=partion(low,high);
			Qsort(low,p-1);
			Qsort(p+1,high);
		}
	}
	//获得输入，并且从此函数开始执行
	public void getInput()
	{
		Scanner scan=new Scanner(System.in);
		while(scan.hasNext())
		{
			n=scan.nextInt();
			if(n==0)
				break;
			for(int i=0;i<n;i++)
			{
				stick[i]=scan.nextInt();
			}
			reset();
			//对所有的树枝进行从大到小的排序
		    Qsort(0,n-1);
		    sum=0;
		    boolean end=false;
		    for(int i=0;i<n;i++)
		    {
		    	stick1[i]=stick[n-1-i];
		    	sum+=stick1[i];
		    }
		    //放入第一根树枝
		    used[0]=true;
		    //之所以k从stick1[0]~sum/2，是由于如果k>sum/2，
		    //那么num=1，那么就只是一根棍子了
		    for(k=stick1[0];k<=sum/2;k++)
		    {
		    	if(sum%k==0)
		    	{
		    		num=sum/k;
		    		if(judge(0,k-stick1[0],0))
		    		{
		    			end=true;
		    			System.out.println(k);
		    			break;
		    		}
		    	}
		    	reset();
		    }
		    if(end==false)
		    {
		    	System.out.println(sum);
		    }
		}
	}
	public static void main(String[] args)
	{
		Main m=new Main();
		m.getInput();
	}
}