11-19子序列系列

11-19 P300最长递增子序列

题目描述

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

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

题解

动态规划。dp[i]表示以nums[i]结尾的最长递增子序列

代码

var lengthOfLIS = function(nums) {
    const n = nums.length
    const dp = new Array(n).fill(1)
    dp[0] = 1
    let res = 1
    for(let i = 1;i<n;i++){
        for(let j = 0;j<i;j++){
            if(nums[j]<nums[i]){
               dp[i] =Math.max(dp[j]+1,dp[i])
            }                               
        }
        if(dp[i]>res)  res = dp[i]
    }
    return res
};

11-19 674. 最长连续递增序列

题目描述

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

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

题解

动态规划

代码

var findLengthOfLCIS = function(nums) {
    const dp = new Array()
    const n  = nums.length
    dp[0] = 1
    let res = 1
    for(let i = 0;i<n;i++){
        if(nums[i-1]<nums[i]){
            dp[i] = dp[i-1] + 1
        }else{
            dp[i] = 1
        }
        if(dp[i]>res) res = dp[i]
    }
    return res
    
};

718. 最长重复子数组

题目描述

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

题解

动态规划。画一个大表格，即表示二维数组。

代码

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number}
 */
var findLength = function(nums1, nums2) {
    const n1 = nums1.length
    const n2 = nums2.length
    let res = 0
    const dp = new Array(n1+1).fill(0).map(x=>new Array(n2+1).fill(0))
    for(let i = 1;i<=n1;i++){
        for(let j = 1;j<=n2;j++){
            if(nums1[i-1] === nums2[j-1]){
                dp[i][j] = dp[i-1][j-1] + 1
            }
            if(dp[i][j]>res) res = dp[i][j]
        }
    }
    return res
};

1143. 最长公共子序列

题目描述

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

• 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

题解

动态规划

代码

/**
 * @param {string} text1
 * @param {string} text2
 * @return {number}
 */
var longestCommonSubsequence = function(text1, text2) {
    const n1 = text1.length
    const n2 = text2.length
    const dp = new Array(n1+1).fill(0).map(x=>new Array(n2+1).fill(0))
    for(let i = 1;i<=n1;i++){
        for(let j = 1;j<=n2;j++){
            if(text1[i-1]===text2[j-1]){
                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[n1][n2]
};