代码随想录算法训练营第五十六天_第九章_动态规划 | 300.最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组

Jane_10358

已于 2023-02-01 21:04:51 修改

阅读量362

点赞数

文章标签：动态规划 leetcode

于 2023-02-01 16:02:55 首次发布

本文链接：https://blog.csdn.net/Jane_10358/article/details/128835627

版权

LeetCode 300.最长递增子序列

给你一个整数数组 nums ，返回其中最长递增子序列的长度。

视频讲解https://www.bilibili.com/video/BV1ng411J7xP 文章讲解 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

思路：
- dp数组含义：dp[i]表示数组下标[0, i]中，以nums[i]结尾的最长递增子序列的长度
- 递推公式：
  - 从0到 i - 1各个位置的最长递增子序列的长度 +1 的最大值
  - if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
- 初始化：全1
- 遍历顺序：外层从左到右（dp[i]依赖于其左边的元素）内层从0到 i - 1或从 i - 1到0都可以
代码：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if (nums.size() <= 1) return nums.size();
        vector<int> dp(nums.size(), 1);
        int result = 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] > result) result = dp[i]; // 取长的子序列
        }
        return result;
    }
};

LeetCode 674. 最长连续递增序列

给定一个未经排序的整数数组，返回其中最长连续递增子序列的长度。

视频讲解https://www.bilibili.com/video/BV1bD4y1778v 文章讲解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

思路：
- dp数组含义：dp[i]表示数组下标[0, i]中，以nums[i]结尾的最长递增子序列的长度
- 递推公式：
  - 连续：只需要比较 nums[i] 和 nums[i - 1]
  - nums[i] > nums[i - 1]👉dp[i] = dp[i - 1] + 1;（连上了，+1）
  - 否则有dp[i] = 1;（没连上，从i位置重新开始）
- 初始化：全1
- 遍历顺序：从左到右
代码：

// 动规解法：
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;
    }
};
// 时间复杂度：O(n)
// 空间复杂度：O(n)

// 贪心解法：遇到nums[i] > nums[i - 1]的情况，count就++，否则count为1，返回count的最大值
class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        int result = 1; // 连续子序列最少也是1
        int count = 1;
        for (int i = 1; i < nums.size(); ++i) {
            if (nums[i] > nums[i - 1]) { // 连续记录
                count++;
            } else { // 不连续，count从头开始
                count = 1;
            }
            if (count > result) result = count;
        }
        return result;
    }
};
// 时间复杂度：O(n)
// 空间复杂度：O(1)

LeetCode 718. 最长重复子数组

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

注：子序列 vs 子数组（连续子序列）

视频讲解https://www.bilibili.com/video/BV178411H7hV 文章讲解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

思路：
- dp数组含义：
  - dp[i][j]：以 nums1[i - 1] 结尾、以 nums2[j - 1] 结尾的最长重复子数组的长度
  - 注：如果定义成以 nums1[i] 结尾、以 nums2[j] 结尾，dp[i][0] 和 dp[0][j]就有意义了，需要分别遍历 i 和 j 来初始化
- 递推公式：
  - 当 nums1[i - 1] 和 nums2[j - 1] 相等时，dp[i][j] = dp[i - 1][j - 1] + 1;
- 初始化：
  - 根据dp[i][j]的定义，dp[i][0] 和 dp[0][j] 都是没有意义的，初值符合递推公式即可
  - 考虑：dp[i][1]👉比较 nums1[i - 1] 和 nums2[0]👉若相等则 dp[i][1] 为1
  - 全部初始化为0
- 遍历顺序：
  - 外层遍历 nums1、内层遍历 nums2，或者反过来都可以（两数组之间无顺序要求）
  - 外层下标从小到大遍历（因为 dp[i][j] 依赖于 dp[i - 1][j - 1]）

代码：

// 版本一
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;
    }
};
// 时间复杂度：O(n × m)，n为nums1长度，m为nums2长度
// 空间复杂度：O(n × m)

// 版本二：滚动数组，内层循环一定要从后往前遍历
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;
    }
};
// 时间复杂度：O(n × m)，n为A长度，m为B长度
// 空间复杂度：O(m)

⭐总结：子序列 / 子数组问题

dp数组含义：
- dp[i] 表示以nums[i]结尾的最长...长度
- 如果涉及两个数组nums1、nums2👉dp[i][j] 表示以nums1[?]结尾、以nums2[?]结尾...
递推公式：
- 搞清楚前一个状态是什么
- 根据题意，确定当前状态是直接赋值还是取max / min
初始化：如果[0]无意义，通过递推公式倒推一个合法值
遍历顺序：外层/内层可否交换？每一层如何遍历？（从递推公式入手，看状态间依赖关系）
返回结果：有别于打家劫舍、股票问题，可能出现在任意下标，计算dp数组时顺便记录 result