Studying-代码随想录训练营day43| 300.最长递增子序列、674.最长连续递增子序列、718.最长重复子数组

第43天，动态规划part10,，子序列题型，编程语言：C++

目录

300.最长递增子序列

674.最长连续递增子序列

718.最长重复子数组

总结

---

300.最长递增子序列

文档讲解：代码随想录最长递增子序列

视频讲解：手撕最长递增子序列

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

学习：本题需要找的是子序列，子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。本题对于动态规划dp数组的使用，又和前面的题型不同，从动归五部曲进行分析：

1.确定dp数组以及下标的含义：dp[i]表示以下标i为尾元素的[0- i]能够组成的最长递增子序列的长度。注意如果是按照之前的题型来说，我们应该设置的dp[i]是[0 - i]能够组成的最长递增子序列的长度，但本题我们需要强调以nums[i]为尾元素。也就意味着一定要包含nums[i]。

为什么一定要包含nums[i]呢，这是因为我们再每加入一个元素的时候，实际上我们不仅仅需要与最大的元素比较，我们还需要和前面的元素进行比较。例如[1,2,4,2,3,4]。如果我们按照以前的方式只记录[0 - i]能够组成的最长递增子序列的长度，并且保存最大值，那么我们在遍历后面的三个元素2，3，4的时候，都不能加入仅最长子序列当中，但显然本题的最长子序列应该是4，也就是[1,2,3,4]。因此nums[i]不仅仅需要和最大的元素进行比较，还需要和前面的元素进行比较，而我们在进行nums[i]与nums[j]其实就默认了分别以nums[i]和nums[j]为结尾，要不然比较就没有意义了，因此我们选以尾部元素比较作为递增的方式。

2.确定递推公式：位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。最终得到递推公式：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);

3.dp[i]的初始化，对于每一个i对应的dp[i]来说，都至少包含nums[i]自己，因此起始大小都是1.

4.确定遍历顺序：由递推公式可知，当前i需要前面的[0, i -1]的为止上的结果推导而来，因此需要从前往后遍历。

5.举例推导dp数组：

代码：

//时间复杂度O(n^2)
//空间复杂度O(n)
class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        //动态规划
        if(nums.size() <= 1) return nums.size();
        //1.确定dp数组以及下标的含义
        vector<int> dp(nums.size(), 1); //dp[i]: [0-i]中最长子序列的长度
        //2.确定递推公式：
        //if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
        //3.初始化dp数组
        //dp[i] = 1; //至少包含nums[i]本身
        //4.确定遍历顺序
        int result = 0;
        for(int i = 1; i < nums.size(); i++) {
            for(int j = 0; j < i; j++) {
                if(nums[j] < nums[i]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            result = max(result, dp[i]);
        }
        return result;
    }
};

---

674.最长连续递增子序列

文档讲解：代码随想录最长连续递增序列

视频讲解：手撕最长连续递增序列

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

学习：本题与上一题的不同在于，本题找的是连续子序列。因此只需要和前一个元素进行比较就可以了。但是本题的dp数组的设置与上一题一致，因为本题我们不能直接依靠前面的结果，因为后面可能会出现长度更长的子序列。

本题的动规五部曲分析，只有递推公式与上一题不同，本题的递推公式为：if(nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + 1；后面的结果只依赖于前一个的结果。

但要注意，本题的最终答案，同样不一定是dp[nums.size() - 1]，因为前面和后面都可能会出现最长的连续子序列，因此我们还需要一个result，来记入最大的结果。

代码：

//时间复杂度O(n)
//空间复杂度O(n)
class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        //动态规划
        if(nums.size() <= 1) return nums.size();
        //1.确定dp数组以及下标的含义
        vector<int> dp(nums.size(), 1); //dp[i] 表示以nums[i]结尾的最大连续子序列
        //2.递推公式，dp[i]只与dp[i - 1]有关
        //if(nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + 1;
        //3.初始化dp数组：dp[i] = 1;
        //4.确定遍历顺序
        int result = 0;
        for(int i = 1; i < nums.size(); i++) {
            if(nums[i] > nums[i - 1]) {
                dp[i] = dp[i - 1] + 1;
            }
            if (dp[i] > result) result = dp[i];
        }
        return result;
    }
};

本题其实直观上，最容易想到的办法是贪心，从前往后，遍历到后面的元素比前大就+1。否则就从1开始重新计算。最后取最大值。

代码：

//时间复杂度O(n)
//空间复杂度O(n)
class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        //贪心算法：遇到nums[i] > nums[i - 1]的情况，count就++，否则count为1
        if(nums.size() <= 1) return nums.size();
        int result = 1;
        int count = 1;
        for(int i = 1; i < nums.size(); i++) {
            if(nums[i] > nums[i - 1]) {
                count++;
            }
            else {
                count = 1;
            }
            if(count > result) {
                result = count;
            }
        }
        return result;
    }
};

---

718.最长重复子数组

文档讲解：代码随想录最长重复子数组

视频讲解：手撕最长重复子数组

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

学习：本题是在两个数组中找公共的连续子序列（子数组）。能够想到的暴力解法是，使用两层for循环，确定两个数组的起始为止，然后再来一个循环可以是for或者while，来从两个起始位置开始比较，取得重复子数组的长度。

本题采用动规的方法，最重要的就是能够想到dp数组的设置。以前两题dp数组的设置为灵感，本题我们可以设置一个二维dp数组。dp[i][j]表示以下标i - 1为结尾的nums1数组，和以下标j - 1结尾的nums2数组的最长重复子数组的长度为dp[i][j]。注意这里是以i- 1作为结尾，为什么要这么做，从初始化状态部门会进行说明。

2.确定递推公式：根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。且仅当nums1[i - 1] == nums[j - 1]时，dp[i][j] = dp[i - 1][j - 1] + 1。

3.初始化dp数组：根据递推公式，显然我们需要初始化第一行和第一列。

这个部分就可以说明为什么我们要以i - 1作为结尾。因为如果我们设置的dp[i][j]是以i和j作为结尾。那么我们就有必要单独初始化第一行和第一列，因为dp[0][0]是可能等于1的，也就是nums1和nums2的下标为0的元素相等。其他的dp[0][j]和dp[i][0]都有可能是1，需要我们进行初始化。

但是如果我们以i - 1和j - 1作为结尾。那么第一行和第一列，本质上是没有意义的。但是带入递推公式，假如nums1和nums2的下标为0（也就是第一个元素）相等，那么此时应该是dp[1][1] = dp[i - 1][j - 1] + 1 = 1。则我们只需要把第一行和第一列都初始化为0即可，相当于我们是把第一种情况的初始化，加入到了后序的遍历中。而把第一行和第一列初始化为0，在我们创建数组的时候，就可以进行了。

总结来说就是，我们可以选择以i和j结尾，也可以选择以i-1和j-1结尾，只不过是初始化数组的时候操作不同而已。对于i和j我们需要单独对第一行和第一列初始化，对于i-1和j-1我们只需要在创建数组的时候，全部初始化为0即可。

4.确定遍历顺序，显然我们需要遍历nums1和nums2，且均是从前往后遍历。

5.举例dp数组：

代码：注意，我们还是需要用一个result来保存最大值。

//时间复杂度O(n)
//空间复杂度
class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        //动态规划：
        if(nums1.size() == 0 || nums2.size() == 0) return 0;
        //1.确定dp数组，以及下标的的含义
        //dp[i][j]表示以下标i-1结尾和下标j-1结尾的nums1和nums2的最大公共长度
        vector<vector<int>> dp(nums1.size() + 1, vector<int> (nums2.size() + 1, 0));
        //2.确定递推公式
        //if(nums[i - 1] == nums[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
        //3.初始化dp数组：
        //对于i = 0; j = 0来说都没有意义，我们遍历的时候也需要从i = 1，j = 1进行遍历。但为了递推公式我们需要初始化为0
        //4.确定遍历顺序
        int result = 0;
        for(int i = 1; i <= nums1.size(); i++) {
            for(int j = 1; j <= nums2.size(); j++) {
                if(nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                if(dp[i][j] > result) result = dp[i][j];
            }
        }
        return result;
    }
};

---

总结

子序列是动态规划的经典题型之一，不同题型之间，dp数组的设置最为关键，其次为递推数组。一定要好好理解，多加练习。