【LeetCode专题】动态规划-1

已于 2023-04-17 10:48:54 修改
阅读量163 收藏
点赞数
文章标签： leetcode 动态规划 算法
于 2023-04-03 21:03:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41084649/article/details/129937395
版权

本专题为动态规划算法的应用

目录

0-1背包问题

0-1背包问题模板详情可见我的个人总结【动态规划专题】

1. 状态定义
0-1背包问题的二维状态定义**

  • f[i][j] : 只选前i个物品, 总体积 <= j 的 Max

2. 状态分析

(1) 当前背包容量不够时（j < v[i]），选不了第 i 个物品，因此前i个物品的最优解和前 i - 1一样

  • f[i][j] = f[i - 1][j]

(2) 当前背包容量够第 i 个时（j ≥ v[i]），可选第 i 个物品，因此需要继续决策 选 or 不选 第i个物品

  • 选：f[i][j] = f[i - 1][j - v[i] + w[i]
  • 不选：f[i][j] = f[i - 1][j]
  • 最后取Max

3. 状态转移方程：
f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i]
4. 优化 ：0-1背包问题的一维状态

  • 在分析二维状态时，第i轮的状态只和第i - 1轮有关，因此可以去掉数组第一维
  • [注] : 每轮遍历 j 的过程中, i 是不变的(都是第 i 轮的状态),
    但是当前第i轮的状态需要第 i - 1轮的状态, 所以需要逆序枚举

一些题目需要转为0-1背包问题去求解

LeetCode 494. 目标和

题目 示例：

输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3

思路
题意要添加正/负号，使得数组和为target，所以设所有正数的和为s，数组所有数的和为sum_n，则所有负数的和为sum_n-s
现在需要求出s - (sum_s -s) = target的所有方案数
只需求出 s = (sum_n + t)/2的所有方案数
记s = (sum_n + t)/2为新的target
-----> 问题转换为从nums中选择一些数字, 使这些数字的和 s = target 所有的方案数（0-1背包问题）
其中num[i]表示物品的重量，target表示背包的容量

代码

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) { 
        // +的和 : s 
        // -的和 : sum_n - s
        // s - (sum_n-s) = t
        // 2s - sum_n = t
        // s = (sum_n + t) / 2
        // <==> 问题转换为从nums中选择一些数字, 使这些数字的和 = (sum_n + t)/2, 所有的方案数
        target += accumulate(nums.begin(), nums.end(), 0);
        if (target < 0 || target % 2) return 0;
        target /= 2;
        int n = nums.size();
        int f[n+1][target+1];
        // f[i][j] 代表考虑前 i 个数，当前计算结果为 j 的方案数
        // f[0][0] 代表不考虑任何数，凑出计算结果为0的方案数为1种
        memset(f, 0, sizeof(f));
        f[0][0] = 1;
        for(int i = 0; i < n; i++){
            for(int c = 0; c <= target; c++) {
                if(c < nums[i]) f[i+1][c] = f[i][c]; // 不够选
                else f[i+1][c] = f[i][c] + f[i][c-nums[i]]; // 不选 + 选
            }
        }
        return f[n][target];
    }
};

空间优化方案一：一维DP数组+逆序枚举

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) { 
        target += accumulate(nums.begin(), nums.end(), 0);
        if (target < 0 || target % 2) return 0;
        target /= 2;
        int n = nums.size();
        int f[target+1];
        memset(f, 0, sizeof(f));
        f[0] = 1;
        for(int i = 0; i < n; i++){
            for(int c = target; c >= 0; c--) {
                if(c >= nums[i]) f[c] = f[c] + f[c-nums[i]]; // 不选 + 选
            }
        }
        return f[target];
    }
};

空间优化方案二：利用求mod,滚动数组

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        target += accumulate(nums.begin(), nums.end(), 0);
        if (target < 0 || target % 2) return 0;
        target /= 2;
        int n = nums.size();
        int f[2][target+1];
        // 空间优化方法二：只用2个滚动数组，进行状态转换
        memset(f, 0, sizeof(f));
        f[0][0] = 1;
        for(int i = 0; i < n; i++){
            for(int c = 0; c <= target; c++) {
                if(c < nums[i]) f[(i+1)%2][c] = f[i%2][c]; // 不够选
                else f[(i+1)%2][c] = f[i%2][c] + f[i%2][c-nums[i]]; // 不选 + 选
            }
        }
        return f[n%2][target];
    }
};

LeetCode 416. 分割等和子集

题目 示例：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

思路
从nums中选一些数，使得这些数的总和sum = target(target = sum_n / 2)
问题转换为0-1背包问题
dp[i][j]表示从前i个数中选，是否存在【所选数的总和s=j的方案】

  • 如果存在dp[i][j] = 1
  • 如果不存在dp[i][j] = 0

代码

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if(sum % 2 == 1) return false;
        int target = sum / 2, n = nums.size();
        bool dp[2][target + 1];
        memset(dp, 0, sizeof(dp));
        dp[0][0] = 1;
        for(int i = 0; i < n; i++){
            for(int j = 0; j <= target; j++){
                if(nums[i] > j) dp[(i+1)%2][j] = dp[i%2][j] > 0;
                else dp[(i+1)%2][j] = dp[i%2][j] + dp[i%2][j-nums[i]] > 0;
            }
        }
        // cout << dp[n][target];
        return dp[n%2][target];
    }
};

空间优化：方法同上题，此处略

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

题目 示例：
在这里插入图片描述

输入：stones = [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]，这就是最优值。

思路
从stones中选两组数，记第一组数的总和为sum1，第二组总和为sum2
要使得最后剩下的一块石头【重量最小】，则需要使得 | sum1 - sum2 |最小

因此需要从stones中选一些数，使得这些数总和sum在不超过sum_n / 2时，得到的sum最大
问题转换为0-1背包问题
dp[i][j]表示从前i个数中选，所选数的总和s<=j的最大总和s
背包容量为sum_n / 2, 物品价值为sum

代码

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int n = stones.size();
        int sum = accumulate(stones.begin(), stones.end(), 0);
        int target = sum / 2;
        int dp[n+1][target+1]; // 从前n个数中选, 体积不超过sum的最大value(此题value=sum)
        memset(dp, 0, sizeof(dp));
        for(int i = 0; i < n; i++){
            for(int j = 0; j <= target; j++){
                if(stones[i] > j) dp[i+1][j] = dp[i][j]; // 体积超过 不选
                else{
                    dp[i+1][j] = max(dp[i][j], dp[i][j-stones[i]] + stones[i]);
                }
            }
        }
        // cout << dp[n][target];
        return sum - 2 * dp[n][target];
    }
};

完全背包问题

完全背包问题模板详情可见我的个人总结【动态规划专题】

图源灵神：
在这里插入图片描述

状态转移方程
f[i][j] = max(f[i - 1][j], f[i][j - v] + w)
与01背包状态方程的区别在于：第i个物品可以重复选

LeetCode 322. 零钱兑换

题目 示例：

输入：coins = [1, 2, 5], amount = 11
输出：3
解释：11 = 5 + 5 + 1
【注意】ans为最少的硬币个数

代码：

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        int n = coins.size();
        int dp[n+1][amount+1];
        memset(dp, 0x3f, sizeof(dp));
        dp[0][0] = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0; j <= amount; j++){
                if(coins[i] > j){ // 选不了
                    dp[i+1][j] = dp[i][j];
                }else{
                    // 物品价值看作1
                    // dp[i+1][j]表示从前i个物品中选, 总金额不超过amount的最少硬币数量
                    dp[i+1][j] = min(dp[i][j], dp[i+1][j-coins[i]] +1);
                }
            }
        }
        if(dp[n][amount] < 0x3f3f) return dp[n][amount];
        return -1;
    }
};

空间优化1

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        int n = coins.size();
        int dp[2][amount+1];
        memset(dp, 0x3f, sizeof(dp));
        dp[0][0] = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0; j <= amount; j++){
                if(coins[i] > j){ // 选不了
                    dp[(i+1)%2][j] = dp[i%2][j];
                }else{
                    // 物品价值看作1
                    // dp[i+1][j]表示从前i个物品中选, 总金额不超过amount的最少硬币数量
                    dp[(i+1)%2][j] = min(dp[i%2][j], dp[(i+1)%2][j-coins[i]] +1);
                }
            }
        }
        if(dp[n%2][amount] < 0x3f3f) return dp[n%2][amount];
        return -1;
    }
};

空间优化2

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        int n = coins.size();
        int dp[amount+1];
        memset(dp, 0x3f, sizeof(dp));
        dp[0] = 0;
        for(int i = 0; i < n; i++){
            for(int j = coins[i]; j <= amount; j++){
                // 物品价值看作1
                // dp[i+1][j]表示从前i个物品中选, 总金额不超过amount的最少硬币数量
                dp[j] = min(dp[j], dp[j-coins[i]] +1);
                
            }
        }
        if(dp[amount] < 0x3f3f) return dp[amount];
        return -1;
    }
};

LeetCode 518. 零钱兑换 II

题目 示例：

输入：amount = 5, coins = [1, 2, 5]
输出：4
解释：有四种方式可以凑成总金额：
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1
【注意】ans为选择的方案数cnt

代码

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int n = coins.size();
        int dp[n+1][amount+1]; // 从前i个物品中选, 金额=amount 的 数量
        memset(dp, 0, sizeof(dp));
        dp[0][0] = 1; // 从前0个选amount = 0数量定义为1
        for(int i = 0; i < n; i++){
            for(int j = 0; j <= amount; j++){
                if(coins[i] > j) dp[i+1][j] = dp[i][j]; // 不够选
                else dp[i+1][j] = dp[i][j] + dp[i+1][j - coins[i]];  // 不选第i个物品 + 选第i个物品
            }
        }
        return dp[n][amount];
    }
};

空间优化

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int n = coins.size();
        int dp[amount+1]; // 从前i个物品中选, 金额=amount 的 数量
        memset(dp, 0, sizeof(dp));
        dp[0] = 1; // 从前0个选amount = 0数量定义为1
        for(int i = 0; i < n; i++){
            for(int j = coins[i]; j <= amount; j++){
                dp[j] = dp[j] + dp[j - coins[i]];  // 不选第i个物品 + 选第i个物品
            }
        }
        return dp[amount];
    }
};
TBD1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
leetcode答案-leetcode-tencent:leetcode面试-腾讯专题做题记录
06-30
leetcode面试-腾讯专题做题记录 LeetCode腾讯专题地址， 小目标 每天至少一道算法题 每天更新README学习markdown写法(不会真的有人不会markdown吧，不会吧，不会吧) 先这样，有什么想到的再说 1月20日 正式开始，...
leetcode下载-Leetcode-AZL:Leetcode-AZL
06-29
:bouquet::bouquet::bouquet::bouquet::bouquet:，有专题讲解，每日一题，下载区和视频题解，后续会增加更多内容，还不赶紧收藏起来？地址： 项目预览 可以清晰地看出仓库组织关系。 （你可以下载本仓库 和 obsidian...
leetcode二叉树专题---C++实现
Eccentric_Lee的博客
04-14 1268
二叉树的常见操作222. 完全二叉树的节点个数110. 平衡二叉树257. 二叉树的所有路径 222. 完全二叉树的节点个数 222. 完全二叉树的节点个数 给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。 完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。 示例 1： 输入：root = [1,2,3,4,5,6] 输出：6 示例 2：
leetcode之动态规划
weixin_47414034的博客
06-23 1788
以爬楼梯问题为例，总结动态规划的步骤：第一步：定义dp数组（可能时一维数组，也可能是二维数组），这一步需要确定两个问题：（1）dp[i]或者dp[i][j]是什么含义（比如在爬楼梯问题中，dp[i]表示到达第i层有多少种爬法）（2）到底开多大的空间，你搞懂了第一个问题dp[i]或者dp[i][j]是什么含义，就知道到底要开多大的空间了，由于在爬楼梯问题中，dp[i]表示到达第i层有多少种爬法，你最后求的是到达第n层所需要的爬法数，所以最后要返回的是dp[n]，所以显然要开n+1大小的数组，这样才能有dp[n
LeetCode - 动态规划专题
Mochadrone的博客
09-26 175
剑指 Offer 14- I. 剪绳子 思路 考虑多种解法 Memoization. 记忆化。也叫从顶到底的算法。将一个列表初始化成0（或者-1在某些题中），如果不是初始化的值就直接读取，如果是的话就迭代的找符合要求的值存入。很好理解。时间复杂度O(2N)O(2^N)O(2N)，空间复杂度O(N)O(N)O(N) DP，从底向顶。根据初始值，和剪下来j后不剪，和剪下来j后继续剪三种情况取最大来从底到顶地写入。时间复杂度O(N2)O(N^2)O(N2), 空间复杂度O(N)O(N)O(N) DP优化解法。用
【Leetcode 专题六】动态规划专题
qq_38253797的博客
03-21 648
目录一、一般问题系列1.1、题目汇总leetcode 509. 斐波那契数leetcode 70. 爬楼梯leetcode 343. 整数拆分leetcode 343. 整数拆分剑指 Offer 62. 圆圈中最后剩下的数字（约瑟夫环问题 难 地推公式没懂）二、背包系列三、打家劫舍系列四、股票问题系列五、子序列问题系列六、路径规划系列 动态规划的核心就是最优化问题。核心是穷举。 判断可不可以用动态规划：当前的状态取决于前一个时刻的状态。 动态规划的特点： 1、重叠子问题 2、状态转移方程 3、最优子结构
LeetCode专题----递归
changetocs的博客
12-24 929
1、111. Minimum Depth of Binary Tree Given a binary tree, find its minimum depth.The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node. 分析：在
Leetcode动态规划专题（共38道）
weixin_45627369的博客
04-10 5911
某一问题有很多重叠子问题 每一状态一定由上一状态推导出来 而贪心没有状态推导，而是直接选局部最优 解决方式： 确定dp数组（dp table）以及下标的含义 确定递推公式 dp数组如何初始化 确定遍历顺序 举例推导dp数组 模拟：举例推导dp数组 检查：打印dp数组 1.Leetcode509. 斐波那契数 class Solution { public: int fib(int n) { //第i个数的值 vector<int>n
LeetCode专题----DFS
changetocs的博客
03-21 554
207. Course ScheduleThere are a total of n courses you have to take, labeled from 0 to n - 1.Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is
Leetcode动态规划题解2——线性dp
qq_41214610的博客
01-31 384
Leetcode动态规划题解2——线性dp
LeetCode动态规划专题：第五天
释然的成长之路
08-25 95
最大子序和 动态规划法 class Solution { public: int maxSubArray(vector<int>& nums) { int maxn = nums[0], n = nums.size(), pre = nums[0]; for (int i = 1; i < nums.size(); i ++ ) { int cur = max(pre + nums[i], nums[i
leetcode题库-LeetCode-Topic:LeetCode专题刷题模板分类Java版讲解
06-29
leetcode题库 LeetCode 专题 介绍 本仓库用来记录初学者能够理解的各类算法题的模板、思路，并汇总yxc老师推荐的相应习题以及其他的...5动态规划专题 6字符串处理专题 7搜索_DFS_BFS专题 8滑动窗口_双指针_单调队列 9
leetcode答案-LeetCode-String:LeetCode-字符串
06-30
leetcode 答案 LeetCode-String #这是LeetCode里面String专题中的python版答案
leetcode叫数-lf-leetcode:leetcode专题
06-30
leetcode专题 参考博客： github： 1.术语说明 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面； 内排序：所有排序操作都在内存中完成...
代码随想录训练营Day56：Leetcode647、516
maybeyaluokenai的博客
05-31 167
Leetcode647、516
159.二叉树：二叉树的层平均值（力扣）
weixin_63779802的博客
05-31 330
代码同样使用了广度优先搜索（BFS）的方法。主要思路是使用一个队列来进行层次遍历，在每一层遍历的时候，计算所有节点的值的总和以及节点的数量，然后用总和除以节点数量得到平均值。这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储整个树的节点。代码是解决“二叉树的层平均值”问题的C++代码，这个问题要求计算二叉树中每一层的节点值的平均值，并返回一个包含这些平均值的列表。
两数之和-力扣
why_12134的博客
05-28 285
另一种方法是使用哈希表来实现，使用一个map记录每个元素出现的下标，这样遍历到一个元素，只需向map查询是否存在 target - nums[i] 是否存在即可，从而减少了一个for循环，打打降低了时间复杂度。
LeetCode 2965.找出缺失和重复的数字：小数据？我选择暴力（附优化方法清单：O(1)空间方法×3）
最新发布
<font color="Pink">Tisfy的博客</font>
05-31 1041
【LetMeFly】2965.找出缺失和重复的数字：小数据？我选择暴力（附优化方法清单：O(1)空间方法×3） 给你一个下标从 0 开始的二维整数矩阵 grid，大小为 n * n ，其中的值在 [1, n2] 范围内。除了 a 出现 两次，b 缺失 之外，每个整数都 恰好出现一次 。 任务是找出重复的数字a 和缺失的数字 b 。 返回一个下标从 0 开始、长度为 2 的整数数组 ans ，其中 ans[0] 等于 a ，ans[1] 等于 b 。
最长公共子序列c++代码_leetcode(动态规划)-1143. 最长公共子序列
06-06
好的，以下是最长公共子序列的C++代码（使用动态规划）： ```cpp class Solution { public: int longestCommonSubsequence(string text1, string text2) { int m = text1.size(), n = text2.size(); vector...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值