算法学习笔记（二）——01背包问题之回溯解法

　　背包问题，相信各位看官肯定都有所耳闻！笔者就在此简单的描述一下背包问题：

给定一背包和n件物品，背包的容量为c，第i件物品的重量为w[i],价值为v[i]（1<=i<=n）;问装那些物品，可使得价值最大？

      思路分析：显然，每种物品不外乎两种选择：装入和不装入背包！若将装入用状态1表示，不装入用状态0表示；那么就可构成一个二叉树！一共有n层，所以就可通过从第一层开始遍历搜索，在装入的物品总重量不大于c的情况下，找到最优解了！

思路还是蛮简单的，别的不多说，直接上代码：

public class Demo1 {
    private static int c = 10;                  //背包容量
    private static int[] w= {0,2,2,6,5,5};                //每个物体的重量：5个物体
    private static int[] v = {0,6,3,5,4,6};                //每个物体的价值
    private static int[] x= new int[6];                    //存放每个物体的选中情况
    private static int bestcp = 0;                        //当前的最优解
    private static int[] bestcpArr = new int[6];
    private static int count = 0;
    private static int n = 5;                        //物体的数目
    public static void main(String[] args) {
        backtrack(1, 0 ,0);
        for(int i =0 ; i < bestcpArr.length ;i++){
            System.out.print(bestcpArr[i]);
        }
        System.out.println("");
        System.out.println(bestcp);
        System.out.println("该树有" + count +"种遍历方式");
    }
    /**
     * 
     * @param i：查找到了第i个物品（i从1开始索引）
     * @param cv：当前包中价值
     * @param cw:当前包中重量
     */
    private static void backtrack(int i , int cw , int cv) {
        count++;
        if (i > n) {
            if (cv  > bestcp) {
                bestcp = cv;
                for(int j = 0 ; j < 6 ;j++){
                    bestcpArr[j]= x[j];
                }
            }
        }else{
//            开始遍历，如果k=0，则表示不装下此物品，k=1，则表示装下此物品
            for(int k = 0 ; k <= 1; k++){
                x[i] = k;
                if (cw + w[i] <= c) {
                    cv += v[i] * k;
                    cw +=w[i] * k;
                    backtrack(i + 1, cw, cv);
                    cv -= v[i] * k;
                    cw -=w[i] * k;
                }
            }
        }
    }
}

　　我们知道，回溯法的效率并不是很高的！因为回溯法，就其本质而言，还是属于穷举！只不过它就提供了一个穷举的思路：回溯！的确也是这样，上面代码中的例子中的物品只由5个，换句话说，所构成的二叉树也只有5层！但当物品有10个，20个，甚至100个话，构成的二叉树是多么的庞大！（笔者觉得不可想象深度为100的二叉树）！故在上述代码的基础上，很有必要去做一个算法的优化！在网上看了别人的博客之后，大致知道了一个思路：即在不断的遍历左子树（即不断的将物品装入）的过程中，如果出现了不能再装入下一物品的情况时，这时就需要去遍历右子树！但是如果，如果在剩余容量情况下，将剩余容量的背包装满（如果大于0且小于物品的重量的话，按照单位重量的价值乘以剩余容量来算）的情况下 得到的总价值比当前最优解还要的小的话，那么该右子树是完全没有必要去遍历，而需要直接剪除的！这样就达到了优化的目的！代码如下：

/**

 *    本算法的上界函数是这样定义的！首先利用冒泡法排序，按照单位价值右高到低开始顺序排列！

 *    这样的话，就能保证，先装进去的是性价比（自己发明的，勿喷）最优的！而在上界函数中，也是如此，求的是剩余

 *        容量在右子树所能容纳的最高价值（背包容量允许情况下），一旦小于当前最优解，那么就

 *        没有继续遍历该右子树的必要

 *

 */

public class Demo2 {
    private static int n;// 物品数量
    private static double c;// 背包容量
    private static double[] v = new double[100];// 各个物品的价值
    private static double[] w = new double[100];// 各个物品的重量
    private static double cw = 0.0;// 当前背包重量
    private static double cp = 0.0;// 当前背包中物品价值
    private static double bestp = 0.0;// 当前最优价值
    private static double[] perp = new double[100];// 单位物品价值排序后
    private static int order[] = new int[100];// 物品编号
    private static int[] put = new int[100];// 设置是否装入

    // 按单位价值排序
    private static void knapsack() {
        int i, j;
        int temporder = 0;
        double temp = 0.0;

        for (i = 1; i <= n; i++)
            perp[i] = v[i] / w[i];
        for (i = 1; i <= n - 1; i++) {
            for (j = i + 1; j <= n; j++)
                if (perp[i] < perp[j])// 冒泡排序perp[],order[],sortv[],sortw[]
                {
                    temp = perp[i];
                    perp[i] = perp[i];
                    perp[j] = temp;

                    temporder = order[i];
                    order[i] = order[j];
                    order[j] = temporder;
                    temp = v[i];
                    v[i] = v[j];
                    v[j] = temp;

                    temp = w[i];
                    w[i] = w[j];
                    w[j] = temp;
                }
        }
    }

    // 回溯函数
    private static void backtrack(int i) {
        if (i > n) {
            bestp = cp;
            return;
        }
//        将物品装进背包：此种情况的话
        if (cw + w[i] <= c) {
            cw += w[i];
            cp += v[i];
            put[i] = 1;
            backtrack(i + 1);
            cw -= w[i];
            cp -= v[i];
        }
        if (bound(i + 1) > bestp)// 符合条件搜索右子数
            backtrack(i + 1);
    }

    // 计算上界函数

    //算法剩余容量的情况下最多能装的价值
    private static double bound(int i) {
        double leftw = c - cw;
        double b = cp;
        while (i <= n && w[i] <= leftw) {
            leftw -= w[i];
            b += v[i];
            i++;
        }
        if (i <= n)
            b += v[i] / w[i] * leftw;
        return b;

    }

    public static void main(String[] args) {
        // private static int[] w= {0,2,2,6,5,5}; //每个物体的重量：5个物体
        // private static int[] v = {0,6,3,5,4,6}; //每个物体的价值
        v[0] = 0;
        v[1] = 6;
        v[2] = 3;
        v[3] = 5;
        v[4] = 4;
        v[5] = 6;
        
        w[0] = 0;
        w[1] = 2;
        w[2] = 2;
        w[3] = 6;
        w[4] = 5;
        w[5] = 5;
        
        n = 5;
        c = 10;
        
        knapsack();
        
        backtrack(1);
        System.out.println(bestp);
        for (int i = 1; i <= n; i++) {
            System.out.print(put[i] + " ");
        }
        System.out.println("");
    }
}

　　 现在，我们来分析下时间复杂度，最好的情况当然是能够剪除所有的右子树，而最优的物品选择刚好全在左子树上了！而最坏的情况自然是搜索右子树的次数最多了呀！

 到此，直接遍历穷举和优化之后的回溯法来解决10背包问题的分析解答终于写完了！写了一上午啊！

 　   笔者水平有限，有纰漏之处勿喷！

 

参考博客：优化的回溯法解决10背包问题

             遍历的回溯法解决10背包问题