动态规划之0-1背包问题理论基础-01

01背包

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

 这是标准的背包问题，以至于很多同学看了这个自然就会想到背包，甚至都不知道暴力的解法应该怎么解了。

这样其实是没有从底向上去思考，而是习惯性想到了背包，那么暴力的解法应该是怎么样的呢？

每一件物品其实只有两个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是$o(2^n)$，这里的n表示物品数量。

所以暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化！

在下面的讲解中，我举一个例子：背包最大重量为4。

物品为：

问背包能背的物品最大价值是多少？

以下讲解和图示中出现的数字都是以这个例子为例。

二维dp数组01背包

依然动规五部曲模板分析一波。

1. 确定dp数组以及下标的含义

对于背包问题，有一种写法， 是使用二维数组，即dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

只看这个二维数组的定义，大家一定会有点懵，看下面这个图：

要时刻记着这个dp数组的含义，下面的一些步骤都围绕这dp数组的含义进行的，如果哪里看懵了，就来回顾一下i代表什么，j又代表什么。

        2.确定递推公式

再回顾一下dp[i][j]的含义：从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。那么可以有两个方向推出来dp[i][j]，

• 不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(其实就是当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以背包内的价值依然和前面相同。)
• 放物品i：由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值

所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

       3.dp数组如何初始化

关于初始化，一定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。

---首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。如图：

---在看其他情况。状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出i 是由 i-1 推导出来，那么i为0的时候就一定要初始化。

dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。

那么很明显当 j < weight[0]的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小。

当j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。

dp[0][j] 和 dp[i][0] 都已经初始化了，那么其他下标应该初始化多少呢？

其实从递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出dp[i][j] 是由左上方数值推导出来了，那么 其他下标初始为什么数值都可以，因为都会被覆盖。

初始-1，初始-2，初始100，都可以！

但只不过一开始就统一把dp数组统一初始为0，更方便一些。

  4.确定遍历顺序

在如下图中，可以看出，有两个遍历的维度：物品与背包重量

那么问题来了，先遍历 物品还是先遍历背包重量呢？

其实都可以！！ 但是先遍历物品更好理解。

//C++代码 
// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品
    for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
        if (j < weight[i]) dp[i][j] = dp[i - 1][j];
        else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
    }
}

为什么也是可以的呢？

要理解递归的本质和递推的方向。

dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 递归公式中可以看出dp[i][j]是靠dp[i-1][j]和dp[i - 1][j - weight[i]]推导出来的。

dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向（包括正上方向），那么先遍历物品，再遍历背包的过程如图所示：

再来看看先遍历背包，再遍历物品呢，如图：

大家可以看出，虽然两个for循环遍历的次序不同，但是dp[i][j]所需要的数据就是左上角，根本不影响dp[i][j]公式的推导！

但先遍历物品再遍历背包这个顺序更好理解。

其实背包问题里，两个for循环的先后循序是非常有讲究的，理解遍历顺序其实比理解推导公式难多了。

5.举例推导dp数组

来看一下对应的dp数组的数值，如图：

 最终结果就是dp[2][4]。

建议大家此时自己在纸上推导一遍，看看dp数组里每一个数值是不是这样的。

做动态规划的题目，最好的过程就是自己在纸上举一个例子把对应的dp数组的数值推导一下，然后在动手写代码！

主要就是自己没有动手推导一下dp数组的演变过程，如果推导明白了，代码写出来就算有问题，只要把dp数组打印出来，对比一下和自己推导的有什么差异，很快就可以发现问题了。

总结：

讲了这么多才刚刚把二维dp的01背包讲完，这里大家其实可以发现最简单的是推导公式了，推导公式估计看一遍就记下来了，但难就难在如何初始化和遍历顺序上。

可能有的同学并没有注意到初始化 和 遍历顺序的重要性，我们后面做力扣上背包面试题目的时候，大家就会感受出来了。

讲解说明：

讨论到a【i】【j】时的两种情况怎么操作?为什么这么操作？
假设已经讨论到了a【i】【j】，即j容量下到前i个物品的讨论，有两种情况
1.选择不装第i个物品，则退回到i-1行，直接选择a【i-1】【j】作为该情况下最大价值
2.装第i个物品，则将背包j-物品i的体积 = f，直接看表中a【i-1】【f】+i物品的价值作为该情况下最大价值
比较两者选最大即a【i】【j】为真正的最大价值
这样做的原因主要就在于，表a【i】【j】以前的所有数据都已经代表了价值最大的最佳情况。

①不装i
不装i即需要到前i-1个里面选，也就是前i-1行j背包容量下的最大价值，同理，由于前面都已经是最优解，直接查表a【i-1】【j】就是不装i条件下的最大价值
②装i
0-1背包问题下每个物品只能放一件，所以用j-i物品的体积=f，查表a【i】【f】直接得到，装i时前f空间的最大价值。所以装i的最大价值就等于a【i】【f】+i的价值
因此比较两者价值大小选大者即可再次得到a【i】【j】情况下的最优解。

 一定要搞清楚dp的含义：
dp[i][j] 表示从前面【i-1】个物品里任意取，放到容量为j的背包里的最大值，这里的任意取其实是可以取1个 取2个 或者i-1个全取。
总之就是 每一个dp[i][j] 都是背包容量为j状态下的最优解。

递推公式怎么理解？
其实动态规划思想都是逐步推结果，每一步都是最优解。
当前物品可以选则拿或者不拿：
不拿：背包容量和背包里物品总价值都没有变化，和上一个状态下的总价值相同。
拿：背包容量减少，背包里的物品总价值=上一个状态下的总价值+当前物品的价值

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

    /**
     * 动态规划获得结果
     * @param weight  物品的重量
     * @param value   物品的价值
     * @param bagSize 背包的容量
     */
    public static void testWeightBagProblem(int[] weight, int[] value, int bagSize){

        // 创建dp数组
        int goods = weight.length;  // 获取物品的数量
        int[][] dp = new int[goods][bagSize + 1];

        // 初始化dp数组
        // 创建数组后，其中默认的值就是0
        //dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。
        for (int j = weight[0]; j <= bagSize; j++) {
            dp[0][j] = value[0]; 
        }

        // 填充dp数组
        // 方式一(好理解)：先遍历物品，然后遍历背包重量的代码
        for (int i = 1; i < weight.length; i++) {
            for (int j = 1; j <= bagSize; j++) {
                if (j < weight[i]) {
                    /**
                     * 当前背包的容量都没有当前物品i大的时候，是不放物品i的
                     * 那么前i-1个物品能放下的最大价值就是当前情况的最大价值
                     */
                    dp[i][j] = dp[i-1][j];
                } else {
                    /**
                     * 当前背包的容量可以放下物品i
                     * 那么此时分两种情况：
                     *    1、不放物品i
                     *    2、放物品i
                     * 比较这两种情况下，哪种背包中物品的最大价值最大
                     */
                    dp[i][j] = Math.max(dp[i-1][j] , dp[i-1][j-weight[i]] + value[i]);
                }
            }
        }

        // 打印dp数组
        for (int i = 0; i < goods; i++) {
            for (int j = 0; j <= bagSize; j++) {
                System.out.print(dp[i][j] + "\t");
            }
            System.out.println("\n");
        }
    }
}

    //打印dp数组方法二
    for(int[] arr : dp){
            System.out.println(Arrays.toString(arr));
        }
    }
}

 打印结果：

 

具体算法题 参见卡码网46. 携带研究材料（第六期模拟笔试）

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // 创建扫描器对象，用于读取用户输入
        Scanner sc = new Scanner(System.in);
        
        // 读取物品种类 M 和背包容量 N
        int M = sc.nextInt();
        int N = sc.nextInt();
        
        // 初始化数组用于存储物品的价值和重量
        int[] values = new int[M];
        int[] weights = new int[M];
        
        // 读取每个物品的重量
        for(int i = 0; i < M; i++) {
            weights[i] = sc.nextInt();
        }
        
        // 读取每个物品的价值
        for(int i = 0; i < M; i++) {
            values[i] = sc.nextInt();
        }
        
        // 初始化二维数组 dp，dp[i][j] 表示前 i 个物品中，在背包容量为 j 时的最大价值
        int[][] dp = new int[M][N+1];
        
        // 初始化第一个物品的情况
        // 如果背包容量大于等于第一个物品的重量，最大价值就是第一个物品的价值
        for(int i = weights[0]; i <= N; i++) {
            dp[0][i] = values[0];
        }
        
        // 处理后续的物品
        for(int i = 1; i < M; i++) {
            // 遍历所有可能的背包容量
            for(int j = 0; j <= N; j++) {
                // 如果当前物品的重量大于背包容量 j，不能将当前物品放入背包
                if(weights[i] > j) {
                    dp[i][j] = dp[i-1][j];
                } else {
                    // 当前物品可以放入背包
                    // 选择不放当前物品或者放当前物品，取最大值
                    dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-weights[i]] + values[i]);
                }
            }
        }
        
        // 输出结果，即最大价值
        System.out.println(dp[M-1][N]);
    }
}

代码思路总结：（ACM模式）

1.读取输入：

• 使用 Scanner 对象读取用户输入的物品种类 M 和背包容量 N。
• 初始化两个数组 values 和 weights 用于存储每个物品的价值和重量。

2.读取物品数据：

• 使用两个 for 循环分别读取每个物品的重量和价值。

3.初始化 DP 数组：

• 定义一个二维数组 dp，其中 dp[i][j] 表示前 i 个物品在背包容量为 j 时的最大价值。
• 初始化第一个物品的情况：如果背包容量大于等于第一个物品的重量，则最大价值就是第一个物品的价值。

4.动态规划过程：

• 使用两个嵌套循环遍历所有物品和所有可能的背包容量。
• 对于每个物品，如果当前物品的重量大于当前背包容量，则不能将当前物品放入背包，直接继承上一个状态的值。
• 如果当前物品可以放入背包，则选择放入或不放入当前物品，取两者中的最大值。

5.输出结果：

• 输出 dp[M-1][N]，即前 M 个物品在背包容量为 N 时的最大价值。