算法_最长回文子串/子序列

类型一：最长回文子串——连续

核心思路：中心扩展法寻找以当前位置作为中心时的最长回文子串

注意点：中心扩展法有两种情况，回文子串总长度为奇数还是偶数，决定中心扩展的起点情况

      // 最长回文子串(连续的)——中心扩展法
      function longestPalindrome(s) {
        const LEN = s.length;
        // 特例
        if (LEN < 2) return s;


        function extend(s, left, right) {
          while (left >= 0 && right < LEN && s[left] === s[right]) {
            left--;
            right++;
          }
          // 也可以直接返回子串，这样就会多slice一次字符串
          // 返回扩展后的最大长度
          return right - left - 1;
        }


        let start = (end = 0);
        for (let i = 0; i < LEN; i++) {
          // 奇数/偶数长度
          let len = Math.max(extend(s, i, i), extend(s, i, i + 1));
          if (len > end - start + 1) {
            start = i - Math.floor((len - 1) / 2);
            end = i + Math.floor(len / 2);
          }
        }
        return s.slice(start, end + 1);
      }

类型二：最长回文子序列——不连续

与类型一不同的是这里的回文子序列可以是不连续的，即从输入的字符串中挑选字符按顺序 组成回文子序列。只需要返回最长子序列长度。

核心思路：二维动态规划数组

第一步：确定动态规划数组元素含义，dp[ i ][ j ] 表示字符串 i 到 j 之间最长回文子序列的长度（题目要求的）

第二步：确定初始值，dp[ i ][ i ] = 1 ; 其余为0

第三步：确定递推公式

if (s[l] === s[r]) {
    dp[i][j] = dp[i + 1][j - 1] + 2;
} else {
    // 首尾不同，取去头去尾的最大值
    dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
}

 上代码：

      // 最长回文子序列——动态规划
      function longestPalindromeSubseq(s) {
        const LEN = s.length;
        if (LEN < 2) return s;

        // dp[i][j]表示字符串i到j之间最长回文子序列的长度
        // 初始化
        const dp = [];
        for (let i = 0; i < LEN; i++) {
          dp[i] = new Array(LEN).fill(0);
          dp[i][i] = 1;
        }

        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 + 1][j], dp[i][j - 1]);
            }
          }
        }
        return dp[0][LEN - 1];
      }


      console.log(longestPalindromeSubseq("bbbab"));  //4-'bbbb'