代码随想录算法训练营Day42|1049.最后一块石头的重量II、494.目标和、474.一和零

最后一块石头的重量II

1049. 最后一块石头的重量 II - 力扣（LeetCode）

考虑昨天的能否将一个数组分为两个和相等的子集，本题有类似的思路，即将左右分为左右两个和相近的子集，然后返回其差值，这里使用动态规划的话。

DP数组含义，dp[j]表示能够达到的总重量为j的石头的最大重量

背包容量从0到1501（根据题目要求变化）

dp[j] = max(dp[j], dp[j-nums[i]] + nums[i])，j为重量，i为石头的选择与否。

遍历顺序同样物品遍历在外，背包遍历在内层，且内层倒序遍历。

最后考虑对最后一块石头重量的返回。考虑到dp[j]为其中一个子集所能抵达的最大重量，则另外一个子集的重量为总重量减去子集1的重量，要得到最后一块石头的重量，为两个子集和的相减值，最后的结果可以表示为sum -= 2*dp[j]。

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        // 创建一个长度为1501，全0的数组dp，用于动态规划
        // dp[j]表示能够达到的总重量为j的石头的最大重量
        vector<int> dp(1501, 0);
        int sum = 0;
        // 计算stones数组中所有石头的总重量
        for (auto x : stones) {
            sum += x;
        }
        // 计算目标和，即分割后两堆石头的总重量应该接近sum/2
        const int target = sum / 2;
        for (int i = 0; i < stones.size(); i++) {
            // 从大到小遍历目标和及其以下的值
            for (int j = target; j >= stones[i]; j--) {
                // 更新dp[j]，选取当前石头和不选取当前石头，取两种情况的最大值
                dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        // 最终结果为sum - dp[target]的两倍，因为dp[target]是接近sum/2的最大重量
        // 所以sum - dp[target]是另一堆石头的重量，两堆石头碰撞后剩下的最小重量就是它们的差
        return sum - 2 * dp[target];
    }
};

算法的时间复杂度为O(n^2)，空间复杂度为O(n)。

目标和

494. 目标和 - 力扣（LeetCode）

动态规划之背包问题，装满背包有多少种方法？| LeetCode：494.目标和_哔哩哔哩_bilibili

得到目标和，需要在数字前面添加加号和减号，即存在两个数组我们假定为left数组和right数组，left数组中元素前全为加号，right数组中元素前全为减号。目标和为target，元素的所有和为sum。

sum_left + sum_right = target;

sum_left - sum_right = sum;

sum_left = (target + sum)/2，即我们能够得到left数组的和为target和元素和sum的一半。

使用动态规划算法来解决这个问题。

此时的dp[j]表示的是要装满容量为j的背包共有dp[j]种方式。

dp[j]：装满容量为j的背包有dp[j]种方式。

dp[j]的推导公式，这里需要牢记 dp[j]表示的是装满容量为j的背包的所有方式数量，所以dp[j]与dp[j-nums[j]]相关。即总容量为5，我们有一个质量为1的物品，则应该有dp[4]种方法能够得到5（1+4 = 5），若我们有一个质量为2的物品，应该有dp[3]种方法能够得到5（2+3 = 5 考虑之前的爬楼梯的题目），依次向下推，则dp[5] = dp[4] + dp[3] + dp[2] + dp[1] + dp[0]。

dp[j] += dp[j-nums[i]]，此处为累加

dp[0]本应为0,但这里若初始为0，则所有dp均为0，所以初始化为1，非0下标初始化为0。

遍历顺序物品遍历在外，背包遍历在内层，且内层倒序遍历。

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        // 计算数组nums中所有数字的和
        for (auto x : nums) {
            sum += x;
        }
        // 如果(target + sum)是奇数，那么不可能通过添加+或-得到target，因为每添加一个-，总和就会减少两倍
        if ((target + sum) % 2 == 1) {
            return 0;
        }
        // 如果target的绝对值大于sum，那么也不可能得到target,leetcode有反例[100] target -200
        if (abs(target) > sum) {
            return 0;
        }
        // 计算我们需要的正数总和left
        const int left = (sum + target) / 2;
        // 初始化动态规划数组dp，大小为left+1，初值都为0，dp[j]表示总和为j的方法数
        vector<int> dp(left + 1, 0);
        // 总和为0的方法只有1种，即不选择任何数字
        dp[0] = 1;
        // 遍历数组nums中的每个数字
        for (int i = 0; i < nums.size(); i++) {
            // 从大到小遍历left及其以下的值
            for (int j = left; j >= nums[i]; j--) {
                // 更新dp[j]，考虑选择当前数字和不选择当前数字的情况
                dp[j] += dp[j - nums[i]];
            }
        }
        // 返回总和为left的方法数，即dp[left]
        return dp[left];
    }
};

算法的时间复杂度为O(n^2)，空间复杂度为O(n)。

一和零

474. 一和零 - 力扣（LeetCode）

本题还是一个01背包问题，虽然有两个维度。具体参考如下网站

代码随想录 (programmercarl.com)

动态规划之背包问题，装满这个背包最多用多少个物品？| LeetCode：474.一和零_哔哩哔哩_bilibili

我们需要装满m个0，n个1的背包，共2个维度，需要一个二维的dp数组，背包中最多有多少个物品，dp[i][j]即表示最多背的物品个数，即最后返回值为dp[m][n]。

dp[i][j] = max(dp[i][j-1],dp[i][j]) x和y分别表示物品i中有x个0，y个1，此处max中的dp[i][j]参考之前背包问题的滚动数组，做了压缩。

对dp数组进行初始化，dp[0][0] = 0，其余值也全赋值为0。同样参考之前背包问题的滚动数组，dp[i][j]的值在每次遍历过程中会被覆盖。

遍历顺序，先遍历物品，再遍历背包，且背包要倒序遍历。

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        // 初始化动态规划数组dp，大小为(m+1) x (n+1)，初值都为0
        // dp[i][j]表示最多能组成多少个只包含0和1的字符串，且0的数量不超过i，1的数量不超过j
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));

        // 遍历数组strs中的每个字符串
        for (string str : strs) {
            int zero_count = 0; // 记录当前字符串中0的数量
            int one_count = 0;  // 记录当前字符串中1的数量
            // 遍历当前字符串中的每个字符
            for (auto c : str) {
                if (c == '0') {
                    zero_count++;
                } else {
                    one_count++;
                }
            }
            // 从大到小遍历m和n，更新dp数组
            for (int i = m; i >= zero_count; i--) {
                for (int j = n; j >= one_count; j--) {
                    // 更新dp[i][j]，考虑选择当前字符串和不选择当前字符串的情况
                    dp[i][j] = max(dp[i - zero_count][j - one_count] + 1, dp[i][j]);
                }
            }
        }
        // 返回最多能组成只包含0和1的字符串的数量，即dp[m][n]
        return dp[m][n];
    }
};

算法的时间复杂度为O(m*n*k)，k为strs的长度，外层遍历str数组中的每个字符串，共有strs.size()次迭代，k为strs数组的总长度，为strs.size()*每个数组中元素的平均长度L。

空间复杂度考虑需要维护一个二维dp数组，为O(m*n)。