1️⃣ 01背包问题

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

首先可以回溯搜索出所有的情况 , 但是这样一来时间复杂度直接起飞 O(2ⁿ) , 需要使用动态规划来进行优化

背包最大重量为4。

物品为：

	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

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

二维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物品。

代码初始化如下：

for (int j = 0 ; j < weight[0]; j++) {  
    // 当然这一步，如果把dp数组预先初始化为0了，这一步就可以省略，但很多同学应该没有想清楚这一点。
    dp[0][j] = 0;
}

for (int j = weight[0]; j <= bagweight; j++) {// 正序遍历
    dp[0][j] = value[0];
}

此时dp数组初始化情况如图所示：

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，更方便一些。

如图：

最后初始化代码如下：

// 初始化 dp
int[][]dp =new int[weight.length][bagWeight+1]{};
for (int j = weight[0]; j <= bagweight; j++) {
    dp[0][j] = value[0];
}

4.确定遍历顺序

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

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

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

先遍历物品，然后遍历背包重量。

// 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数组）

例如：

// weight数组的大小 就是物品个数
for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
    for(int i = 1; i < weight.size(); i++) { // 遍历物品
        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]的左上角方向（包括正上方向），

那么先遍历物品，再遍历背包的过程如图所示：

动态规划-背包问题5

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

动态规划-背包问题6

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

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

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

5.举例推导dp数组

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

动态规划-背包问题4

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

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

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

很多同学做dp题目，遇到各种问题，然后凭感觉东改改西改改，怎么改都不对，或者稀里糊涂就改过了。

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

6.完整java测试代码

class BagProblemTest{
        @Test
    public void BagTest(){
        int[]weights=new int[]{1,3,4};
        int[]values=new int[]{15,20,30};
        int bagWeight=7;
        BagProblemTest(weights,values,bagWeight);
    }
    void BagProblemTest(int[]weight,int[]values,int bagWeight){
        int cnt=weight.length;
        int[][] dp=new int[cnt+1][bagWeight+1]; //dp[i][j] 表示 0~i 件物品的最大利润 , i 表示物品, j 表示使用的重量
        for (int j = weight[0]; j <= bagWeight; j++) { // 初始化数据,
            dp[0][j]=0;
        }
        for (int i = 1; i <= cnt; i++) {
            for (int j = 1; j <= bagWeight; j++) {
                if(j<weight[i-1]){ // 当前的重量小于上一件物品的重量 , 那么利润与上一层的背包一样
                    dp[i][j]=dp[i-1][j];
                }else{
                    // 状态转移, 当前的最大值为,不放上一件物品的values + 放当前物品的value  or 不放当前的物品的max
                    dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-weight[i-1]]+values[i-1]);
                }
            }
/**
*当 当前遍历到的重量刚好大于上一件物品的重量但是小于当前物品的重量+上一件物品的重量, 也就是 只能在上一件物品与当前的物品二选一,
* 此时就是利用Math.max()  通过上一层不选上一个物品的结果(0) : 也就是当前物品的价值 与上一件物品的价值比较, 选大的那个
* 直到重量能够同时满足 装下之前的物品 + 当前的物品
对于后面的物品来说, 区别在于 0 变为了之前的物品的values*/
        }
        for (int i = 0; i <= cnt; i++){
            for (int j = 0; j <= bagWeight; j++){
                System.out.print(dp[i][j] + " ");
            }
            System.out.print("\n");
        }
}