算法备忘录~01背包问题

题目：

        有N件物品和⼀个最多能被重量为W 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每

件物品只能⽤⼀次 ，求解将哪些物品装⼊背包⾥物品价值总和最⼤。

        示例：

思路（二维数组）：

        动态规划五部曲：

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

            

         使⽤⼆维数组，即dp[i][j] 表示从下标为 [0-i] 的物品⾥任意取，放进容量

为 j 的背包，价值总和最⼤是多少 。

 

2. 确定递推公式

再回顾⼀下 dp[i][j] 的含义：从下标为 [0-i] 的物品⾥任意取，放进容量为 j 的背包，价值总和最⼤是多少。

那么可以有两个⽅向推出来 dp[i][j] ，

（1） 由dp[i - 1][j] 推出，即背包容量为 j ，⾥⾯不放物品 i 的最⼤价值，此时 dp[i][j]就是dp[i - 1][j]

（2）由 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[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 物品。

 4. 确定遍历顺序

有两个遍历的维度：物品与背包重量，可以先遍历物品，然后背包在内层依次遍历，反之亦可

5. 举例推导dp数组

 完整C++测试代码

void bag_problem()

{
        vector weight = {1,3,4};

        vector value = {15,20,30};

        int bagWeight = 4;

        //二维数组

        vector> dp(weight.size() + 1,vector(weight.size()b + 1,vector(bagWeight + 1,0));

        //初始化

        for(int j = bagWeight; j >= weight[0];j--)

        {

                dp[0][j] = dp[0][j - weight[0]] + value[0]; 

        }

        //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];//此处避免下一行代码j - weight[j]访问数组越界

                        else dp[i][j] = max(dp[i - 1][j],dp[i - 1][j - weight[j]] + value[i[);

                }

        }

cout<< dp[weight.size() - 1][bagWeight] << endl;

}

int main()

{

        bag_problem();

}

空间优化：

思路（一维数组）：

        动态规划五部曲：

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

         在⼀维dp 数组中， dp[j] 表示：容量为 j 的背包，所背的物品价值可以最⼤为 dp[j] 。

  2. ⼀维 dp 数组的递推公式

         dp[j]可以通过 dp[j - weight[j]] 推导出来， dp[j - weight[i]] 表示容量为 j - weight[i] 的背包所背的最⼤价值。

         dp[j - weight[i]] + value[i] 表示 容量为 j - 物品 i 重量 的背包 加上 物品 i 的价值。（也就是容量为 j 的背

包，放⼊物品 i 了之后的价值即： dp[j] ）

此时 dp[j] 有两个选择，⼀个是取⾃⼰ dp[j] ，⼀个是取 dp[j - weight[i]] + value[i] ，指定是取最⼤的，毕

竟是求最⼤价值，

所以递归公式为：

                                 ​​​​​​​        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

 3. ⼀维dp数组如何初始化

dp[j]表示：容量为j的背包，所背的物品价值可以最⼤为dp[j]，那么dp[0]就应该是0，因为背包容量为0 所背的物品的最⼤价值就是0，其他的默认为0即可。

4. ⼀维 dp 数组遍历顺序

for(int i = 0; i < weight.size(); i++) { // 遍历物品
 for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
 dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
 }
}

注意：遍历顺序不可颠倒，外物品，内层背包，内层遍历时需要倒序，以保证物品i只被放入一次，因为如果正序，访问dp[j]的时候无法访问到dp[j - weight[i]]的在上一轮循环的历史值，因为j - weight 小于j，已经在本轮的前面被更新了。所以从后往前循环，每次取得状态不会和之前取得状态重合，这样每种物品就只取⼀次了。

5. 举例推导 dp 数组

 ⼀维dp01背包完整C++测试代码

void test_1_wei_bag_problem() {
 vector weight = {1, 3, 4};
 vector value = {15, 20, 30};
 int bagWeight = 4;
 // 初始化
 vector dp(bagWeight + 1, 0);
 for(int i = 0; i < weight.size(); i++) { // 遍历物品
 for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
 dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
 }
 }
 cout << dp[bagWeight] << endl;
}

以上部分图文转载于代码随想录，仅作为个人学习使用，无商业用途，如侵必删！