題意：n根不同長度的小棍，拼成若干長棍，要這些長棍的長度相等，並且小棍剛好用完，問拼成長棍的最短長度是？
前話：這題是在暑假第一天搜尋專題下，作為自己複習的練手題目，其實是又一次加深學習搜尋的思想（弱已跪）和回溯的一些理解。
思路：表明上初看此題就像是搜尋，（我開始也想過二分，這並不是只有一種可行，而是找到最短），首先考慮搜尋的方向，最短，那肯定是從最短的情況開始遞增，最短的可能情況那肯定就是最長的的單個棍子，所以首先把這些小棍排序，從大到小，並計算這些棍子總和，拼成的長棍的長度從最長的小棍開始搜尋，搜尋的過程也是判斷，用總和除以這個長度得到應該拼成的長棍個數，遞迴搜尋判斷小棍之間能否相組合成滿足這麼多個長度相等的長棍。
在搜尋過程中 注意四個地方可以剪枝（效果還是很驚人的）
1.搜尋的起點是最長的小棍長度，而不用從1開始（最明顯，容易可以想到）。
2.用一個used陣列標記，哪個小棍用過了。(前兩個都是最基礎，當我沒說)。
3.（威力巨大）當一個棍子發現沒有棍子可以與他配對，直接跳過，後面的棍子嘗試，這次棍子長度絕對不滿足，直接嘗試下一個長度。
4.當一個棍子的長度已經被否定不能與這個棍子配對，避免出現下個與上個相同的情況，搜尋重複，由於排好序的，如果這個和下個相等，就移到不相等的數字再嘗試。
以已下這組測試資料為例：
45
15 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8 15 3 2 4 11 1 8 8 8
不剪枝 用c變數記載遞迴次數900多萬次
剪枝完成後 僅僅4萬多次 遞迴。
由於開始看到書上標答是回溯的寫法，深搜帶一個返回值，對於一直習慣搜尋返回void 的我開始覺得不好理解…後來測試各種資料後,我自己寫出我習慣寫的普通深搜，感覺兩者從時間複雜度上沒神馬區別。回溯也是第一次用，不好評價，以後慢慢理解。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[80],sum,num,n,c;
bool used[80];
bool cmp(int a,int b)
{
    return  a>b;
}

bool dfs(int stick,int len,int pos)
{
    //c++;
    if(stick==num)
     return true;
    for(int
 
 i=pos;i<n;i++)
    {
        if(used[i]) continue;
        if(a[i]+len==sum/num)
        {
          used[i]=true;
          if(dfs(stick+1,0,0))
          return true;
          used[i]=false;
          return false;
        }
        else if(a[i]+len<sum/num)
        {
            used[i]=true;
            if
 
(dfs(stick,len+a[i],i))
                return true;
            used[i]=false;
            if(len==0) return false;
            while(a[i]==a[i+1]) i++;
        }
    }
    return false;
}

int main()
{
    //c=0;
    while(scanf("%d",&n)&&n)
    {
        sum=0;
        for(int i=0;i<n;i++){
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        sort(a,a+n,cmp);
        for(int aim=a[0];aim<=sum;aim++)
        {
            if(sum%aim) continue;
            num=sum/aim;
            memset(used,false,sizeof(used));
            if(dfs(0,0,0))
            {
                printf("%d\n",aim);
                //cout<<c<<endl;
                break;

            }
        }
    }
    return 0;
}

我寫的普通深搜

#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
int a[65],used[65],n,sum,num,flag,c;
bool cmp(int a,int b)
{
    return a>b;
}

void dfs(int stick,int len,int pos)
{
   // c++;
    if(flag)
        return;
    if(stick==num){
        flag=1;
        return;
    }
    for(int i=pos;i<n;i++)
    {
        if(used[i]) continue;
        if(a[i]+len==sum/num)
        {
            used[i]=1;
            dfs(stick+1,0,0);
            //if(flag) return;//想起到剪枝作用，收到後，回到上個 搜尋就直接結束，而然並沒神馬作用。
            used[i]=0;
            return;
        }
        else if(a[i]+len<sum/num)
        {
            used[i]=1;
            dfs(stick,len+a[i],i+1);
            //if(flag) return;
            used[i]=0;
            if(len==0) return;

            while(a[i]==a[i+1])i++;
        }
    }
}

int main()
{
    //c=0;
    while(scanf("%d",&n)&&n)
    {
        flag=sum=0;
        memset(used,0,sizeof(used));
        for(int i=0;i<n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        sort(a,a+n,cmp);
        for(int i=a[0];i<=sum;i++)
        {
            if(sum%i) continue;
            num=sum/i;
            dfs(0,0,0);
            if(flag){
            printf("%d\n",i);
            break;
            }
        }
        //cout<<c<<endl;

    }
    return 0;
}