子序列问题总和(连续+非连续)_连续子序列是什么意思

一、子序列(不连续)

300. 最长递增子序列

题目链接
假设我们已经知道了 dp[0…4] 的所有结果，我们如何通过这些已知结果推出 dp[5] 呢？
nums[5] = 3，既然是递增子序列，我们只要找到前面那些结尾比 3 小的子序列，然后把 3 接到最后，就可以形成一个新的递增子序列，而且这个新的子序列长度加一

var lengthOfLIS = function(nums) {
    const n = nums.length
    // dp[i]代表0~i且以i结尾的数组最长递增子序列的长度，初始化的时候，长度均为为1，即本身。
    const dp = new Array(n).fill(1);
    
    // 遍历数组，对于每个位置都要去寻找最长递增子序列
    for(let i=1; i<n; i++){
        // 向前找比i小的数字j，比较j的最长递增子序列+1 和 i本身的大小
        // 由于不要求连续，所以可以比较往前所有比i小的，拿到最大的即可
        for(let j=0;j<i;j++){
            if(nums[i] > nums[j]){
                // 更新数组的值
                dp[i] = Math.max(dp[i],dp[j]+1);
            }
        }
    }
    // 子序列是不连续的，不需要包括最后一个数字的，所以取dp数组中的最大
    return Math.max(...dp);  
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1143. 最长公共子序列

题目链接

1、二维dp数组

dp[i][j]的含义是第一个字符串前i个字符和第二个字符串前j个字符的最大公共子序列
（i , j用来遍历两个字符串的指针）

2、状态转移方程

3、状态的初始化

4、遍历过程

dp[i][j] 依赖与 dp[i - 1][j - 1] , dp[i - 1][j], dp[i][j - 1]，所以 i 和 j 的遍历顺序肯定是从小到大的。

5、举例理解

var longestCommonSubsequence = function(text1, text2) {
    const m = text1.length, n = text2.length;
    // 1、dp[i][j]表示第一个字符串前i个字符和第二个字符串前j个字符的最长公共子序列长度
    // 初始化公共子序列均为0，dp[0][0]表示空字符串，所以需要从dp[1][1]开始更新
    const dp = new Array(m+1).fill().map(() => new Array(n+1).fill(0))

    for(let i=1; i<=m; i++){
        for(let j=1; j<=n; j++){
            // 拿到两个字符串的最后一个字符
            let c1 = text1[i-1], c2 = text2[j-1]
            // 最后一个字符相等,就是之前相等的字符 + 1
            if(c1 == c2){
                dp[i][j] = dp[i-1][j-1] + 1
            }else{
                // 不相等
                dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1])
            }
        }
    }
    return dp[m][n]
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

二、子序列(连续)

连续子序列就相当于数组，所以定义 dp[i] 的时候是包括 i 在内的序列。并且最后的结果不是最后一个，而是选择dp数组中最大的。

674. 最长连续递增序列

var findLengthOfLCIS = function(nums) {
    const n = nums.length
    // dp[i]表示在0~i下标的数组包括i的连续递增子序列(数组)的长度,初始长度都是本身
    const dp = new Array(n).fill(1)

    for(let i=1;i<n;i++){
        // 大于前一个，就是递增
        if(nums[i]>nums[i-1]){
            dp[i] = Math.max(dp[i],dp[i-1]+1)
        }else{
            // 小于前一个，就是递减。此时包括它本身的连续递增子序列就是自己
            dp[i] = 1
        }
    }
    // 拿到最大的数值,一维数组可以这么用，二维不可以
    return Math.max(...dp)
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

718. 最长重复子数组

var findLength = function(nums1, nums2) {
    // dp[i][j]为第一个数组的前i项包括i的子数组 和 第二个数组的前j项包括j的子数组的最长公共长度
    const m = nums1.length, n = nums2.length;
    const dp = new Array(m+1).fill().map(() => new Array(n+1).fill(0))

    // 最大长度
    let res = 0
    for(let i=1; i<=m; i++){
        for(let j=1; j<=n; j++){
             // 拿到两个子数组的最后一个项
            let c1 = nums1[i-1], c2 = nums2[j-1]
            // 相等的话，可以考虑前面的，加上相等的这一项
            // 不相等的话，由于子数组必须包括这项，所以相当于为0，即不存在重复子数组
            if(c1 == c2){
                dp[i][j] = dp[i-1][j-1] + 1
                // 此时的最大长度就是dp[i][j]和res的最大值
                // 最长重复子数组以哪一项结尾都有可能
                res = Math.max(res,dp[i][j])
            }
        }
    }
    return res
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

53. 最大连续子数组和

思路和674差不多，一个是看连续子数组的长度，一个是看它们的和。都是把前面的状态加上自身 和 自身比，从而更新自身的状态。

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSubArray = function(nums) {
    const n = nums.length
    // dp[i]为0~i下标的数组包括i在内的最大子数组和
    const dp = new Array(n)

    // 初始化，最大的和就是本身
    dp[0] = nums[0]

    for(let i=1; i<n; i++){
        // 以i结尾包括i在内的最大和
        dp[i] = Math.max(nums[i],dp[i-1]+nums[i])
    }
    // 返回最大的即可
    return Math.max(...dp)
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19