动态规划-题型【01背包】

---

1. 01背包基础

void test_1_wei_bag_problem() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;

    // 初始化
    vector<int> 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;
}

2. 分割等和子集

将一个数组分割成两个子集，使得两个子集的元素和相等。
解答：
dp[j]：背包总容量为j，最大可以凑成j的子集总和为dp[j]
递推公式：dp[j]=max(dp[j],dp[j-nums[i]]+nums[i]);
初始化：全部初始化为0
遍历顺序：同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]);
    }
}

整体代码：

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;
    }
};

3. 最后一块石头的重量

示例： 输入：[2,7,4,1,8,1] 输出：1 解释： 组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]， 组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]， 组合 2 和 1，得到 1，所以数组转化为 [1,1,1]， 组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。
分析：本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成01背包。
dp[j]：容量为j的背包，最多可以背dp[j]这么重的石头。
递推公式：dp[j]=max(dp[j],dp[j-stones[i]]+stones[i])；
初始化：全部初始化为0；
最后dp[target]里是容量为target的背包所能背的最大重量。
那么分成两堆石头，一堆石头的总重量是dp[target]，另一堆就是sum - dp[target]。
在计算target的时候，target = sum / 2 因为是向下取整，所以sum - dp[target] 一定是大于等于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];
    }
};

4. 目标和

给定一个整数数组nums和一个target，向数组中每个整数前添加±，构造成一个表达式，返回运算结果等于target的不同表达式的数目。
解答：
left组合-right组合=target；left组合+right组合=sum，sum是固定的，可以解得：
left组合=(target+sum)/2，那么此问题就转换为在nums中找出和为left的组合，装满容量为left的背包，有几种方法
dp[j]：填满j容量的背包，有dp[j]种方法；
递推公式：
不考虑nums[i]的情况，填满容量为j的背包，有dp[j]种方法；
考虑nums[i]的情况，凑成的dp[j]，有dp[j-nums[i]]种方法；
对于求多少种方法的问题，一般都要累加：
dp[j]+=dp[j-nums[i]]。
初始化：dp[0]=1，其他初始化为0；

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int S) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) sum += nums[i];
        if (abs(S) > sum) return 0; // 此时没有方案
        if ((S + sum) % 2 == 1) return 0; // 此时没有方案
        int bagSize = (S + sum) / 2;
		if (bagsize < 0) return 0;
        vector<int> dp(bagSize + 1, 0);
        dp[0] = 1;
        for (int i = 0; i < nums.size(); i++) {
            for (int j = bagSize; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[bagSize];
    }
};