2021-10-08

回文子串/最长回文子串 LeetCode JS实现

本文是对【代码随想录】动态规划部分的转载。

回文子串 题目描述

点这里做题
给定⼀个字符串，你的任务是计算这个字符串中有多少个回⽂⼦串。
具有不同开始位置或结束位置的⼦串，即使是由相同的字符组成，也会被视作不同的⼦串。
示例 1：
输⼊：“abc”
输出：3
解释：三个回⽂⼦串: “a”, “b”, “c”
示例 2：
输⼊：“aaa”
输出：6
解释：6个回⽂⼦串: “a”, “a”, “a”, “aa”, “aa”, “aaa”
提示：
输⼊的字符串⻓度不会超过 1000

解题思路

动态规划五部曲：
1.确定dp数组（dp table）以及下标的含义：
布尔类型的dp[i][j]:表示区间范围i,j的子串是否是回文串，如果是dp[i][j]为true 否则为false
2. 确定递推公式
在确定递推公式时，就要分析如下⼏种情况。
整体上是两种，就是s[i]与s[j]相等，s[i]与s[j]不相等这两种。
当s[i]与s[j]不相等，那没啥好说的了，dp[i][j]⼀定是false。
当s[i]与s[j]相等时，这就复杂⼀些了，有如下三种情况
情况⼀：下标i 与 j相同，同⼀个字符例如a，当然是回⽂⼦串
情况⼆：下标i 与 j相差为1，例如aa，也是⽂⼦串
情况三：下标：i 与 j相差⼤于1的时候，例如cabac，此时s[i]与s[j]已经相同了，我们看i到j区间是
不是回⽂⼦串就看aba是不是回⽂就可以了，那么aba的区间就是 i+1 与 j-1区间，这个区间是不是
回⽂就看dp[i + 1][j - 1]是否为true。
以上三种情况分析完了，那么递归公式如下：

if(s[i]==s[j]){
    if(j-i<=1){ //情况一 和 情况二
      res++ //res是统计回文子串的数量
      dp[i][j] = true
    }else if(dp[i+1][j-1]){ //情况三
      res++
      dp[i][j] = true
    }
  }

3. dp数组如何初始化
   dp[i][j]可以初始化为true么？ 当然不⾏，怎能刚开始就全都匹配上了。所以dp[i][j]初始化为false。
4. 确定遍历顺序
   遍历顺序可有有点讲究了。
   ⾸先从递推公式中可以看出，情况三是根据dp[i + 1][j - 1]是否为true，在对dp[i][j]进⾏赋值true的。
   dp[i + 1][j - 1] 在 dp[i][j]的左下⻆，如图：
   
   如果这矩阵是从上到下，从左到右遍历，那么会⽤到没有计算过的dp[i + 1][j - 1]，也就是根据不确定是
   不是回⽂的区间[i+1,j-1]，来判断了[i,j]是不是回⽂，那结果⼀定是不对的。
   所以⼀定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。
   有的代码实现是优先遍历列，然后遍历⾏，其实也是⼀个道理，都是为了保证dp[i + 1][j - 1]都是经过计
   算的。
   代码如下：

for(let i=s.length-1;i>=0;i--){
    for(let j=i; j<s.length;j++){
      if(s[i]==s[j]){
        if(j-i<=1){ //情况一 和 情况二
          res++
          dp[i][j] = true
        }else if(dp[i+1][j-1]){ //情况三
          res++
          dp[i][j] = true
        }
      }
    }
  }

5. 举例推导dp数组
   举例，输⼊：“aaa”，dp[i][j]状态如下：
   [[true, true, true],
   [false, true, true],
   [false, false, true]]
   矩阵中有6个true，所以就有6个回文子串
   注意因为dp[i][j] 的定义，所以j一定是大于等于i的，那么在填充dp[i][j]的时候一定是只填充右上半部分
   分析完毕，附上js代码：

var Palindrome = function(s) {
  var dp = new Array(s.length).fill(false)
  for(let i = 0;i<s.length;i++){
    dp[i] = new Array(s.length).fill(false)
  }
  var res = 0
  for(let i=s.length-1;i>=0;i--){
    for(let j=i; j<s.length;j++){
      if(s[i]==s[j]){
        if(j-i<=1){ //情况一 和 情况二
          res++
          dp[i][j] = true
        }else if(dp[i+1][j-1]){ //情况三
          res++
          dp[i][j] = true
        }
      }
    }
  }
  return res
};

最长回文子串 题目描述

点这里做题
给你一个字符串 s，找到 s 中最长的回文子串。
示例 1：
输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。

示例 2：
输入：s = “cbbd”
输出：“bb”

示例 3：
输入：s = “a”
输出：“a”

示例 4：
输入：s = “ac”
输出：“a”

解题思路

这题和回文子串的区别就是，需要找到最长的回文子串，那我用一个maxRes来记录最长回文子串的长度，用flagl来记录最长回文子串在字符串的起始位置，flagr来记录最长回文子串咋字符串的最终位置。
分析完毕，代码如下：

var longestPalindrome = function(s) {
      // 初始化dp数组
      var dp = new Array(s.length).fill(false)
      for (let i=0;i<s.length;i++){
        dp[i] = new Array(s.length).fill(false)
      }
      var res = 0,maxRes = 0, flagl = 0, flagr = 0
      // 遍历数组
      for(let i=s.length-1;i>=0;i--){
        for(let j=i;j<s.length;j++){
          if(s[i] == s[j]){
            if(i-j<=1){
              res = j-i+1
              dp[i][j] = true
            }else if(dp[i+1][j-1]){
              res = j-i+1
              dp[i][j] = true
            }
          }
          if(res > maxRes){
            maxRes = res
            flagl = i
            flagr = j
          }
        }
      }
      console.log(dp)
      return s.slice(flagl,flagr+1)
    };

注意：虽然我们用 flagl 和 flagr 记录了最长子串的起始和结束位置，但是slice（）函数的第二个参数是指定结束选择的位置，输出的子串并不包含s[falgr]字符，所以需要+1。