Leetcode5. 最长回文子串 (Python3测试通过) - 马拉车算法通俗讲解

一、题目描述

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

1. 示例 1：

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

2. 示例 2：

   输入：s = “cbbd”
   输出：“bb”

• 提示：
  • 1 <= s.length <= 1000
  • s 仅由数字和英文字母组成

二、解决思路和代码

解法一：暴力解决法

思路

遍历每个字符，找出每个字符对应的回文子串，返回最长的回文串。

• 回文串的长度有两种情况：
  • 奇数：bab
  • 偶数：baab

代码

class Solution:
    def ithPalindrome(self, s:str, left:int, right:int) -> str:
        while left>=0 and right<len(s) and s[left]==s[right]:
            left-=1
            right+=1
        return s[left+1, right]

    def longestPalindrome(self, s: str) -> str:
        if len(s)==1: return s
        res = ''
        for i in range(len(s)):
            stri1 = self.ithPalindrome(s, i, i)
            stri2 = self.ithPalindrome(s, i, i+1)
            stri  = stri1 if len(stri1)>len(stri2) else stri2
            if len(stri)>len(res): res = stri
        return res

Leetcode提交测试超时…

解法二：马拉车算法

思路

1. 将字符串中的偶回文（比如 bccb）和奇回文（比如 bcacb）处理为奇回文。具体做法：

   1. 在字符串的首尾和每个字符中间插入 #，将回文串变为奇回文；
   2. 在奇回文的首部和尾部添加不同的字符，比如：$ 和 *。这两个字符与字符串中的其他字符不同，在中心扩展寻找回文的时候会自动退出循环，不需每次判断是否越界。
      

2. 利用回文串对称的特性，修改内部循环的起始位置，以减少内部循环遍历的次数。那怎么修改内部循环的起始位置呢？借助一个数组 P 记录以当前字符为中心的回文串半径的长度。如何利用回文串的对称性求 P[i] ？这里以下面的字符串，求P[8]为例：

   

   • (1) 如果使用解法一的方法（暴力循环）

     ## 相当于从 P[8]=0 开始更新
     left = right = 8
     while left>=0 and right<len(s) and s[left]==s[right]:
         left-=1
         right+=1
     P[i] = right - i
     

   • (2) 利用回文串的对称性求P[i]

     • 定义两个变量：C-回文串的中心，R-回文串右侧半径位置。由于P[i]记录的是以第i个字符为中心的回文串半径的长度，所以R=i+P[i]

       

     • 如何利用回文串的对称性？来观察一下 回文串 以及 P ，我们发现：

       (1) 对于 字符串 s ，s[C]两侧的字符是对称相等的
       (2) 对于 P ， P[C]两侧的数值是对称相等的
       (3) 对于位于 s[C] 右侧的字符，即 i>C 时，i+P[i]<=R

       

       • 再回到上面问题中，求P[8]？

         • 首先，利用对称性找到 i 的对称位置 i_mirror，其中 i_mirror=2*C-i

           

         • 确定 P[i]。根据下面例子，考虑一下能不能直接将 p[i]=P[i_mirror]？

           

           ## 相当于从 P[8]=3 开始更新
           i = 8             ## right = 8
           i_mirror = 2*C-i  ## left = 4
           if i_mirror>=0 and R>i:
               P[i] = min(P[i_mirror], R-i)
           while s[i+1+P[i]]==s[i-1-P[i]]:
               P[i]+=1
           

     • C 和 R 什么时候更新？

       • 当求出的 P[i] 的右边界大于当前的 R 时，就需要更新 C 和 R 为当前的回文串。因为我们必须保证 i 在 R 里面。

         if i+P[i]>R:
             C = i
             R = i + P[i]
         

代码

class Solution:
    def longestPalindrome(self, s: str) -> str:

        if len(s)==1: return s

        stri = '$#'
        for ss in s: 
            stri = stri + ss + '#'
        stri += '*'

        P = [0]*len(stri)
        C, R = 0, 0
        for i in range(1, len(stri)-1):
            i_mirror = 2*C - i
            if i_mirror>=0 and R>i:
                P[i] = min(P[i_mirror], R-i)
                
            while stri[i+1+P[i]]==stri[i-1-P[i]]:
                P[i]+=1

            if i+P[i]>R:
                C = i
                R = i + P[i]
        
        c, length = P.index(max(P)), max(P)
        start = (c-length)//2
        return s[start:start+length]