代码随想录算法训练营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]。

cpp 复制代码
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。

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

cpp 复制代码
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]的值在每次遍历过程中会被覆盖。

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

cpp 复制代码
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)。

相关推荐
小沈熬夜秃头中୧⍤⃝13 分钟前
【贪心算法】No.1---贪心算法(1)
算法·贪心算法
木向1 小时前
leetcode92:反转链表||
数据结构·c++·算法·leetcode·链表
阿阿越1 小时前
算法每日练 -- 双指针篇(持续更新中)
数据结构·c++·算法
skaiuijing1 小时前
Sparrow系列拓展篇:对调度层进行抽象并引入IPC机制信号量
c语言·算法·操作系统·调度算法·操作系统内核
Star Patrick1 小时前
算法训练(leetcode)二刷第十九天 | *39. 组合总和、*40. 组合总和 II、*131. 分割回文串
python·算法·leetcode
武子康2 小时前
大数据-214 数据挖掘 机器学习理论 - KMeans Python 实现 算法验证 sklearn n_clusters labels
大数据·人工智能·python·深度学习·算法·机器学习·数据挖掘
pianmian17 小时前
python数据结构基础(7)
数据结构·算法
好奇龙猫10 小时前
【学习AI-相关路程-mnist手写数字分类-win-硬件:windows-自我学习AI-实验步骤-全连接神经网络(BPnetwork)-操作流程(3) 】
人工智能·算法
sp_fyf_202410 小时前
计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-11-01
人工智能·深度学习·神经网络·算法·机器学习·语言模型·数据挖掘
香菜大丸10 小时前
链表的归并排序
数据结构·算法·链表