动态规划背包问题

01背包

1. 确定dp数组以及下标的含义: dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。两个维度需要表示，分别是：物品 和 背包容量

状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 

• 不放入当前物品 i 的情况下的最大价值，即 dp[i - 1][j]。
• 放入当前物品 i 的情况下的最大价值，即 dp[i - 1][j - weight[i]] + value[i]。

2. 初始化 dp 数组

在背包问题中，背包容量确实是量化的，通常用一个整数 bagweight 来表示背包的最大承重能力。

for (int j = weight[0]; j <= bagweight; j++) { dp[0][j] = value[0]; }

如果背包容量大于或等于第一个物品的重量，那么我们可以选择放入或不放入第一个物品。如果放入，则背包的价值至少为第一个物品的价值 value[0]。注意，这个循环从 weight[0] 开始，因为如果背包容量小于第一个物品的重量，那么就不能放入第一个物品，最大价值仍然是0。

例题：小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。他需要带一些研究材料，但是他的行李箱空间有限。这些研究材料包括实验设备、文献资料和实验样本等等，它们各自占据不同的空间，并且具有不同的价值。 

小明的行李空间为 N，问小明应该如何抉择，才能携带最大价值的研究材料，每种研究材料只能选择一次，并且只有选与不选两种选择，不能进行切割。

1. 背包容量 N：这是小明的行李空间，表示背包能容纳物品的总重量。
2. 物品重量 weight 数组：包含每种研究材料所占空间的数组。
3. 物品价值 value 数组：包含每种研究材料价值的数组。
4. dp 数组：动态规划表，dp[i][j] 表示在考虑前 i 个物品，且背包容量为 j 时能够获得的最大价值。

vector<vector<int>> dp(M, vector<int>(N + 1, 0)); // M 为物品种类数，N 为背包容量

初始化了 dp 数组，其中 M 是物品的种类数，N + 1 是背包容量加一（因为数组索引从 0 开始）。

for (int j = weight[0]; j <= N; j++) { dp[0][j] = value[0]; }初始化第一个物品在不同背包容量下的最大价值。如果研究材料所占空间小于等于背包容量，可放入。

如果背包容量 N 是 1，但第一个物品的重量 weight[0] 大于 1，那么这个物品就无法放入背包中。在这种情况下，初始化循环将不会执行（因为 weight[0] 大于 N），dp[0][j] 将保持为 0，这符合我们的预期，因为无法放入任何物品。

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n, bagweight;// bagweight代表行李箱空间

    cin >> n >> bagweight;

    vector<int> weight(n, 0); // 存储每件物品所占空间
    vector<int> value(n, 0);  // 存储每件物品价值

    for(int i = 0; i < n; ++i) {
        cin >> weight[i];
    }
    for(int j = 0; j < n; ++j) {
        cin >> value[j];
    }
    // dp数组, dp[i][j]代表行李箱空间为j的情况下,从下标为[0, i]的物品里面任意取,能达到的最大价值
    vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));

    // 初始化, 因为需要用到dp[i - 1]的值
    // j < weight[0]已在上方被初始化为0
    // j >= weight[0]的值就初始化为value[0]
    for (int j = weight[0]; j <= bagweight; j++) {
        dp[0][j] = value[0];
    }

    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]; // 如果装不下这个物品,那么就继承dp[i - 1][j]的值
            else {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
            }
        }
    }
    cout << dp[n - 1][bagweight] << endl;

    return 0;
}

416. 分割等和子集

给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

注意: 每个数组中的元素不会超过 100 数组的大小不会超过 200

要明确本题中我们要使用的是01背包，因为元素我们只能用一次。

回归主题：首先，本题要求集合里能否出现总和为 sum / 2 的子集。

• 背包的体积为sum / 2
• 背包要放入的商品（集合里的元素）重量为 元素的数值，价值也为元素的数值
• 背包如果正好装满，说明找到了总和为 sum / 2 的子集。
• 背包中每一个元素是不可重复放入。

1. 初始化：首先计算数组nums的总和sum，如果总和是奇数，则无法平分，直接返回false。如果总和是偶数，则计算目标总和target为sum / 2。

2. 动态规划数组初始化：dp数组的大小设置为10001，所有元素初始化为0。这个大小足够覆盖所有可能的总和，因为题目中提到数组元素的最大值不会超过100，数组大小不会超过200，总和不会超过20000。

3. 填充动态规划数组：使用两层循环来填充dp数组。外层循环遍历数组nums中的每个元素，内层循环从target开始递减，直到当前元素的值。这里从大到小遍历是因为每个元素只能使用一次，我们需要检查是否可以用当前元素来更新dp[j]的值。

4. 状态转移：对于每个j，如果dp[j - nums[i]]已经为真（即存在一个子集其总和为j - nums[i]），那么我们可以加上当前元素nums[i]来尝试构成总和为j的子集。如果这样做可以构成，就更新dp[j]为真。

5. 检查结果：最后，检查dp[target]==target 是否为真。如果为真，说明存在一个子集的总和等于target，即数组可以被分成两个总和相等的子集，返回true；否则返回false。

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;

        // dp[i]中的i表示背包内总和
        // 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
        // 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
        vector<int> dp(10001, 0);
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        // 也可以使用库函数一步求和
        // int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2 == 1) return false;
        int target = sum / 2;

        // 开始 01背包
        for(int i = 0; i < nums.size(); i++) {
            for(int j = target; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入，所以从大到小遍历
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        // 集合中的元素正好可以凑成总和target
        if (dp[target] == target) return true;
        return false;
    }
};

1049.最后一块石头的重量II

有一堆石头，每块石头的重量都是正整数。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；

如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0

这个问题实际上是一个变种的背包问题，我们可以通过动态规划的方法来解决。在这个问题中，我们的目标是找到一种粉碎石头的方式，使得最后剩下的石头的重量最小。这个问题可以转化为一个类似于01背包问题的场景，其中石头的重量相当于背包问题中物品的重量，而我们希望达到的总重量（即背包的容量）是所有石头重量的一半。

dp[j]表示在所有石头粉碎后，剩下的石头总重量为j时，能达到的最小重量，

最后dp[target]里是容量为target的背包所能背的最大重量。

那么分成两堆石头，一堆石头的总重量是dp[target]，另一堆就是sum - dp[target]。

和前面的很像，还是分组目标为一半，但是返回的是 (sum - dp[target]) - dp[target]。

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        vector<int> dp(15001, 0);
        int sum = 0;
        for (int i = 0; i < stones.size(); i++) sum += stones[i];
        int target = sum / 2;
        for (int i = 0; i < stones.size(); i++) { // 遍历物品
            for (int j = target; j >= stones[i]; j--) { // 遍历背包
                dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - dp[target] - dp[target];
    }
};