poj1011

这篇文章我参考了很多

http://hi.baidu.com/jobxys/blog/item/d11aa30086863a13728b6594.html

题目大意：给出一些长度不大于 50 的木棍， 要求你把这些小木棍拼成
*             长度相同木棍，当然长度越小越好。
* 解题思路：这个题最近做了很多次，我比较有发言权了。
*             思想很简单，一个接一个的把木棍拼起来，最后把木棍用光。
*             关键的地方是几个剪枝技巧：
*                   设所有木棍的总长度为 Sum, 最终的答案是 L。 
*             1. 首先要明白， Sum一定要能被 L 整除。 
*             2. L 一定 大于等于 题目给出的最长的木棍的长度 Max。
*                  由上述两点，我们想到，可以从 Max 开始递增地枚举 L, 
*                直到成功地拼出 Sum/L 支长度为 L 的木棍。
*                    搜索种的剪枝技巧： 
*             3. 将输入的输入从大到小排序，这么做是因为一支长度为 K 
*                的完整木棍，总比几支短的小木棍拼成的要好。
*                形象一些：
*                  如果我要拼 2 支长为8的木棍，第一支木棍我拼成 
*                          5 + 3
*                  然后拼第二支木棍但是失败了，而我手中还有长为 2 和 1 
*                  的木棍，我可以用 5 + 2 + 1 拼好第一支，再尝试拼第二
*                  支，仔细想一想，就会发现这样做没意义，注定要失败的。     
*                  我们应该留下 2+1 因为 2+1 比 3 更灵活。 
*             4. 相同长度的木棍不要搜索多次， 比如：
*                我手中有一些木棍, 其中有 2 根长为 4 的木棍， 当前搜索
*                状态是 5+4+.... (即表示长度为 5,4,2 的三支拼在一起, 
*                ...表示深层的即将搜索的部分), 进行深搜后不成功，故我
*                没必要用另一个 4 在进行 5+4+...
*             5. 将开始搜索一支长为 L 的木棍时，我们总是以当前最长的未
*                被使用的 木棍开始，如果搜索不成功，那么以比它短的开始
*                那么也一定不能取得全局的成功。因为每一支题目给出的木棍
*                都要被用到。
*                如果，有 
*                    4
*                    5 4 4 3 2
*                  想拼成长为 6 的木棍，那么从 5 开始， 但是显然没有能与 5
*                  一起拼成 6 的，那么我就没必要去尝试从 4 开始的，因为
*                  最终 5 一定会被遗弃。在拼第 2 3 ... 支木棍时，一样。 
*             6. 最后的最简单的一个就是，
*                      for(int i = 0; i < n; i++)
*                          for(int j = 0; j < n; j++)
*                               {}
*                与
*                      for(int i = 0; i < n; i++)
*                          for(int j = i+1; j < n; j++)
*                               {} 
*                的区别，这个不多说了。
*             7. 我用过的另一个剪枝，但是对 poj 的数据效果一般，
*                用一个数组， Sum[i] 保存 第 i 个木棍之后，即比第 i 枝
*                木棍短或与之相等所有的木棍的长度之和。
*                试想，如果剩余的所有木棍加在一起都不能和我当前的状态拼
*                出一直长为 L 的木棍(从长度来看)，还有必要搜下去么？ 

上面是搜索剪枝的思路

 

 

http://blog.csdn.net/nevergiveup23/article/details/3014328

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
    // 标记是否使用过这个棒子，在递归时后需要标记
    static boolean[] used;
    // 棒子总数量
    static int len;
    // 棒子的数组
    static int[] s;
    // 总长度
    static int sum;
    // 假设的原棒长
    static int max;
    // 棒子数量 = 总长度/原棒长
    static int parts;
    public static void main(String[] args) throws Exception {
        BufferedReader read = new BufferedReader(new InputStreamReader(
                System.in));
        while ((len = Integer.parseInt(read.readLine())) != 0) {
            s = new int[len];
            StringTokenizer take = new StringTokenizer(read.readLine());
            int index = 0;
            sum = 0;
            used = new boolean[len];
            while (take.hasMoreTokens()) {
                s[index] = Integer.parseInt(take.nextToken());
                sum += s[index++];
            }
            Arrays.sort(s);
            // 起始假设原棒长=最长棒的长度
            max = s[len - 1];
            for (; max <= sum; max++) {
                // 穷举棒子长度，只取总长度模原长度=0的情况
                if (sum % max == 0) {
                    // 原棒的数量
                    parts = sum / max;
                    // 递归搜索
                    if (search(0, len - 1, 0)) {
                        System.out.println(max);
                        break;
                    }
                }
            }
        }
    }
    public static boolean search(int res, int next, int cpl) {
        // 如果凑成了一根棒子，继续凑下面一个
        if (res == max) {
            // 这个是现在这个棒子的长度，初始化为0
            res = 0;
            // 这里等于len-2只是一个初始化，反正len-1肯定被占用了，我何不从len-2开始呢，反正后面还要判断有没有被使用过
            next = len - 2;
            // 这个是已经凑成的棒子数
            cpl++;
        }
        // 如果凑成了parts这么多棒子，那就结束了，搜索完成
        if (cpl == parts) {
            return true;
        }
        // 从后往前搜索
        while (next >= 0) {
            // 如果没有被使用的话
            if (used[next] == false) {
                // 那么判断下这根棒子能不能放进我现在剩余的空间里面
                if (res + s[next] <= max) {
                    // 能放得进的话，那么标记这跟棒子已经使用过了
                    used[next] = true;
                    // 继续寻找下一根
                    if (search(res + s[next], next - 1, cpl)) {
                        // 返回结果为true表示全部凑成功了
                        return true;
                    }
                    // 如果没有凑成功，我把这根棒子不放进去并标记为false
                    used[next] = false;
                    // 如果第一块的都没放不进去的话，那么说明找的有问题，直接退出了
                    if (res == 0) {
                        break;
                    }
                    // 如果现在本来应该尝试成功的（已经拼成了一个原棒，应该进入递归变成0的）却失败了，说明找的有问题
                    if (res + s[next] == max) {
                        break;
                    }
                }
                // 找下一块不相等的棒子
                int i = next - 1;
                while (i >= 0 && s[i] == s[next]) {
                    i--;
                }
                next = i;
                // 如果剩下的和比我需要的棒子还小的话，就不用凑了
                int l_s = 0;
                for (int j = next; j >= 0; j--) {
                    if (!used[j]) {
                        l_s += s[j];
                    }
                }
                if (l_s < max - res) {
                    break;
                }
                // 继续找下面的棒子
                continue;
            }
            // 说明这个棒子被用过了，找下面一个棒子
            next--;
        }
        // 如果从这里出来的话，表示程序不能凑完所有棒子
        return false;
    }
}

 

#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;



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


int len[100], used[100];
int Min;
int sum;
int n;



int find(int pos,int rest ,int totalrest)//这里把min的值赋给rest，但是注意rest的值在后面是会发生变化的，用min还是rest请注意
{
    int i;
    if(totalrest==Min)//这里可以把Min换成rest，但是Min更好，时间更少,所以下面的那句话可以加上
    {
        return 1;
    }
    if(totalrest==rest)//可以加上
    {
        return 1;
    }

    for(i=pos;i<n;i++)
         if(!used[i] && len[i]<=rest)
        {
            used[i]=1;
            if(len[i]==rest)//注意这里
            {
                if(find(0,Min,totalrest-len[i]))//min改为len[i]  ||   这里的0不可改为i+1，因为如果第一次循环不成功，则min的值会变大，则要从头开始找
                return 1;
            }
            else if (find(i+1,rest-len[i],totalrest-len[i]))
                return 1;

            used[i]=0;
            if(len[i]==rest)
                return 0;
            if(totalrest==sum)
                return 0;
            if(rest==Min)
                return 0;
            while(len[i+1]==len[i])
            {
                i++;
            }

        }

        return 0;
}
int main()
{
    int i;
    while(1)
    {
        sum=0;
        scanf("%d",&n);
        if(n==0) break;
        memset(used,0,sizeof(used));
        for(i=0;i<n;i++)
        {
            scanf("%d",&len[i]);
            sum+=len[i];
        }
        sort(len,len+n,cmp);
        Min=len[0];
        while((sum%Min)!=0)
        {
            Min++;
        }
        while(find(0,Min,sum)==0)
        {
            Min++;
            while((sum%Min)!=0)
            {
                Min++;
            }
        }
        printf("%d\n",Min);
    }
    return 0;
}