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

今日内容

300.最长递增子序列

674. 最长连续递增序列

718. 最长重复子数组  

300.最长递增子序列

问题：

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

提示：

• 1 <= nums.length <= 2500
• -104 <= nums[i] <= 104

 进阶：

• 你能将算法的时间复杂度降低到 O(n log(n)) 吗?

思路：动态五部曲

1. dp数组

dp[i]，以nums[i]为结尾的最长递增序列长度

2. 递推公式

推导方向：

dp[i] 是否是 包含dp[j]在内的子序列的末端？

判断条件：nums[i]>nums[j] 

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

3. 初始化：

dp[0到1]：1；

4. 循环遍历：从小到大

代码：

/*
 * @lc app=leetcode.cn id=300 lang=javascript
 *
 * [300] 最长递增子序列
 */

// @lc code=start
/**
 * @param {number[]} nums
 * @return {number}
 */
var lengthOfLIS = function(nums) {
    let dp = new Array(nums.length).fill(1);
    let res = 1;
    for (let i = 1; i < nums.length; i++) {
        for (let j = 0; j <= i; j++) {
            if (nums[i] > nums[j]) dp[i] = Math.max(dp[j] + 1, dp[i])
        }
        if (res < dp[i]) res = dp[i]
    }
    return res;
};

674.最长连续递增序列

问题：

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

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

 提示：

• 1 <= nums.length <= 104
• -109 <= nums[i] <= 109

思路：
这题直接一个for循环，从头到尾遍历，只需要判断nums[i]是否大于nums[i-1]即可

代码：

/*
 * @lc app=leetcode.cn id=674 lang=javascript
 *
 * [674] 最长连续递增序列
 */

// @lc code=start
/**
 * @param {number[]} nums
 * @return {number}
 */
var findLengthOfLCIS = function(nums) {
    let dp = new Array(nums.length).fill(1);
    let res = 1;

    for (let i = 1; i < nums.length; i++) {
        if (nums[i] > nums[i - 1]) dp[i] = Math.max(dp[i - 1] + 1, dp[i])

        if (res < dp[i]) res = dp[i]
    }

    return res;

};

718.最长重复子数组

问题;

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

 提示：

• 1 <= nums1.length, nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 100

思路：

注意：

1. 注意题目中说的子数组，其实就是连续子序列

动态规划：

dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。 （特别注意： “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 ）

2. 递推公式

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

即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;

根据递推公式可以看出，遍历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。

第一列和第一行都没有意义！！！

4. 确定遍历顺序

外层for循环遍历A，内层for循环遍历B。

那又有同学问了，外层for循环遍历B，内层for循环遍历A。不行么？

也行，一样的，我这里就用外层for循环遍历A，内层for循环遍历B了。

同时题目要求长度最长的子数组的长度。所以在遍历的时候顺便把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];
    }
}

5. 举例推导dp数组

 代码：

/*
 * @lc app=leetcode.cn id=718 lang=javascript
 *
 * [718] 最长重复子数组
 */

// @lc code=start
/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number}
 */
var findLength = function(nums1, nums2) {

    let dp = new Array(nums1.length + 1).fill(0).map(() => new Array(nums2.length + 1).fill(0));
    let res = 0;

    // 循环遍历
    for (let i = 1; i <= nums1.length; i++) {
        for (let j = 1; j <= nums2.length; j++) {
            // 遇到A[i - 1] === B[j - 1]，则更新dp数组
            if (nums1[i - 1] === nums2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
            if (res < dp[i][j]) res = dp[i][j]
        }
    }
    return res;
};