浅谈对0-1背包的理解

刷题刷到动态规划时，免不了碰到0-1背包的题目。考虑到0-1背包具有很强的移植性，所以多花点时间彻底弄懂它也是值得的。下面是我个人对于0-1背包问题的理解，如有不恰当的地方，烦请大佬指正。

0-1背包的问题是：有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

这里利用动规四部曲分析以下：

确定dp数组：dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包（即决策完第i件且容量为j时的取舍，也可理解为完成了前i件且容量从0到j的情况的取舍），最大的价值总和。注意，此时背包不一定能被装满，背包中物品的总重量<=j。因为所选物品的重量不一定能够恰好凑成j，比如wieght=[1,3],背包容量为4，那么j的取值就应该是[0, 4],但很明显，j=2时的背包中只能放weight=1的物品，另一件weight=3因为重量大于容量放不下，那么此时背包中的物品重量之和是小于j的。如果背包中的物品重量之和=j，就说明背包中的物品重量之和恰好为j。

确定递推公式：dp[i][j] = max{dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]}。对于第i件，有2种选择，取或者不取。不取对应着dp[i - 1][j]，取对应着dp[i - 1][j - weight[i]] + value[i]，由于要取得时最大价值，故取max。这个递推公式也表明了第i件物品的决策依赖于第i-1件物品的决策，第i-1件又依赖于第i-2件的决策，相当于把决策第i件分解成许多子事件。而事件可分解为子事件也是dp算法的特征之一

初始化dp数组：j >= weight[0]时，dp[0][j]=value[0]，其他值都初始化为0，方便之后被其他最大值覆盖

确定遍历顺序：由于dp[i - 1][j]和dp[i][j - weight[i]]分别在dp[i][j]的左边和上边，所以我们可以采用从左到右，从上到下的顺序遍历

代码如下：

public static void main(String[] args) {
        int[] weight = {1, 3, 4};
        int[] value = {15, 20, 30};
        int bagsize = 4;
        testweightbagproblem(weight, value, bagsize);
    }

    public static void testweightbagproblem(int[] weight, int[] value, int bagsize){
        int wlen = weight.length, value0 = 0;
        //定义dp数组：dp[i][j]表示背包容量为j时，前i个物品能获得的最大价值
        int[][] dp = new int[wlen][bagsize + 1];
        //初始化：对第0件物品进行决策，只要背包容量>=weight[0]的，都初始化为value[0]
        for(int j = weight[0]; j <=bagsize; j++)
            dp[0][j] = value[0];
        //遍历顺序：先遍历物品，再遍历背包容量
        for (int i = 1; i < wlen; i++){
            for (int j = 1; j <= bagsize; j++){//j从1开始是因为j=0时代表背包容量为0，则价值自然也为0
                if (j < weight[i]){//如果背包容量小于这一次要取得物品得重量，那么对于这一件物品得决策就只能是不取
                    dp[i][j] = dp[i - 1][j];
                }else{
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
                }
            }
        }
        //打印dp数组
        for (int i = 0; i <= wlen; i++){
            for (int j = 0; j <= bagsize; j++){
                System.out.print(dp[i][j] + " ");
            }
            System.out.print("\n");
        }
    }

分析递推公式:dp[i][j] = max{dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]},可知dp[i][j]只是依赖于dp[i - 1]这一层的取值而已，所以我们可以考虑只用个一维数组dp[j]来推导。依旧是dp四部曲：

确定dp数组：dp[j]表示背包容量为j时背包中物品的价值之和的最大值

确定递推公式：dp[j] = max{dp[j], dp[j - weight[i]] + value[i]}。其中i表示决策的第i件物品。中括号外的dp[j]是这一层要决策的，中括号内的dp[j]是上一层决策完第i-1件物品且背包容量为j时的最大价值，dp[j - weight[i]]是上一层决策完第i-1件物品且背包容量为j-weight[i]时的最大价值。递推公式中的第一项对应不取第i件的情况，第二项对应取第i件的情况。

初始化dp数组：一开始对于第0件物品(下标为0)的决策显然是j>=weight[0]时，dp[j]=value[0],其他都赋值0.

确定遍历顺序：外层循环遍历物品按顺序遍历即可。但是内层循环遍历j时就有讲究了，必须使用倒序遍历。因为按照我们的想法是依赖于第i-1物品的决策结果来决策第i件，如果使用正序遍历，那么dp[j] = max{dp[j], dp[j - weight[i]] + value[i]}中的dp[j-weight[i]]这一项就已经是使用了第i件物品的决策结果了，不满足我们依赖于第i-1物品的决策结果来决策第i件的想法。使用正序遍历造成的后果是可能会重复取第i件物品。即dp[j-weight[i]]已经是取了dp[j-weight[i] - weight[i]]+value[i]这一项了，而我们在决策dp[j]时，可能又会取到p[j - weight[i]] + value[i]这一项，就相当于dp[j]取了2遍地第i件，这违背了0-1背包中每件物品只能取一次的条件

代码如下：

public static void main(String[] args) {
        int[] weight = {1, 3, 4};
        int[] value = {15, 20, 30};
        int bagsize = 4;
        testweightbagproblem(weight, value, bagsize);
    }

    public static void testweightbagproblem(int[] weight, int[] value, int bagsize){
        int wlen = weight.length, value0 = 0;
        //定义dp数组：dp[j]表示背包容量为j时背包中物品的最大价值
        int[] dp = new int[bagsize + 1];
        //初始化：对第0件物品进行决策，只要背包容量>=weight[0]的，都初始化为value[0]
        for(int j = weight[0]; j <=bagsize; j++)
            dp[j] = value[0];
        //遍历顺序：先遍历物品，再遍历背包容量
        for (int i = 1; i < wlen; i++){
            for (int j = bagsize; j >= weight[i]; j--){//j从1开始是因为j=0时代表背包容量为0，则价值自然也为0
                    dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
                }
            }
        }
        //打印dp数组
            for (int j = 0; j <= bagsize; j++){
                System.out.print(dp[j] + " ");
            }      
    }