代码随想录算法训练营第五十二天| LeetCode300.最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组

李某今天洗头了吗

已于 2024-05-04 11:36:31 修改

阅读量592

点赞数 20

分类专栏：代码随想录训练营文章标签：算法动态规划 c++ leetcode 子序列

于 2024-05-04 01:27:24 首次发布

本文链接：https://blog.csdn.net/qq_64336203/article/details/138421198

版权

代码随想录训练营专栏收录该内容

47 篇文章 0 订阅

订阅专栏

一、LeetCode300.最长递增子序列

题目链接/文章讲解/视频讲解：https://programmercarl.com/0300.%E6%9C%80%E9%95%BF%E4%B8%8A%E5%8D%87%E5%AD%90%E5%BA%8F%E5%88%97.html

状态：已解决

1.思路

动规做多了，其实能够很快确认出来dp数组，dp[i]：以 nums[i] 结尾的最长递增序列，但是我在求递推公式的时候贪了一下，想一次遍历做出来，但是发现不对，看来这题还是必须双重遍历。

（1）确定dp数组以及下标含义：

由于nums数组为一维，故dp[i]也定义为一维的就行了。dp[i]：以 nums[i] 结尾的最长递增序列。

（2）确定递推公式：

确定了dp数组就很好确定递推公式了，只需要遍历nums[i]之前的元素，只要满足nums[i]>nums[j]，就将dp[j]的值+1赋给dp[i]，然后所有情况取最大，故递推公式：

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

（3）初始化dp数组：

由于题目要求求子序列长度，而一个元素也能构成子序列，故给每个元素的初始序列长度都为1。

（4）确定遍历顺序：

最外层 i 必定是从小到大，因为我们要计算最长递增子序列，所以需要前面的递增序列长度来推导当前的长度。

内层 j 可以从小到大也可以从大到小，只要能遍历完 0~i-1即可，具体哪个方向无所谓，因为 0~i-1是前面的外层遍历中已经计算出的。

（5）举例推导dp数组：

输入：[0,1,0,3,2]，dp数组的变化如下：注意，最长递增子序列不一定以nums数组最后一个元素结尾，故要维护每次外层循环中,dp[i]的最大值，最后返回的是这个最大值，不是dp[nums.size()-1]。

2.代码实现

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

时间复杂度：O(n^2)

空间复杂度：O(n)

二、674. 最长连续递增序列

题目链接/文章讲解/视频讲解：https://programmercarl.com/0674.%E6%9C%80%E9%95%BF%E8%BF%9E%E7%BB%AD%E9%80%92%E5%A2%9E%E5%BA%8F%E5%88%97.html

状态：已解决

1.思路

这道题对比上道题难度是下降了的，因为上道题不是连续的，故 nums[i] 可以衔接到前面已有的连续递增子序列，因此要逐个遍历 0~i-1 的每个值来看nums[i]是否可以衔接上去。但是现在求的是连续递增子序列，这意味着，0~i-2 前面的子序列是无法拼接 nums[i] 的，故我们只需要看 nums[i] 能不能拼接 nums[i-1] 即可。

也就是说，不再需要第二层 j 循环，只需要用外层的 i 循环，让 nums[i] 与 nums[i-1] 做比较，看是否能够拼接，其余地方均与上题相同。

2.代码实现

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        vector<int> dp(nums.size(),1);
        int maxLength = 0;
        for(int i=1;i<nums.size();i++){
            if(nums[i-1] < nums[i]){
                dp[i] = dp[i-1] + 1; //只用一层循环
            }
            maxLength = max(dp[i],maxLength);
        }
        return maxLength;
    }
};

时间复杂度：O(n)

空间复杂度：O(n)

三、718. 最长重复子数组

题目链接/文章讲解/视频讲解：https://programmercarl.com/0718.%E6%9C%80%E9%95%BF%E9%87%8D%E5%A4%8D%E5%AD%90%E6%95%B0%E7%BB%84.html

状态：已解决

1.思路

注意，子数组就是连续子序列（子数组要保证原数组顺序），那么这道题可以暴力求解，外层循环是遍历数组 nums1，内层循环是遍历数组 nums2，然后在内层循环中以 i,j 作为两个数组的起始位置，用一个while循环对比两个串，记录每种情况的最大匹配程度。

动规解法：

（1）确定dp数组以及下标含义：

        dp[i][j] ：以下标i - 1为结尾的A，和以下标 j - 1为结尾的B，最长重复子数组长度为dp[i][j]。

        此时细心的同学应该发现，那dp[0][0]是什么含义呢？总不能是以下标-1为结尾的A数组吧。其实dp[i][j]的定义也就决定着，我们在遍历dp[i][j]的时候i 和 j都要从1开始。

        那有同学问了，我就定义dp[i][j]为以下标i为结尾的A，和以下标j 为结尾的B，最长重复子数组长度。不行么？也行，但是很麻烦：如果定义 dp[i][j]为以下标i为结尾的A，和以下标j 为结尾的B，那么dp[i][0]和dp[0][j]就有意义，代表下标为0结尾的A和下标为0结尾的B，因此，第一行和第一列要进行初始化：如果nums1[i] 与 nums2[0] 相同的话，对应的 dp[i][0]就要初始为1，因为此时最长重复子数组为1。 nums2[j] 与 nums1[0]相同的话，同理。

故初始化多了两个遍历。

（2）确定递推公式：

再次明确dp[i][j]的含义：以下标i - 1为结尾的A，和以下标 j - 1为结尾的B，最长重复子数组长度为dp[i][j]。那么，dp[i][j]就应该由nums1[i-1]=nums2[i-1]的情况下，下标 i - 2 为结尾的A和以下标 j - 2 为结尾的B（dp[i-1][j-1]）+1而来。

故递推公式：dp[i][j] = dp[i-1][j-1] + 1；（或者dp[i+1][j+1] = dp[i][j] + 1）

（3）初始化dp数组：

根据dp[i][j]的定义，dp[i][0] 和dp[0][j]其实都是没有意义的！

但dp[i][0] 和dp[0][j]要初始值，因为为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;

所以dp[i][0] 和dp[0][j]初始化为0。

举个例子A[0]如果和B[0]相同的话，dp[1][1] = dp[0][0] + 1，只有dp[0][0]初始为0，正好符合递推公式逐步累加起来。

（4）确定遍历顺序：

两层循环之间的顺序无固定要求，只需要遍历完二者就行，谁先谁后无所谓，但是每层遍历都需要从小到大（递推公式决定）

（5）举例推导dp数组：

拿示例1中，A: [1,2,3,2,1]，B: [3,2,1,4,7]为例，画一个dp数组的状态变化，如下：

2.代码实现

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