Day 52 300.最长递增子序列 674. 最长连续递增序列 718. 最长重复子数组

最长递增子序列

给你一个整数数组 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
• -10^4 <= nums[i] <= 10^4

​ 动规五部曲：

​ 1dp数组下标及其含义

​ dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度；

​ 做 递增比较的时候，如果比较 nums[j] 和 nums[i] 的大小，那么两个递增子序列一定分别以nums[j]为结尾和nums[i]为结尾

​ 所以此处的dp[i]表示的一定是尾部元素；

​ 2.递推公式

​ 位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值；

​ 所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);

​ 注意这里不是要dp[i] 与 dp[j] + 1进行比较，而是我们要取dp[j] + 1的最大值；

​ 3.初始化

​ 易知，最长递增子序列最小长度为1，所以全部初始化为1即可；

​ 4.遍历顺序

​ dp[i] 是有0到i-1各个位置的最长递增子序列 推导而来，那么遍历i一定是从前向后遍历；

​ j其实就是遍历0到i-1，那么是从前到后，还是从后到前遍历都无所谓，只要吧 0 到 i-1 的元素都遍历了就行了。 所以默认习惯 从前向后遍历；

	int res = 0;//最后的返回值是res而不是dp[nums.size() - 1]
	for(int i = 1; i < nums.size(); i++){
        for(int j = 0; j <i; j++){//j < i是因为dp数组的含义是以i为结尾的最长子序列
            if(nums[i] > nums[j]){
                dp[i] = max(dp[i], dp[j] + 1);
            }
        }
        if(dp[i] > res)	res = dp[i];
    }

​ 5.打印dp数组

​ 整体代码如下：

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

最长连续递增序列

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

连续递增的子序列 可以由两个下标 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。

提示：

• 0 <= nums.length <= 10^4
• -10^9 <= nums[i] <= 10^9

​ 和上题最大的区别在于，此时要求的递增序列是连续的；

​ 1.确定dp数组下标及其含义

​ dp[i]表示以i为结尾的最长连续递增子序列的长度；

​ 2.确定递推公式

​ 关键是怎么实现连续这个操作，由于要求是连续，所以

	if(nums[i - 1] < nums[i])	dp[i] = do[i - 1] + 1;//由于要求连续，所以不需要比较前面的所有元素

​ 3.初始化

​ 同上，全为1即可；

​ 4.遍历顺序

​ 由递推公式，显然是从前往后遍历；

	int res = 0;
	for(int i = 1; i < nums.size(); i++){
        if(nums[i - 1] < nums[i])	dp[i] = do[i - 1] + 1;
        res = max(dp[i], res);
    }

​ 5.打印dp数组

​ 整体代码如下

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

最长重复子数组

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

示例：

输入：

• A: [1,2,3,2,1]
• B: [3,2,1,4,7]
• 输出：3
• 解释：长度最长的公共子数组是 [3, 2, 1] 。

提示：

• 1 <= len(A), len(B) <= 1000
• 0 <= A[i], B[i] < 100

​ 如果直接使用暴力解法的话，时间复杂度至少是$O(n^3)$；

​ 而动态规划，只要想到二维dp数组就好解决了；

​ 1.确定dp数组（dp table）以及下标的含义

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

​ 如果是以下标i为结尾或者以j为结尾，则需要额外初始化dp[i][0]或dp[0][j];

​ 2.递推公式

​ 求最长重复子数组，那只能是一个一个的加上来；

	if(num1[i - 1] == nums2[j - 1])	dp[i][j] = dp[i - 1][j - 1] + 1;//由于是同步进行的寻找操作，所以此处只能是dp[i - 1][j - 1],这是由dp定义导致的

​ 3.初始化

	dp[i][0] = 0;//第一列第一行都是没有意义的
	dp[0][j] = 0;

​ 4.遍历顺序

	for(int i = 1; i <= num1.size(); i++){
		for(int j = 1; j <= nums2.size; j++){
            if(num1[i - 1] == nums2[j - 1])	dp[i][j] = dp[i - 1][j - 1] + 1;
        }
        res = max(res, dp[i][j]);
	}

​ 5.打印dp数组

​ 整体代码如下：

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 res = 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;
                res = max(res, dp[i][j]);
            }
        }
        return res;
    }
};

​ 由于本题所有状态都是由上一个状态得出的，所以可以进行一个状态压缩；

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        vector<int> dp(nums2.size() + 1, 0);
        int res = 0;
        for(int i = 1; i <= nums1.size(); i++){
            for(int j = nums2.size(); j > 0; j--){//避免重复覆盖从后向前遍历
                if(nums1[i - 1] == nums2[j - 1]){
                    dp[j] = dp[j - 1] + 1;
                }
                else dp[j] = 0;
                res = max(res, dp[j]);
            }
        }
        return res;
    }
};