动态规划（八） 练习题

已于 2023-07-21 22:47:24 修改
阅读量61 收藏
点赞数
分类专栏： leetcode(c++) 文章标签： 动态规划 算法 C++
于 2023-07-21 22:47:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jmqxnxg/article/details/131692174
版权

1.练习题

1）

力扣https://leetcode.cn/problems/house-robber-ii/解答：

这道题的重点是第一个屋子和最后的一个屋子不能一起偷。

所以可以把屋子分成两组，一组是从第一个屋子到倒数第二个屋子，另一组是从第二个屋子到最后屋子。

针对每组：

dp[i][0]表示不偷第i个屋子时的最大收益，那前一个屋子就是可偷可不偷，取二者中的最大值

dp[i][0] = max(dp[i-1][0], dp[i-1][1])

dp[i][1]表示偷第i个屋子时的最大收益，所以前一个屋子不能偷

dp[i][1] = dp[i-1][1] + nums[i-1]

代码：

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if(n==0) return 0;
        if(n==1) return nums[0];

        vector<vector<int>> dp(n+1,vector<int>(2,0));
        
        for(int i=2;i<n+1;i++){
            dp[i][0] = max(dp[i-1][0], dp[i-1][1]);
            dp[i][1] = dp[i-1][0] + nums[i-1];
        }
        int res = max(dp[n][0], dp[n][1]);


        for(int i=1;i<n;i++){
            dp[i][0] = max(dp[i-1][0], dp[i-1][1]);
            dp[i][1] = dp[i-1][0] + nums[i-1];
        }
        int res2 = max(dp[n-1][0], dp[n-1][1]);

        return max(res, res2);

    }
};

2）

力扣icon-default.png?t=N6B9https://leetcode.cn/problems/maximum-subarray/

这题是典型的DP，针对每个元素，考虑是与前面的元素组成连续子数组，或者是放弃前面的元素，当前元素作为连续子数组的开头元素。判断依据就是哪种情况下连续子数组的和更大。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n+1,INT_MIN/2);
        for(int i=1;i<=n;i++){
            dp[i] = max(dp[i-1]+nums[i-1], nums[i-1]);
           
        }
        return *max_element(dp.begin(), dp.end());
    }
};

可以看到dp[i]只与dp[i-1]相关，所以可以把一维数组压缩成常量。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        int pre = 0, cur, res = nums[0];
        for(int i=1;i<=n;i++){
            cur = max(pre+nums[i-1], nums[i-1]);
            pre = cur;
            res = max(res, cur);
        }
        return res;
    }
};

结果：

 

3）

力扣icon-default.png?t=N6B9https://leetcode.cn/problems/integer-break/看到这道题首先的思路是dp[i]代表i拆分后的最大乘积，所以可以遍历和为n的所有两个数的组合：

  • 若拆分成两个数：dp[i]=max(dp[i],j*(i-j))
  • 若拆分成两个以上的数：dp[i]=max(dp[i],j*dp[i-j])

这里的dp[i-j]代表i-j这个数再拆分后的最大乘积。

这时候，直觉地会有一个写法dp[i]=max(dp[i],dp[j]*(i-j))，这其实是和第二种情况重复了，i和i-j本质上是等价的。

还有另一个写法dp[i]=max(dp[i],dp[j]*dp[i-j])，我感觉这可以算是第三种情况，就是j和(i-j)都取拆分。但看最后结果，加不加这种情况，不会影响最终结果。大概是因为当把数字拆的过于小了之后，得到的自然不会是最大乘积了。

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n+1,0);
        dp[1] = 1;
        for(int i=2;i<=n;i++){
            for(int j=1;j<i;j++){
                dp[i]=max(dp[i],j*(i-j));
                dp[i]=max(dp[i], j*dp[i-j]);
            }
        }
        return dp[n];
    }
};

 

4)

力扣icon-default.png?t=N6B9https://leetcode.cn/problems/delete-operation-for-two-strings/

这题比之前做的那道字符串编辑的题简单一些，因为这道题只考虑删除。

那么转移方程就很简单了，如果匹配，那最小步数等于前一个字符的情况。

如果不匹配：要么删除字符串1的当前字符，要么删除字符串2的当前字符，要么都删除。

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m = word1.size(), n = word2.size();

        vector<vector<int>> dp(m+1,vector<int>(n+1,0));
        for(int i=0;i<=n;i++){
            dp[0][i]=i;
        }
        for(int i=0;i<=m;i++){
            dp[i][0]=i;
        }
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(word1[i-1]==word2[j-1]){
                    dp[i][j] = dp[i-1][j-1];
                }else{
                    dp[i][j] = min(dp[i-1][j]+1, min(dp[i][j-1]+1, dp[i-1][j-1]+2));
                }
            }
        }
        return dp[m][n];
    }
};

5）

力扣icon-default.png?t=N6B9https://leetcode.cn/problems/maximum-length-of-pair-chain/这题最初，我是这么想的，一个二维数组，每一行表示以该数对结尾的数对链（表示之前的数对都已考虑过，可以不取某个数对），每一列表示要新增的数对。

然后二维数组遍历，来判断合法的数对链。

于是我写出了这一段代码：

class Solution {
public:
    int findLongestChain(vector<vector<int>>& pairs) {
        if(pairs.size()==0 || pairs[0].size()==0){
            return 0;
        }
   
        sort(pairs.begin(), pairs.end(),
        [](const vector<int>& a, const vector<int>& b){
            return a[1]<b[1];
        }
        );
      

        int n = pairs.size();
        vector<vector<int>> dp(n,vector<int>(n,1));
        int res = 1;

        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                    if(pairs[i][1]<pairs[j][0]){       
                        if(i==0){
                            dp[i][j] += 1;           
                        }else{
                            dp[i][j] = dp[i-1][i]+1;               
                        }
                    }
                    if(i!=0)
                        dp[i][j] = max(dp[i][j], dp[i-1][j]);
                    res = max(res, dp[i][j]);
                
            }
        }
       
      
        return res;

    }
};

写完之后，虽然通过了所有case，但很显然我是想复杂了。这个二维数组左下边的一半都是用不到的，每次转移方程也都是只用到上一次以i或者以j结尾的最长数对链。

所有很明显可以压缩成一维数组，每个元素表示以i结尾时的最长数对链：

class Solution {
public:
    int findLongestChain(vector<vector<int>>& pairs) {
        if(pairs.size()==0 || pairs[0].size()==0){
            return 0;
        }
   
        sort(pairs.begin(), pairs.end(),
        [](const vector<int>& a, const vector<int>& b){
            return a[1]<b[1];
        }
        );
      

        int n = pairs.size();
        vector<int> dp(n,1);
        int res = 1;

        for(int i=0;i<n;i++){
            for(int j=0;j<i;j++){         
                if(pairs[j][1]<pairs[i][0]){
                     dp[i] = max(dp[i], dp[j]+1);  
                     res = max(res, dp[i]);
                }
                   
            }
        }
       
      
        return res;

    }
};

6)

力扣icon-default.png?t=N6B9https://leetcode.cn/problems/wiggle-subsequence/解题思路：

首先如果相邻元素相等，那是肯定不满足要求的，所以删去重复的相邻元素。

接下来再处理，就不会出现差值为零的情况了，只会大于0或者小于0。

所以对连续的三个数的两个差值相乘，来判断是否是摆动的。

如果小于零，说明是摆动的，序列长度加一。否则序列长度不变。

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        vector<int> nums2;
        int n = nums.size();
        
        nums2.push_back(nums[0]);
        for(int i=1;i<n;i++){
            if(nums[i]!=nums[i-1]){
                nums2.push_back(nums[i]);
            }
        }

        n = nums2.size();
        if(n<3) return n;
        vector<int> dp(n,0);
        dp[0] = 1;
        dp[1] = 2;
        for(int i=2;i<n;i++){
            if((nums2[i]-nums2[i-1])*(nums2[i-1]-nums2[i-2])<0){
                dp[i] = dp[i-1] + 1;
            }else{
                dp[i] = dp[i-1];
            }
        }
        return dp[n-1];
    }
};

因为dp[i]只与dp[i-1]相关，所以可以用两个遍历代替一维数组

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        vector<int> nums2;
        int n = nums.size();
        
        nums2.push_back(nums[0]);
        for(int i=1;i<n;i++){
            if(nums[i]!=nums[i-1]){
                nums2.push_back(nums[i]);
            }
        }

        n = nums2.size();
        if(n<3) return n;
        vector<int> dp(n,0);
        int pre = 2, cur;
        for(int i=2;i<n;i++){
            if((nums2[i]-nums2[i-1])*(nums2[i-1]-nums2[i-2])<0){
                cur = pre + 1;
            }else{
                cur = pre;
            }
            pre = cur;
        }
        return cur;
    }
};

结果：

 

7）

力扣icon-default.png?t=N6B9https://leetcode.cn/problems/target-sum/解题思路：用一个二维数组来表示状态转移，横坐标i表示考虑数组[0...i]的组合，纵坐标j表示这些组合的和。

因为组合的和存在负数，所以要加上一个数组列数的偏移量

dp[i][j]表示数组[0...i]的组合和为j，所以等于数组组[0...i-1]的组合和为j-nums[i]，加上数组组[0...i-1]的组合和为j+nums[i]的和。当然前提是坐标要不越界。

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int n = nums.size();
        int len = max(target,-target);
        len = max(len,accumulate(nums.begin(), nums.end(),1));
        vector<vector<int>> dp(n,vector<int>(2*len+1,0));
        
        dp[0][nums[0]+len] += 1;
        dp[0][-nums[0]+len] += 1;
        
        for(int i=1;i<n;i++){
            for(int j=0;j<=2*len;j++){
                if((j-nums[i])>=0 && (j-nums[i])<=2*len)
                dp[i][j] += dp[i-1][j-nums[i]];
               if((j+nums[i])>=0 && (j+nums[i])<=2*len)
                dp[i][j] += dp[i-1][j+nums[i]];
            }
        }
       
        return dp[n-1][target+len];
    }
};

因为dp[i]只和dp[i-1]相关，所以压缩成一维数组，又因为遍历数组时，会覆盖掉后面的元素要用到的值，所以最后用两个一维数组来实现：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int n = nums.size();
        int len = max(target,-target);
        len = max(len,accumulate(nums.begin(), nums.end(),1));
        vector<int> pre(2*len+1,0);
        vector<int> cur(2*len+1,0);
        
        pre[nums[0]+len] += 1;
        pre[-nums[0]+len] += 1;
        
        for(int i=1;i<n;i++){
            for(int j=0;j<=2*len;j++){
                cur[j] = 0;
               if((j-nums[i])>=0 && (j-nums[i])<=2*len)
                cur[j] += pre[j-nums[i]];
               if((j+nums[i])>=0 && (j+nums[i])<=2*len)
                cur[j] += pre[j+nums[i]];
              
            }
         
           pre = cur;
        }
        
       
        return pre[target+len];
    }
};

8)

力扣icon-default.png?t=N6B9https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/解题思路：考虑手上有股票和没有股票的两种情况

有股票：之前购买的，和当前购买的，这两种情况的最大值

没有股票：直接手上就没有股票，和当前卖掉股票，这两种情况的最大值

转移方程：

dp1[i] = max(dp1[i-1], dp2[i-1]-prices[i]);

dp2[i] = max(dp2[i-1], dp1[i-1]+prices[i]-fee);

代码：

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        
        vector<int> dp1(n,0);
        vector<int> dp2(n,0);

        dp1[0] = -prices[0];
        for(int i=1;i<n;i++){
            dp1[i] = max(dp1[i-1], dp2[i-1]-prices[i]);
            dp2[i] = max(dp2[i-1], dp1[i-1]+prices[i]-fee);
        }

        return dp2[n-1];
    }
};

绿风天空
关注
专栏目录
动态规划题目练习
2301_80841939的博客
03-21 922
棋盘上 A 点有一个过河卒，需要走到目标 B 点。同时在棋盘上 C 点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。餐馆虽低端，但是菜品种类不少，有 N 种 ((N≤100)，第 i 种卖 ai​ 元 (ai​≤1000)。现在要求你计算出卒从 A 点能够到达 B 点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。棋盘用坐标表示，A 点 (0,0)、B 点 (n,m)，同样马的位置坐标是需要给出的。对于 100% 的数据，1≤n,m≤20，0≤马的坐标≤20。
【算法设计与分析】动态规划-练习题
lunaol的博客
12-02 1013
【算法设计与分析】动态规划练习题：1、最长递增子序列，2、骨牌铺棋盘，3、棋盘放石子。
动态规划相关高频笔试汇总
热门推荐
张彦峰的博客
04-20 1万+
动态规划基本理解分析以及应用举例，同时给出高频笔试考题解法分析和代码展示验证（最大子序和、最长上升子序列、最长公共子序列、最大子数组乘积、分割整数的最大乘积、最长有效括号、不同路径、最小路径和、最大矩形、0-1背包问题、编辑距离、单词拆分、爬楼梯、打家劫舍、强盗抢劫环形街区、股票买卖问题、最佳买卖股票时机含冷冻期、找零钱的最少硬币数、从起点到终点的最小路径数等）
【算法】动态规划题目总结
m0_51064412的博客
09-16 831
所以想求跳到第n级台阶有几种方法的话，我们只需知道跳到第 n-1、n-2 和 n-3 台阶时各自有几种方法，然后把它们相加起来即可。观察公式可以看到，如果要求第 i 个泰波那切数的话，我们只需知道前 i-1、i-2、i-3 的值即可。初始化：dp[n-1] = cost[n-1]、dp[n-2] = cost[n-2]状态表示：dp[i] 表示从i位置出发，到达楼顶，此时的最小花费。返回值：min(dp[0]， dp[1])PS：计算时需要注意取模。
最全动态规划题型详解
阿华的保温杯的博客
11-17 6440
通俗的讲动态规划（dp）的核心就是记住已经解决过子问题的解，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。dp常常适用于有重叠子问题和最优子结构性质的问题,动态规划方法所消耗的时间往往远小于朴素解法。
LeetCode练习八：动态规划下：背包问题
qq_56591814的博客
03-28 1466
文章目录一、背包问题简介二、 0-1 背包问题2.1 二维dp解法2.1.1 第一行表示第一个物品2.1.2 第一行表示0个物品2.2 一维dp解法2.2.1 使用两个一维数组2.2.2 使用一个一维数组2.3 0-1背包应用2.3.1 分割等和子集（最大背包价值）2.3.1.1 二维dp数组2.3.1.2 一维dp数组2.3.2 目标和（装满背包的方式）2.3.2.1 记忆化搜索2.3.2.2 二维dp数组2.3.2.3 一维数组2.3.3 最后一块石头的重量 II （最大背包价值）2.3.3.1 二
66.一维动态规划
Hanyaoo的博客
05-25 868
左神一维动态规划
动态规划入门详解 内含12道经典动态规划编程题
haocoming的博客
05-06 2155
动态规划入门详解 一 什么是动态规划？？ 算法导论中介绍，动态规划和分治方法类似，都是听过子问题的解来解决原问题。下面说一下这2者之间的分别，分治方法将原问题划分为互不相交的子问题，而后将子问题组合之后求出原问题的解，而动态规划是相反的，动态规划利用子问题之间的重叠，写出原问题和子问题之间的状态转移方程，转化为更小的子问题的求解，直到到达边界条件为止，有点类似于递归。 ①动态规划和分治的区别 分...
算法 动态规划
Pandaer杂货铺
10-09 1012
所谓总结就是做完一道题之后，思考一下这道题的特点，以及这道题的特点和哪个模型比较像。接下来我们来仔细看看具体的模型吧。
算法设计与分析 第8章动态规划法
m0_61993588的博客
10-31 463
算法设计与分析 第8章动态规划法
蓝桥杯练习题
06-06
- 动态规划：背包问题、最长公共子序列、最短路径问题等。 - 回溯法：八皇后问题、棋盘覆盖问题等。 - 分治策略：快速选择、大数乘法、归并排序等。 4. **字符串处理**： - KMP算法：快速查找子串在主串中的...
python面向对象练习题.pdf
09-04
这样的设计使得程序能够根据不同的对象类型动态地选择合适的行为，提高了代码的灵活性。 #### 二、类属性与对象属性的区别 **1. 类属性** 类属性是属于类本身的属性，所有该类的对象都共享同一份数据。它们通常...
保研考研机试攻略：第八章——动态规划（1）
qq_63349644的博客
08-22 911
保研考研机试攻略：第八章——动态规划（1）8.1递推求解+8.2最大子段和+8.3最长上升子序列（LIS）（这一章有点难）
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 2803
注意到位置为id，权值为v ,不合法的情况，当且仅当 v = id+k或 v= id-k。dp(i,j,pd)表示考虑到第i号点， 连了j条边，是否有连接i 到 i-1号点。因此，我们把每一个位置和权值抽象成点 ，不合法的情况之间连一条边，可以构成二分图。由此可知，当选了n条边，就恰好n个位置不合法，限制条件是：连的边不能相邻，求出f(m) ，f(m)指代至少有m个位置不合法的方案数。由此总共有2n 个点 k 条链，链与链之间无边 互不干涉。把二分图展开成k条链，进行dp。简单的乘法原理罢了。
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 494
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数
Zuoriqiufeng的博客
10-30 397
【代码】代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数。
xtu oj 连接字符串
Go offline for a while
10-30 960
最后总结一下：这题思路比较直观，找公共的元素，代码细节比较多，一个是要求输出字典序小的，第二是前面字符串要枚举完最后一个元素才算满足条件，第三是两个字符串可能完全没有公共部分，需要特判。
数据结构初阶排序全解
最新发布
枫の大一分享
11-03 708
排序顾名思义，就是将一组乱序的数，按从大到小或者从小到大进行排列的操作。常见的排序如下可以看到排序也是有分类的，既然有分类，那么这边给出宝子们一个思考，在最后测试的时候给出答案，思考1：排序方法这么多，哪个最好呢？最差的有什么用呢？那么废话不多说，今天的重点内容就是理解并写出一个个排序算法，现在直接上高速，带着宝子们攻破一个个排序算法！这边给出各个排序算法的声明，会在对应内容进行解释，宝子们先有个印象即可~~今天讲解了各种类型的排序算法，最常用的还是时间复杂度最小的堆排序、快排、归并排序。
【力扣打卡系列】二分查找(搜索旋转排序数组)
qq_45734745的博客
10-29 299
坚持按题型打卡&刷&梳理力扣算法题系列，语言为go，Day11。
Java编程挑战：30道提升技能的练习题
- 第十三题是经典的斐波那契序列问题，可能需要通过递归或动态规划的方法求解兔子数量。 这些练习题覆盖了Java编程的许多核心概念，包括基本语法、控制结构、数据类型、循环、逻辑判断、函数调用以及输入输出操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值