背包问题中的01背包

01背包

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

主要有四个重要参数：物品个数n， 物品重量weight， 物品的价值value，背包能背的重量w

二维dp数组01背包

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

   dp[i] [j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

2. 确定递推公式

• 不放物品i：

  dp[i] [j] = dp[i - 1] [j] : 遍历到第i个物品的时候，我们不选择将第i个物品放入，于是此时背包的最大价值就等于前一个物品放入的最大价值。

• 放物品i：

  dp[i] [j] = dp[i - 1] [j - weight[i]] + value[i] ： 将第i个物品放入之后，背包的容量就要减去weight[i]，同时背包中价值的总和要加上value[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
  • 如果j > weight[0]，表示当前背包的容量是大于第一个物品的，那么此时dp[0] [j] = value[0]

• 其他下标：都初始化成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]);
       }
   }
  

• 先背包后物品

   // 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]);
       }
   }
  

5. 举例推导dp数组

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

二维dp数组01背包的代码实现

 #include <iostream>
 #include <vector>
 using namespace std;
 ​
 int getMaxValue01Bag(vector<int> &weight, vector<int> &value, int bag_size){
     //参数检验
     if(weight.size() != value.size() || bag_size < 0){
         return 0;
     }
 ​
     int weight_size = weight.size();
 ​
     //声明dp数组
     vector<vector<int>> dp(weight_size, vector<int>(bag_size + 1, 0));
 ​
     //初始化dp数组
     for(int j = weight[0]; j <= bag_size; j++){     
         dp[0][j] = value[0];
     }
 ​
     //遍历（先物品后背包）
     for(int i = 1; i < weight_size; i++){
         for(int j = 0; j <= bag_size; 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]);
             } 
             cout << dp[i][j] << " ";
         }
         cout << endl;
     }
 ​
     //先背包后物品
     /*
     for(int j = 0; j < bag_size; 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]);
             } 
         }
     }
     */
 ​
     return dp[weight_size - 1][bag_size];
 }
 ​
 int main()
 {
     vector<int> weight {1, 3, 4};
     vector<int> value {15, 20, 30};
     int bag_size = 4;
     int maxVal = getMaxValue01Bag(weight, value, bag_size);
     return 0;
 }

一维dp数组01背包

1. 确定dp数组的定义

   dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。

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

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

   由于整个将上一层的状态拷贝到下一层，所以计算本层的数据跟上一层的数据是一样的，就可以从二维数组中直接去掉i这个维度就行

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

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

   剩下的清况为了不覆盖我们推导出的值，也都初始化成0

4. 一维dp数组遍历顺序

   这里一维数组遍历的时候就不能任意物品和背包顺序

   先物品后背包 ：如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：背包里只放入了一个物品。

   遍历背包的时候倒序遍历（避免重复添加一个物品）（二维数组中状态的隔离的，一维数组中状态是依赖的）

5. 举例推导dp数组

一维dp数组01背包的代码实现

 // 一维dp
 int getMaxValue01Bag2(vector<int>& weight, vector<int>& value, int bag_size) {
     vector<int> dp(bag_size + 1, 0);
     for(int i = 0; i < weight.size(); i++){
         for(int j = bag_size; j >= weight[i]; j++){
              dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
         }
     }
 ​
     return dp[bag_size];
 }