动态规划篇-代码随想录算法训练营第三十九天| 300.最长递增子序列，674. 最长连续递增序列，718. 最长重复子数组，1143.最长公共子序列，1035.不相交的线，53. 最大子数组和

热爱编程的OP

已于 2024-08-24 11:29:26 修改

阅读量412

点赞数 14

分类专栏： leetcode 文章标签：动态规划算法 leetcode c++ 学习

于 2024-08-24 10:54:53 首次发布

本文链接：https://blog.csdn.net/m0_67804957/article/details/141496003

版权

leetcode 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

子序列与子数组区别

子序列不一定连续，子数组一定连续

300.最长递增子序列

题目链接：. - 力扣（LeetCode）

讲解视频：

动态规划之子序列问题，元素不连续！| LeetCode：300.最长递增子序列

题目描述：

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

解题思路：

1、状态表示：

dp[i] 表示：以 i 位置元素为结尾的「所有子序列」中，最长递增子序列的长度。

2、状态转移方程：

对于 dp[i] ，我们可以根据「子序列的构成方式」，进行分类讨论：

子序列长度为 1 ：只能自己玩了，此时 dp[i] = 1 ；
子序列长度大于 1 ： nums[i] 可以跟在前面任何一个数后面形成子序列。

设前面的某一个数的下标为 j ，其中 0 <= j <= i - 1 。只要 nums[j] < nums[i] ， i 位置元素跟在 j 元素后面就可以形成递增序列，长度为 dp[j] + 1 。因此，我们仅需找到满足要求的最大的 dp[j] + 1 即可。综上， dp[i] = max(dp[j] + 1, dp[i]) ，其中 0 <= j <= i - 1 && nums[j]
< nums[i] 。

3、初始化：

所有的元素「单独」都能构成一个递增子序列，因此可以将 dp 表内所有元素初始化为 1 。
由于用到前面的状态，因此我们循环的时候从第二个位置开始即可。

4、遍历顺序：

填表顺序「从左往右」。

5、返回值：

由于不知道最长递增子序列以谁结尾，因此返回 dp 表里面的「最大值」。

代码：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n,1);
        int ret = 1;
        for(int i = 1; i < n; i++)
        {
            for(int j = 0; j <= i - 1; j++)
                if(nums[i] > nums[j])
                    dp[i] = max(dp[i],dp[j]+1);
            ret = max(ret,dp[i]);
        }
        return ret;
    }
};

674. 最长连续递增序列

题目链接：. - 力扣（LeetCode）

讲解视频：

动态规划之子序列问题，重点在于连续！| LeetCode：674.最长连续递增序列

题目描述：

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

示例 1：

输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。

解题思路：

1、状态表示：

dp[i] 表示：以 i 位置元素为结尾的「所有子序列」中，最长连续递增子序列的长度。

2、状态转移方程：

对于 dp[i] ，我们可以根据「子序列的构成方式」，进行分类讨论：

子序列长度为 1 ：只能自己玩了，此时 dp[i] = 1 ；
子序列长度大于 1 ： nums[i] 只能跟在nums[i-1]后面形成子序列。

只有 nums[i-1] < nums[i] ， i 位置元素跟在 i-1元素后面就可以形成递增序列，长度为 dp[i-1] + 1 。综上， dp[i] = dp[i-1] + 1 ，其中nums[i-1]< nums[i] 。

3、初始化：

所有的元素「单独」都能构成一个递增子序列，因此可以将 dp 表内所有元素初始化为 1 。
由于用到前面的状态，因此我们循环的时候从第二个位置开始即可。

4、遍历顺序：

填表顺序「从左往右」。

5、返回值：

由于不知道最长递增子序列以谁结尾，因此返回 dp 表里面的「最大值」。

代码：

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n,1);
        int ret = 1;
        for(int i = 1; i < n; i++)
        {
            if(nums[i-1] < nums[i])
                dp[i] = dp[i-1]+1;
            ret = max(ret,dp[i]);
        }
        return ret;
    }
};

718. 最长重复子数组

题目链接：. - 力扣（LeetCode）

讲解视频：

动态规划之子序列问题，想清楚DP数组的定义 | LeetCode：718.最长重复子数组

题目描述：

给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。

示例 1：

输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3
解释：长度最长的公共子数组是 [3,2,1] 。

解题思路：

子数组是数组中「连续」的一段，我们习惯上「以某一个位置为结尾」来研究。由于是两个数组，因此我们可以尝试：以第一个数组的 i 位置为结尾以及第二个数组的 j 位置为结尾来解决问
题。

1、状态表示：

dp[i][j] 表示「以第一个数组的 i 位置为结尾」，以及「第二个数组的 j 位置为结尾」公
共的、长度最长的「子数组」的长度。

2、状态转移方程：

对于 dp[i][j] ，当 nums1[i] == nums2[j] 的时候，才有意义，此时最长重复子数组的长度应该等于 1 加上除去最后一个位置时，以 i - 1, j - 1 为结尾的最长重复子数组的长度。因此，状态转移方程为： dp[i][j] = dp[i - 1][j - 1] + 1

3、初始化：

为了处理「越界」的情况，我们可以添加一行和一列，dp 数组的下标从 1 开始，这样就无需初始化。第一行表示第一个数组为空，此时没有重复子数组，因此里面的值设置成0即可；第一列也是同理。

4、遍历顺序：

「从上往下」填每一行，每一行「从左往右」。

5、返回值：

根据「状态表示」，我们需要返回 dp 表里面的「最大值」。

代码：

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size(), m = nums2.size();
        vector<vector<int>> dp(n+1,vector<int>(m+1));
        int ret = 0;
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
            {
                if(nums1[i-1] == nums2[j-1]) 
                    dp[i][j] = dp[i-1][j-1]+1;
                ret = max(ret,dp[i][j]);
            }  
        return ret;
    }
};

1143.最长公共子序列

题目链接：. - 力扣（LeetCode）

讲解视频：

动态规划子序列问题经典题目 | LeetCode：1143.最长公共子序列

题目描述：

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 1：

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace" ，它的长度为 3 。

解题思路：

比上一题最长重复子数组多了一种判断，即如果nums[i] != nums[j]还能求dp[i][j]，而不是0

1、状态表示：

dp[i][j]表示:s1的[0，i]区间以及 s2 的[0，j]区间内的所有的子序列中，最长公共子序列的长度。

2、状态转移方程：

分析状态转移方程的经验就是根据「最后一个位置」的状况，分情况讨论。对于 dp[i][j] ，我们可以根据 s1[i] 与 s2[j] 的字符分情况讨论：

两个字符相同， s1[i] = s2[j] ：那么最长公共子序列就在 s1 的 [0, i - 1] 以及 s2 的 [0, j - 1] 区间上找到一个最长的，然后再加上 s1[i] 即可。因此dp[i][j] = dp[i - 1][j - 1] + 1 ；
两个字符不相同， s1[i] != s2[j] ：那么最长公共子序列一定不会同时以 s1[i]和 s2[j] 结尾。那么我们找最长公共子序列时，有下面三种策略：

去 s1 的 [0, i - 1] 以及 s2 的 [0, j] 区间内找：此时最大长度为 dp[i- 1][j] ；
去 s1 的 [0, i] 以及 s2 的 [0, j - 1] 区间内找：此时最大长度为 dp[i ][j - 1] ；
去 s1 的 [0, i - 1] 以及 s2 的 [0, j - 1] 区间内找：此时最大长度为dp[i - 1][j - 1] 。

我们要三者的最大值即可。但是我们细细观察会发现，第三种包含在第一种和第二种情况里
面，但是我们求的是最大值，并不影响最终结果。因此只需求前两种情况下的最大值即可。
综上，状态转移方程为：
if(s1[i] == s2[j]) dp[i][j] = dp[i - 1][j - 1] + 1 ;
if(s1[i] != s2[j]) dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) 。

3、初始化：

第一行和第一列里面的值初始化为 0

4、遍历顺序：

「从上往下」填每一行，每一行「从左往右」。

5、返回值：

根据「状态表示」，我们需要返回 dp 表里面的「最大值」。

代码：

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int n = text1.size(), m = text2.size();
        vector<vector<int>> dp(n+1,vector<int>(m+1));
        int ret = 0;
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= m; j++)
            {
                if(text1[i-1] == text2[j-1]) dp[i][j] = dp[i-1][j-1]+1;
                else dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
                ret = max(dp[i][j],ret);
            }
        }
        return ret;
    }
};

1035.不相交的线

题目链接：. - 力扣（LeetCode）

讲解视频：

动态规划之子序列问题，换汤不换药 | LeetCode：1035.不相交的线

题目描述：

在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。

现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足：

nums1[i] == nums2[j]
且绘制的直线不与任何其他连线（非水平线）相交。

请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。

以这种方法绘制线条，并返回可以绘制的最大连线数。

示例 1：

输入：nums1 = [1,4,2], nums2 = [1,2,4]
输出：2
解释：可以画出两条不交叉的线，如上图所示。 
但无法画出第三条不相交的直线，因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从 nums1[2]=2 到 nums2[1]=2 的直线相交。

解题思路：

经分析会发现本题跟上一题的最长公共子序列一模一样

代码：

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size(), m = nums2.size();
        vector<vector<int>> dp(n+1,vector<int>(m+1));
        int ret = 0;
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= m; j++)
            {
                if(nums1[i-1] == nums2[j-1]) dp[i][j] = dp[i-1][j-1]+1;
                else dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
                ret = max(ret, dp[i][j]);
            }
        }
        return ret;
    }
};

53. 最大子数组和

题目链接：. - 力扣（LeetCode）

讲解视频：

看起来复杂，其实是简单动态规划 | LeetCode：53.最大子序和

题目描述：

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

解题思路：

该题目与前边674.最长连续递增序列相似

1、状态表示：

dp[i] 表示：以 i 位置元素为结尾的「所有子数组」中和的最大和。

2、状态转移方程：

dp[i] 的所有可能可以分为以下两种：

子数组的长度为 1 ：此时 dp[i] = nums[i] ；
子数组的长度大于 1 ：此时 dp[i] 应该等于以 i - 1 做结尾的「所有子数组」中和的最大值再加上 nums[i] ，也就是 dp[i - 1] + nums[i] 。

由于我们要的是「最大值」，因此应该是两种情况下的最大值，因此可得转移方程：
dp[i] = max(dp[i], dp[i - 1] + nums[i]) 。

3、初始化：

使用nums数组进行初始化

4、遍历顺序：

「从左往右」。

5、返回值：

根据「状态表示」，我们需要返回整个dp 表里面的「最大值」。

代码：

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

热爱编程的OP

关注

14
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
动态规划篇-代码随想录算法训练营第三十九天| 300.最长递增子序列，674. 最长连续递增序列，718. 最长重复子数组，1143.最长公共子序列，1035.不相交的线，53. 最大子数组和

300.最长递增子序列，674. 最长连续递增序列，718. 最长重复子数组，1143.最长公共子序列，1035.不相交的线，53. 最大子数组和
复制链接

扫一扫

专栏目录