LeetCode | C++ 动态规划——1049. 最后一块石头的重量 II、494. 目标和、474.一和零

52 篇文章 0 订阅

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

1049题目链接
本题其实就是尽量让石头分成重量相同的两堆,相撞之后剩下的石头最小,这样就化解成01背包问题了

这样,整体来说和416.分割等和子集 差不多

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = 0, target;
        for (const int& i : stones) {
            sum += i;
        }
        target = sum / 2;
        vector<int> dp(target + 1, 0);
        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]);
            }
        }

        int result;
        result = (sum - dp[target]) - dp[target];
        return result;
    }
};

494. 目标和

494题目链接
转化思路: 本题要求表达式结果为 target, 每一个数 要么为 + 要么为 -

正的之和 - 负的之和 = target, 设 正的之和 为 A, 所有数都为正的总和 为 sum, 那么负的之和 为 sum - A, 可得关系式: A - (sum - A) = target;

A = (sum + target) / 2;

此时问题转化为 在集合nums 里面 找出 和 为 A 的组合。

如果 (sum + target) / 2 不能整除, 或者 target > sum , 此时没有解决方案。

可以通过 回溯算法,在集合里面 求目标和, 不过会超时。

动态规划:此时转化为 装满容量为 A 的背包,有几种方法。

二维数组理解:

dp[i] [j]: 从下标为[0…i]的物品里任取,填满j这么⼤容积的包,有dp[i] [j]种⽅法

递推公式:dp[i] [j] = dp[i - 1] [j] + dp[i - 1] [j - nums[i]]

dp[i - 1] [j]是不将物品i放入背包的方式数,dp[i - 1] [j - nums[i]]是将物品i放入背包的方式数

dp初始化: dp[0] [0] = 1 表示装满容量为0的背包,有1种⽅法,就是装0件物品。

如果nums[0]在范围内的话,dp[0] [nums[0]] = 1,其他全为0

用二维的话要注意背包为0时的初始化,数组里有0的情况是可以正也可以负,每一个0都有2种状态,需要统计从0第0个到第i个物品时有多少个0,记为n那么dp[i] [0]就等于2的n次方

对于 dp[0] [j] 的初始化

​ 若 nums[0] = 0, 则, dp[0] [nums[0]] = 2;

​ 若 nums[0] != 0, 则, dp[0] [nums[0]] = 1;

对于 dp[i] [0] 的初始化

​ 1. 当 nums[i] 从 0 - i nums[i] 都不为0, 则 dp[i] [0] = 0;

​ 2. 当 nums[i] 从 0 - i 中,有 0 时, 则为 2的n 次方,(n 为 0 的个数)

​ 对于 第二种情况,从递推公式可以看出,当nums[i] = 0, 用不到dp[i] [0], 只是dp[i - 1] [j]的 2 倍

遍历顺序: 先物品,在背包,这样就省得 给 最左一列进行初始化了。

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for (const int& i : nums) sum += i;
        if (abs(target) > sum) return 0;
        
        if ((target + sum) % 2 != 0) return 0;
        int A = (target + sum) / 2;

        vector<vector<int>> dp(nums.size(), vector<int>(A + 1, 0));

        dp[0][0] = 1; 
        // 对于 dp[0][j] 的初始化
        // 若 nums[0] = 0, 则, dp[0][nums[0]] = 2;
        // 若 nums[0] != 0, 则, dp[0][nums[0]] = 1;
        if (nums[0] < dp[0].size()) {
            dp[0][nums[0]] = 1; // 注意这里是 刚好填满
            if (nums[0] == 0) dp[0][nums[0]] = 2;
        }
        // 对于 dp[i][0] 的初始化
        // 1. 当 nums[i] 从 0 - i nums[i] 都不为0, 则 dp[i][0] = 0;
        // 2. 当 nums[i] 从 0 - i 中,有 0 时, 则为 2的n 次方,(n 为 0 的个数)
        // 对于 第二种情况,从递推公式可以看出,当nums[i] = 0, 用不到dp[i][0], 只是dp[i - 1][j]的 2 倍
        for (int i = 1; i < nums.size(); i++) {
            for (int j = 0; j <= A; j++) {
                if (j < nums[i]) dp[i][j] = dp[i - 1][j];
                else {
                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];
                }
            }
        }
        return dp[nums.size() - 1][A];
    }
};

一维数组理解:

dp[j]:

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

递推公式:

dp[j] += dp[j - nums[i]];

dp[j]方法等于 不用 i 物品方法数 + 用 i 物品方法数

对nums[i]来说,分拿或者是不拿,把不拿nums[i] 和 拿 nums[i] 的情况加在一起就好了。

dp[j] = dp[j] + dp[j - nums[i]] 递推公式详细解释:

如果我们要用若干个元素组成和为 j 的方案数,那么有两种选择:不选第 i 个元素或者选第 i 个元素。如果不选第 i 个元素,那么原来已经有多少种方案数就不变;如果选第 i 个元素,那么剩下要组成和为 j - nums[i] 的方案数就等于 dp[j - nums[i]]。所以两种选择相加就是dp[j]。

dp 初始化

dp[0] = 1, 如果赋值为 0 的话,后面累加都为0,因为dp[0]是在公式中一切递推结果的起源

如果数组[0] ,target = 0,那么 bagSize = (target + sum) / 2 = 0。 dp[0]也应该是1, 也就是说给数组里的元素 0 前面无论放加法还是减法,都是 1 种方法。

非零下标都初始化为0,这个由递推公式可以看出,dp[j]要保证是0的初始值,才能正确的由dp[j - nums[i]]推导出来。

遍历顺序:

01背包 一维dp 先物品 再 背包容量,背包容量倒序遍历。

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for (const int& i : nums) sum += i;
        if (abs(target) > sum) return 0;
        
        if ((target + sum) % 2 != 0) return 0;
        int A = (target + sum) / 2;
        
        vector<int> dp(A + 1, 0);
        dp[0] = 1;

        for (int i = 0; i < nums.size(); i++) {
            for (int j = A; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[A];
    }
};

474.一和零

474题目链接
dp[i] [j]: 最多有i个0和j个1的strs的最大子集的大小为dp[i] [j]。

递推公式:

dp[i] [j] = max(dp[i] [j], dp[i - zeroNum] [j - oneNum] + 1);

dp[i] [j] 可以由前一个strs里的字符串推导出来,strs里的字符串有zeroNum个0,oneNum个1。

dp 初始化

因为字符串的个数不会是负数,初始为0,保证递推的时候dp[i] [j]不会被初始值覆盖

遍历顺序:

01背包一维dp 顺序

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for (int i = 0; i < strs.size(); i++) {
            int zeroNum = calZeroNum(strs[i]);
            int oneNum = strs[i].size() - zeroNum;
            for (int j = m; j >= zeroNum; j--) {
                for (int k = n; k >= oneNum; k--) {
                    dp[j][k] = max(dp[j][k], dp[j - zeroNum][k - oneNum] + 1);
                }
            }
        }
        return dp[m][n];
    }
    int calZeroNum(string& s) {
        int zeroNum = 0;
        for (char& c : s) {
            if (c == '0') {
                zeroNum++;
            }
        }
        return zeroNum;
    }
};
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值