背包问题中的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];
}