子序列问题笔记——代码随想录学习(一）

图片来源：代码随想录https://leetcode-cn.com/problems/longest-palindromic-subsequence/solution/516-zui-chang-hui-wen-zi-xu-lie-dong-tai-hap0/

##「代码随想录」带你学透DP子序列问题！516. 最长回文子序列【动态规划】详解

子序列

最长递增子序列 （不连续）

var lengthOfLIS = function (nums) {
    const len = nums.length;
    let dp = new Array(len).fill(1);
    for (let i = 1; i < len; i++) {
        for (let j = 0; j < i; j++) {
            if (nums[i] > nums[j]) {
                dp[i] = Math.max(dp[i], dp[j] + 1);
            }
        }
    }
    return Math.max.apply(null, dp);
};
let arr = [1, 3, 6, 7, 9, 4, 10, 5, 6];
lengthOfLIS(arr)

最长连续递增序列 （连续）

var findLengthOfLCIS = function(nums) {
    // dp[i] 表示以 i结尾最长连续递增序列的长度
    // base case dp[0] = 1
    // dp[i] = dp[i-1]+1 如果 nums[i-1]>nums[i]
    const dp = new Array(nums.length).fill(1);
    for(let i =1;i<nums.length;i++){
        if(nums[i-1]<nums[i]){
            dp[i]=dp[i-1]+1;
        }
    }
    return Math.max.apply(null,dp);
};

最长递增子序列的个数 （不连续）

定义dp:
length[i]以i结尾的最长递增序列的长度
count[i]以i结尾的最长递增序列的个数
初始值：
默认length[i] 最长长度，长度就是它自己,长度为1
默认count[i] 最长个数，个数默认1

   const len = nums.length;
    let length = new Array(len).fill(1); // length[i]以i结尾的最长递增序列的长度
    let count = new Array(len).fill(1); // count[i]以i结尾的最长递增序列的个数
    maxFun = () => {
        const max = 0;
        for (let i = 1; i < len; i++) {

            for (let j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    if (length[j] >= length[i]) {  // 前一个最大长度大于等于目标位置长度
                        length[i] = length[j] + 1;
                        count[i] = count[j];
                    } else if (length[j] + 1 == length[i]) {
                        count[i] += count[j];
                    }
                }
            }
        }
        return Math.max.apply(null, length)
    }
    let Maxlen = maxFun(nums), rs = 0;
    for (let i = 0, j = 0; i < length.length; i++) {
        if (length[i] == Maxlen) {
            rs += count[i];
        }
    }
    return rs

最长重复子数组 （连续）

var findLength = function(nums1, nums2) {
    const len1 = nums1.length, len2 = nums2.length;
    let dp = new Array(len1), max = 0;
    for (let i = 0; i < len1; i++) {
        dp[i] = new Array(len2).fill(0);
    }
    for (let i = 0; i < len1; i++) {
        for (let j = 0; j < len2; j++) {
            if (nums1[i] == nums2[j]) {
                if (i == 0 || j == 0) {
                    dp[i][j] = 1;
                } else {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                if (dp[i][j] > max) {
                    max = dp[i][j]
                }
            }
        }
    }
    return max;
};

最长公共子序列 （不连续）

var longestCommonSubsequence = function(text1, text2) {
        let dp = new Array(text1.length+1);
        for(let i=0;i<dp.length;i++){
            dp[i] = new Array(text2.length+1).fill(0);
        }
        for(let i=1;i<text1.length+1;i++){
            for(let j=1;j<text2.length+1;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[text1.length][text2.length]
};

不相交的线

实质是最长公共子序列 ，这是它的变式 （注意变式考法）

---

回文

回文子串 （回文连续）

// 动态规划 O(N^2)+O(N^2)
var countSubstrings = function (s) {
    const len = s.length;
    let rs = 0;
    const dp = new Array(len);
    for (let i = 0; i < dp.length; i++) {
        dp[i] = new Array(len).fill(false);
    }
    for (let j = 0; j < len; j++) { // 从上往下,从左往右
        for (let i = 0; i <= j; i++) {
            if (s[i] === s[j]) {
                if (j - i < 2) {    // 单个字母或者两个相同字母时
                    dp[i][j] = true;
                    rs++;
                } else if (dp[i + 1][j - 1]) { // 三个以上是回文字符串
                    dp[i][j] = true
                    rs++;
                }
            }
        }
    }
    return rs;
};

// 二分法 中心扩散 (数组中 每个元素就是一个中心(可以是一个元素,也可以是两个相同元素))
// O(N^2)+O(1)
var countSubstrings2 = function (s) {
    let rs = 0;
    // 已s的每一个元素为中心;
    for (let i = 0; i < s.length; i++) {
        rs += extend(i, i, s);           // 选择一个中心
        rs += extend(i, i + 1, s);       // 选择两个中心
    }
    function extend(i, j, s) {       // 已中心朝外扩散,看有多少个回文串。
        let res = 0;
        while (i >= 0 && j < s.length && s[i] == s[j]) {
            i--;
            j++;
            res++;
        }
        return res;
    }
    return rs;
};

最长回文子串 （回文连续）

var longestPalindrome = function (s) {
    const len = s.length;
    let max = 0, rs = "";
    const dp = new Array(len);
    for (let i = 0; i < len; i++) {
        dp[i] = new Array(len).fill(false);
    }
    for (let j = 0; j < len; j++) {
        for (let i = 0; i <= j; i++) {
            if (s[i] == s[j]) {
                if (j - i < 2) {    // 等于长度1或2的回文串
                    dp[i][j] = true;
                } else if (dp[i + 1][j - 1]) { // 长度为3的回文串
                    dp[i][j] = true;
                }
                if (dp[i][j] && max < j - i + 1) { //求最值
                    max = j - i + 1;
                    rs = s.slice(i, j + 1);
                }
            }
        }
    }
    return rs;
};
// 双指针 中心扩散
var longestPalindrome1 = function (s) {
    const len = s.length;
    let rs = '', max = 0;
    for (let i = 0; i < len; i++) {
        // 返回当前较长的回文串
        let tmp = Math.max(extend(i, i, s).length, extend(i, i + 1, s).length);
        // 记录给max
        max = max < tmp ? tmp : max;
        // max等于谁,在把结果给谁
        rs = max == extend(i, i, s).length ? extend(i, i, s) : rs
        rs = max == extend(i, i + 1, s).length ? extend(i, i + 1, s) : rs
    }
    function extend(i, j, s) {
        let res = '';
        while (i >= 0 && j < len && s[i] == s[j]) {
            res = s.slice(i, j + 1);
            i--;
            j++;
        }
        return res;
    }
    return rs;
}

最长回文子序列 （回文不连续）

最长回文子序列 ，因为回文串要比较两端的对称性，这里的dp数组应该考虑是二维数组。
s[i,j] 表示以【i，j】为范围的s字符串。dp[i][j] 表示长度范围是s[i,j] 时，最长回文子序列的长度。base case是斜对角线上的单个字母组成的回文串，长度为1。
状态转移方程：
dp[i][j] = dp[i+1][j-1] s[i]==s[j];

dp[i][j] = Math.max(dp[i][j-1],dp[i-1][j]) s[i]!=s[j]

var longestPalindromeSubseq = function(s) {
    const dp = new Array(s.length), len = s.length;
    for (let i = 0; i < len; i++) {
        dp[i] = new Array(len).fill(0);
        dp[i][i] = 1;
    };
    // dp[i][j] = dp[i+1][j-1] s[i]==s[j];
    // dp[i][j] = Math.max(dp[i][j-1],dp[i-1][j]) s[i]!=s[j]
    for (let i = len - 2; i >=0; i--) {
        for (let j = i + 1; j < len; j++) {
            if (s[i] == s[j]) {
                dp[i][j] = dp[i + 1][j - 1] + 2;
            } else {
                dp[i][j] = Math.max(dp[i][j - 1], dp[i+1][j]);
            }
        }
    }
    return dp[0][len-1];
};

---

编辑距离