代码随想录算法训练营DAY50|C++动态规划Part11|300.最长递增子序列、674.最长连续递增序列、718.最长重复子数组

⭐️300.最长递增子序列

力扣题目链接

文章讲解：300.最长递增子序列

视频链接：动态规划之子序列问题，元素不连续！| LeetCode：300.最长递增子序列
状态：子序列问题的开篇，主要是子序列问题思路的开端，非常重要。特别是关于他的dp数组，反复推敲反复琢磨：dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度

可以删除或不删除某些元素，保证数组原有的顺序，然后求最长的递增子序列。

这是典型的子序列系列，也是卡哥安排的第一个动规子序列问题。

思路

• dp数组dp[i]的定义

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

• 递推公式

如果j < i ，并且有nums[j] < nums[i]，其中，以nums[j]结尾的最长递增子序列长度为dp[j]。以nums[i]结尾的最长递增子序列长度为dp[i]。

我们应该有dp[i]=dp[j] + 1，再一个，我们会遍历每一个小于 i 的下标 j（也就是说我们会固定 i ，去遍历 j ）来取到dp[i]的最大值，所以，我们的递推公式是：

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

• dp数组的初始化

每一个i，对应的dp[i]（即最长递增子序列）起始大小至少都是1。因为我们一个元素当然也构成一个子序列

• 确定遍历顺序

老样子，从前到后遍历，至于j的遍历范围是~i-1，但是遍历方向都无所谓.

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] > result) result = dp[i]; // 取长的子序列
}
1
2
3
4
5
6

这里为什么要定义一个result呢，因为我们如果不保存结果的话，后面还得去遍历dp数组找最大，着实没必要

• 举例推导dp数组

输入：[0,1,0,3,2]，dp数组的变化如下：

CPP代码

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(), 1);
        int result = 1;
        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);
            }
            result = result > dp[i] ? result : dp[i]; // 取长的子序列
        }
        return result;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 时间复杂度: O(n^2)
• 空间复杂度: O(n)

674.最长连续递增序列

力扣题目链接

文章讲解：674.最长连续递增序列

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

状态：连续递增子序列和递增子序列区别在哪里？体现在代码中的话又在哪里呢？

• 首先之前的300.最长递增子序列只要求递增子序列，并不要求序列在数组是是一组连续的数，而本题要求连续的递增子序列。其实只要一连续，很明显就可以用贪心算法了(贪心算法的求解会放在最后面)；
• 再一个，代码中我们要求的连续的子序列，所以两次遍历肯定是不用了，只要每次发现连续小的话，直接来个+1即可。

来了，本题要求是连续序列，而不是原始序列派生的子序列

思路

• 明确dp数组的含义

跟上一题一样，以下标i为结尾的最长连续递增子序列的长度为dp[i]

• 确定递推公式

在300.最长递增子序列中，我们的dp[i]是由i面前的某个元素j来进行推导。

本题中我们求的是连续的递增子序列，所以我们没有必要去比较前面的所有元素了，在上一题中，我们可是遍历了0~i-1的j。

所以如果我们nums[i] > nums[i-1]，我们就做对应的那个dp[i] + 1的操作，即：

dp[i]=dp[i-1]+1

• dp数组的初始化

以下标i为结尾的连续递增的子序列长度最少也应该是1，即就是nums[i]这一个元素。

所以dp[i]应该初始1;

• 确定遍历顺序

从递推公式上可以看出， dp[i + 1]依赖dp[i]，所以一定是从前向后遍历。

for (int i = 1; i < nums.size(); i++) {
    if (nums[i] > nums[i - 1]) { // 连续记录
        dp[i] = dp[i - 1] + 1;
    }
}
1
2
3
4
5

• 举例推导dp数组

已输入nums = [1,3,5,4,7]为例，dp数组状态如下：

CPP代码

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        int result = 1;
        vector<int> dp(nums.size() ,1);
        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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

贪心算法

本题其实想到贪心的解法还是比较简单的。和之前写过的53. 最大子序和差不太多。

如果我们在遍历数组的时候，发现当前的元素nums[i]比前一个元素nums[i-1]小了，说明这两个元素肯定不能在一个子序列中，所以直接放弃该序列，并且进行区间的更新。也就是说我们需要一个start来标记区间的开始，然后需要一个循环去遍历整个数组。

综上所述，我们的贪心策略是：
局部最优：当前遍历的相邻元素不满足单调递增的关系时直接放弃，从下一个元素开始重新计算。
全局最优：选取最大的递增序列。

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if (nums.size() == 1) return 1;
        int result = 0, start = 0;
        for (int i = 1; i < nums.size(); i++) {
            if (i > 0 && nums[i] <= nums[i - 1])
                start = i;
            result = max(result, i - start + 1);
        }
        return result;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13

⭐️718.最长重复子数组

力扣题目链接

文章讲解：718.最长重复子数组

视频讲解：动态规划之子序列问题，想清楚DP数组的定义 | LeetCode：718.最长重复子数组
状态：肯定是需要一个二维数组，其他的就不想不太明白了。
但是本题也是子序列二维数组的一个典型题目。再者，一定要注意的就是使用一个result来时刻存储更新的最长的dp值

本题要操作两个数组了，就是要求两个数组中最长的重复子数组长度。

这里的子数组呢其实就是连续子序列，强调的是连续

本题其实最难的就是，如何用dp数组去表示两个数组的所有比较状态。

暴力解法：两层for循环确定两个数组起始位置，然后再来一个循环可以是for或者while，来从两个起始位置开始比较，取得重复子数组的长度。在文章末尾给出暴力算法的求解。

思路

• dp数组含义

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

为什么要定义成i-1结尾和以j-1结尾呢？

其实是为了让后续代码尽可能简洁。后续的话会写如果定义成i结尾和j结尾的代码麻烦之处

• 递推公式

根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。

即当nums[i - 1] 和nums2[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1

根据递推公式可以看出，遍历i 和 j 要从1开始！

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

• 初始化

为了使递推公式能够完成推导，dp[i][0] 和dp[0][j]初始化为0。

• 遍历顺序

从小到大遍历即可，先遍历哪个也都是可以的，并且在遍历的过程中记录dp[i][j]的最大值

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];
    }
}
1
2
3
4
5
6
7
8

• 打印

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

CPP代码

// 版本一
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 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;
    }
};

//滚动数组，遍历nums2的时候，要从后向前遍历，避免重复覆盖
// 版本二
class Solution {
public:
    int findLength(vector<int>& A, vector<int>& B) {
        vector<int> dp(vector<int>(B.size() + 1, 0));
        int result = 0;
        for (int i = 1; i <= A.size(); i++) {
            for (int j = B.size(); j > 0; j--) {
                if (A[i - 1] == B[j - 1]) {
                    dp[j] = dp[j - 1] + 1;
                } else dp[j] = 0; // 注意这里不相等的时候从头开始，一定要有赋0的操作
                if (dp[j] > result) result = dp[j];
            }
        }
        return result;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

为什么dp数组下标i,j表示nums1的i-1结尾和num2的j-1结尾

我们在之前说这样设置是为了让初始化程序比较方便，因为比如说求dp[1][1]，从递推公式来说：$dp[1][1]=dp[1-1][1-1]+1$
如果我们dp[1][1]对应nums1的第0个位置和 nums2 的第0个位置，那么我们肯定是需要初始化dp[0][0]=0的。所有的初始化我们可以在创建dp数组的时候就完成而且计算流程都很直观。

如果我们不小心设置了dp[1][1]对应nums1的第1个位置和 nums2 的第1个位置。那么我们想要比较nums1 和 nums2的第零个位置，就需要另外初始化一组数，来让所谓的$dp[1][1]=dp[0-1][0-1]+1$有意义，这样我们dp数组的初始化还有进行额外的处理，未免太麻烦了。

卡哥的文章中详细介绍了这种情况的处理：718. 最长重复子数组

暴力解法

暴力解法还是很直观的，两个for循环，最后在判断结果的地方我们用一个while比较合适，刚开始想了半天不知道如何进行判断，因为我们要在当前遍历的基础上往前进发才能找到连续相等的子数组。

不过暴力解法会超时

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int maxLength = 0;
        for (int i = 0; i < nums1.size(); ++i) {
            for (int j = 0; j < nums2.size(); ++j) {
                int length = 0;
                while (i + length < nums1.size() 
                    && j + length < nums2.size() 
                    && nums1[i + length] == nums2[j + length]) {
                    ++length;
                }
                maxLength = max(maxLength, length);
            }
        }
        return maxLength;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18