【代码随想录训练营第42期 Day43打卡 - 子序列问题 - LeetCode 300. 最长递增子序列 674. 最长连续递增序列 718. 最长重复子数组

逝去的秋风

于 2024-08-28 19:53:26 发布

阅读量711

点赞数 20

分类专栏：代码随想录打卡文章标签： leetcode 子序列问题动态规划

本文链接：https://blog.csdn.net/2303_79786049/article/details/141646890

版权

代码随想录打卡专栏收录该内容

38 篇文章 0 订阅

订阅专栏

一、解题步骤

今天解决的是动态规划章节的子序列问题，共探讨了三道题。这类题一般可通过以下步骤完成：

1. 定义状态

首先，需要定义动态规划数组（通常称为dp数组）及其状态含义。对于子序列问题，dp[i]通常表示以第i个元素结尾的子序列的某种性质（如最长长度、最大/最小值等）。

2. 确定状态转移方程

状态转移方程是动态规划的核心，它描述了如何从一个或多个已知状态推导出下一个状态。对于子序列问题，通常需要考虑以下几种情况：

最长子序列（LIS，Longest Increasing Subsequence）：

dp[i] = max(dp[i], dp[j] + 1)

解释：如果nums[i]大于nums[j]，那么nums[i]可以接在以nums[j]结尾的最长子序列后面，形成一个更长的子序列。

最长公共子序列（LCS，Longest Common Subsequence）：

if (nums1[i] == nums2[j]) dp[i][j] = dp[i - 1][j - 1] + 1

else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])

解释：如果nums1[i]等于nums2[j]，则当前字符可以加入LCS；否则，取不包含nums1[i]或nums2[j]中的较大者。

3. 初始化边界条件

确定dp数组的初始值。对于子序列问题，通常有以下几种初始化方式：

单序列问题：dp[0] = 1（表示单个元素的最长/最大子序列长度/值）

双序列问题：dp[0][j]和dp[i][0]初始化为0（表示一个序列为空时的子序列长度）

4. 遍历顺序

根据状态转移方程，确定dp数组的遍历顺序。通常，遍历顺序是按照子序列的长度递增的顺序进行的。

5. 返回结果

根据问题的要求，返回最终的dp数组值或根据dp数组计算出的结果。

二、题目与题解

题目一：300. 最长递增子序列

题目链接

300. 最长递增子序列 - 力扣（LeetCode）

给你一个整数数组 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 。
示例 2：
输入：nums = [0,1,0,3,2,3]
输出：4
示例 3：
输入：nums = [7,7,7,7,7,7,7]
输出：1
提示：

1 <= nums.length <= 2500
-104 <= nums[i] <= 104

题解：动态规划

上边有提到这类题的做题思路，这里需要注意的就是dp数组中dp[i]表示的含义：

dp[i]：以位置 i 结尾的最长递增子序列的长度。需要理解的一个点就是这里的dp[i]是明确以 i 结尾，而不是 i 之前某个位置。

然后就是初始化的考虑：上边提到，单序列问题初始化 dp[0] = 1，在这里，我们需要初始化所有dp数组元素为1，表示任意递增子序列至少有一个元素。

最后就是递推方程的确立，当前的 dp[i] 将由在当前位置 i 之前的 dp[j] 得来，我们要得到以 i 结尾的递增子序列长度的最大值，就需要遍历所有当前位置 i 之前的位置 j ，比较所有递增序列，取最大值即可。

for (int i = 1; i < n; i++) {     
            for (int j = 0; j < i; j++) {           
                if (nums[i] > nums[j]) {
                    dp[i] = max(dp[i], dp[j] + 1);    
                }
            }
            ans = max(ans, dp[i]);      
        }

注意，这里最终的结果 ans 就是处于所有位置的 i 的最长递增子序列中的最大长度--我们可以在循环中一并比较，不断更新这个值。

完整代码如下：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        if (n == 0 || n == 1) {
            return n;
        }
        vector<int> dp(n, 1);      //dp[i]：以位置 i 结尾的最长递增子序列的长度（注意：必须以nums[i]结尾）；注意初始化所有元素为1；每一个 i，对应的 dp[i]（即最长递增子序列）起始大小至少都是1
        int ans = 0;           //记录结果
        for (int i = 1; i < n; i++) {       //从第二个元素开始遍历当前元素
            for (int j = 0; j < i; j++) {           //内层循环，遍历当前位置 i 之前的所有元素
                if (nums[i] > nums[j]) {
                    dp[i] = max(dp[i], dp[j] + 1);     //注意这里不是要dp[i] 与 dp[j] + 1进行比较，而是我们要取dp[j] + 1的最大值 -- 多个 j 下的最大值，才是当前位置 i 对应的最大长度
                }
            }
            ans = max(ans, dp[i]);      //更新结果变量，取 dp 数组中的最大值 -- 所有元素 i 结尾情况的最大值
        }
        return ans;       
    }
};

题目二：674. 最长连续递增序列

题目链接

674. 最长连续递增序列 - 力扣（LeetCode）、

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

连续递增的子序列 可以由两个下标 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 隔开。 
示例 2：
输入：nums = [2,2,2,2,2]
输出：1
解释：最长连续递增序列是 [2], 长度为1。
提示：

1 <= nums.length <= 104
-109 <= nums[i] <= 109

题解：动态规划

这道题感觉比上一道简单，已经确定是连续的递增序列了，就只需要比较相邻的两个元素的大小，就能够确定以当前位置 i 结尾的最长连续递增序列的长度。

代码如下：

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int n = nums.size();
        if (n == 0 || n == 1) {
            return n;
        }
        vector<int> dp(n, 1);       //dp[i]：以位置 i 结尾的最长递增子序列的长度（注意：必须以nums[i]结尾），初始化所有元素为1：最长递增子序列至少一个元素
        int ans = 0;
        for (int i = 1; i < n; i++) {
            if (nums[i] > nums[i - 1]) {        //连续递增--只考虑相邻元素
                dp[i] = dp[i - 1] + 1;
            }
            ans = max(ans, dp[i]);      //不断更新，取每个位置 i 结尾的最长连续递增子序列的的最大长度
        }
        return ans;
    }
};

题目三：718. 最长重复子数组

题目链接

718. 最长重复子数组 - 力扣（LeetCode）

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

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

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 100

题解：动态规划

这道题的关键就是dp数组的建立，对于两个数组的双序列问题，我们也将采用双维度dp数组来解决这个问题。

dp[i][j]：以下标 i-1 为结尾的nums1，和以下标 j-1 为结尾的nums2，最长重复子数组长度为 dp[i][j]。这就很容易搞错了，我们这样设置的缘由就是当前位置（i, j）是由前一个元素（i - 1, j）得来，为了防止越界，我们选择这样设置。

然后一个注意的点就是双序列问题，dp数组所有元素都初始化为0。

最后就是公共子序列就是要求对应元素一致：这里的判断条件就是dp数组前一个元素对应的两个数组的元素一样，即：

 if (nums1[i - 1] == nums2[j - 1])

这时就能满足当前位置由前一个位置长度+1。（多了当前判断元素）

代码如下：

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size();
        int m = nums2.size();
        vector<vector<int>> dp (n + 1, vector<int>(m + 1, 0));     //dp[i][j]：以下标i-1为结尾的nums1，和以下标j-1为结尾的nums2，最长重复子数组长度为dp[i][j]（因此i,j循环都从1开始）；初始化所有元素为0
        int ans = 0;
        for (int i = 1; i <= n; i++) {          //外层循环，遍历nums1的所有元素
         for (int j = 1; j <= m; j++) {            //内层循环，遍历nums2的所有元素
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;      //如果nums1的第i-1个元素（从0开始计数）等于nums2的第j-1个元素，则当前最长公共子序列长度为前一个元素的最长公共子序列长度+1
                }
                ans = max(ans, dp[i][j]);           //不断更新结果变量 -- 取得以任意位置(i - 1, j - 1)结尾的最长重复子数组的长度的最大值
            }
        }
        return ans;
    }
};