【综合篇】Leetcode：5. 最长回文子串｜刷题打卡

前言

前面学习了数组、栈、链表、哈希表、二叉树、图、并查集等数据结构和递归、二叉树遍历（前/中/后）、二分查找、DFS、BFS、动态规划、贪心算法、位运算。前面9天刷的算法题，先做个回顾，来看看其每道题涉及的知识点：

• 【刷穿leetcode】1. 两数之和｜刷题打卡 - 数组、哈希表
• 【刷穿leetcode】20. 有效的括号｜刷题打卡 - 栈
• 【刷穿leetcode】141. 环形链表｜刷题打卡 - 链表、哈希表、快慢指针
• 【刷穿leetcode】98. 验证二叉搜索树｜刷题打卡 - 二叉树、递归、二叉树的中序遍历
• 【刷穿leetcode】70. 爬楼梯｜刷题打卡 - 动态规划
• 【刷穿leetcode】322. 零钱兑换｜刷题打卡 - 动态规划、贪心算法
• 【刷穿leetcode】441. 排列硬币｜刷题打卡 - 二分查找
• 【刷穿leetcode】200. 岛屿数量｜刷题打卡 - 深度优先搜索DFS、广度优先搜索BFS、并查集
• 【刷穿leetcode】191. 位1的个数｜刷题打卡 - 位运算、移位运算

好了，回顾完上述的知识点，我们继续来做题吧，今天刷道综合题，巩固学过的算法知识！！！

一、题目描述：

这是leetcode第5题：最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

示例 2：

输入：s = "cbbd"
输出："bb"

示例 3：

输入：s = "a"
输出："a"

示例 4：

输入：s = "ac"
输出："a"

难度：中等

二、思路分析：

解法1：暴力枚举

我们能想到最直接的方法就是暴力枚举。

• 先获取输入字符串的长度，针对length=0、length=1的字符串单独处理，length>1的字符串进行以下步骤的操作。
• 枚举所有长度大于1的子串，依次判断其字符串是否是对称的回文子串。
• 在具体实现时，可以只针对大于”当前得到的最长回文子串长度“的子串进行”回文验证“。
• 最后将截取的最长回文子串返回即可。

复杂度分析：

• 时间复杂度：O(n^3)，这里 n 为字符串的长度，2次for循环组合子串，再加上字符串截取，总共n^3的时间复杂度。
• 空间复杂度：O(1)，只用到常数个临时变量。

解法2：动态规划

对于暴力解法的时间复杂度为O(n^3)，执行效率过低，我们可以寻找更优的解法降低时间复杂度。一个回文去掉两头以后，剩下的部分依然是回文，具有一个问题可以拆分成多个子问题的特点，因此可以采用动态规划。
解题思路，可以从去掉两头判断是否是回文串下手：

• 如果一个字符串的头尾2个字符都不相等，那么这个字符串一定不是回文串
• 如果一个字符串的头尾2个字符相等，才有必要继续判断下去。
  • 如果里面的子串是回文，整体就是回文串；
  • 如果里面的子串不是回文，整体就不是回文串。

第1步：定义dp状态

dp[i][j] ：字符串s从索引i到j的子串是否是回文子串

• true：s[i][j] 是回文串
• false：s[i][j] 不是回文串

第2步：定义dp转移方程

dp[i][j] = dp[i+1][j-1] && s[i] == s[j]

• s[i] == s[j]：说明当前中心可以继续扩展
• dp[i+1][j-1]：true
  • 说明s[i,j]的子串s[i+1][j-1]也是回文串
  • 其中，i是从最大下标开始遍历的，j是从最小下标开始遍历的
• 边界特殊情况：
  • j-i < 2, 意即子串是一个长度为0或1的回文串

第3步：综合dp方程和边界判断

dp[i][j] = s[i] == s[j] && ( dp[i+1][j-1] || j - i < 2)

复杂度分析：

• 时间复杂度：O(n^2)，其中 n 是字符串的长度。动态规划的状态总数为 O(n^2)，对于每个状态，我们需要转移的时间为 O(1)。
• 空间复杂度：O(n^2)，即存储动态规划状态所需要的空间。

解法3：中心扩展算法

回文子串的枚举可以从两边开始，也可以从中心位置开始，因此我们有了第3种解法，中心扩展法。 解题思路，是从回文串一定是对称的特点下手：

• 枚举所有可能的回文串的中心位置
  • 中心位置可能是一个字符（奇数字符），也可能是相邻的两个字符（偶数字符），如图所示：
  • 所以中心位置有2种组合：left：i，right：i和left：i，right：i+1。
• 记录最长回文子串的相关变量，最后截取最长回文子串返回即可。

复杂度分析：

• 时间复杂度：O(n^2)，其中 n 是字符串的长度。枚举中心位置的个数是 2(n-1)，即枚举中心位置的时间复杂度为 O(n)，向中心位置扩散得到回文子串的时间复杂度为O(n)，因此总的时间复杂度为O(n^2)。
• 空间复杂度：O(1)，只用到常数个临时变量。

解法4：Manacher 算法

Manacher 算法，翻译过来叫马拉车算法，它可以将时间复杂度降到线性级别O(n)。主要是对字符串做了预处理，使用 # 将原始奇偶数字符隔开，统一成奇数字符串，如图所示： 预处理后的字符串还是通过上述中心扩展算法进行求解回文子串。

复杂度分析

• 时间复杂度：O(n)，其中 n 是字符串的长度。由于对于每个位置，扩展要么从当前的最右侧臂长 right 开始，要么只会进行一步，而 right 最多向前走 O(n) 步，因此算法的复杂度为 O(n)。
• 空间复杂度：O(n)，创建了p数组用来记录每个位置的臂长。

三、AC 代码：

暴力枚举的代码

var longestPalindrome = function(s) {
  var ans = '';
  var max = 0;
  var len = s.length;
  if(len == 0) return '';// 字符串为空则返回空
  if(len == 1) return s;// 字符串为一个字符，返回它本身
  for(var i = 0;i<len;i++){
      for(var r = i+1;r<=len;r++){
          var tmpStr = s.substring(i,r)
          if(isPalindrome(tmpStr) && tmpStr.length > max){
              ans = s.substring(i,r)
              max = tmpStr.length;
          }
      }
  }
  return ans;
};
function isPalindrome(str) {
  var len  = str.length
  var middle = parseInt(len/2)
  for(var i = 0;i<middle;i++){
      if(str[i]!=str[len-i-1]){
          return false;
      }
  }
  return true;
}

动态规划的代码

var longestPalindrome = function(s) {
  let n = s.length;
  if (n === 0) return "";

  let res = '';
  let dp = Array.from(new Array(n),() => new Array(n).fill(0));
  // 倒着遍历简化操作， 这么做的原因是dp[i][..]依赖于dp[i + 1][..]
  for(let i = n-1;i >= 0;i--){
      for(let j = i;j < n;j++){
          dp[i][j] = s[i] == s[j] && (j - i < 2 || dp[i+1][j-1]);
          if(dp[i][j] && j - i +1 > res.length){
              res = s.substring(i,j+1);
          }
      }
  }
  return res;
}

中心扩展算法的代码

var longestPalindrome = function(s) {
  if(!s || s.length < 2){
      return s;
  }
  let start = 0,end = 0;
  let n = s.length;
  // 中心扩展法
  let centerExpend = (left,right) => {
      while(left >= 0 && right < n && s[left] == s[right]){
          left--;
          right++;
      }
      return right - left - 1;
  }
  for(let i = 0;i < n;i++){
      let len1 = centerExpend(i,i);
      let len2 = centerExpend(i,i+1);
      // 两种组合取最大回文串的长度
      let maxLen = Math.max(len1,len2);
      if(maxLen > end - start){
          // 更新最大回文串的首尾字符索引
          start = i - ((maxLen - 1) >> 1);
          end = i + (maxLen >> 1);
      }
  }
  return s.substring(start, end+1);
};

Manacher 算法的代码

var longestPalindrome = function(s) {
  if(!s || s.length < 2){
      return s;
  }
  var s_f = '#'+s.split('').join('#')+'#';
  let c = 0,R = 0;
  var t_len = s_f.length;
  var maxLen = 0;
  var maxIndex = 0;
  var originIndex = 0;
  var p = new Array(t_len);
  p[0] = 0;
  for(var i = 1;i<t_len-1;i++){
      var j = 2*c-i;
      if(i<R){
          p[i] = Math.min(p[j],R-i)
      }else{
          p[i] = 0;
      }
      var left = i-p[i]-1;
      var right = i+p[i]+1;
      while(left>=0 && right<t_len && s_f[left]==s_f[right]){
          left--;
          right++;
          p[i]++;
      }
      if(i+p[i]>R){
          c = i;
          R = i+p[i];
      }
      if(p[i]>maxLen){
          maxLen = p[i];
          maxIndex = i;
          originIndex = parseInt((i-p[i])/2)
      }
  } 
  return s.substring(originIndex,originIndex + maxLen);
};

四、总结：

上述对最长回文子串的4种求解方法，将时间复杂度从三次方降到了一次。一步步优化时间复杂度的感觉，真是妙哉！其中的动态规划解法，通过观察数组的利用情况，从而降低了空间复杂度。而 Manacher 算法对回文串对称性的充分利用，不得不让人叹服！

本文正在参与「掘金 3 月闯关活动」，点击查看活动详情