Python版[leetcode]5. 最长回文子串（难度中等）

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2：

输入: "cbbd"
输出: "bb"

先贴一个我自己写的超出时间限制的算法：

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if len(s) <= 1:
            return s
        elif len(s) == 2 and s[0] != s[1]:
            return s[0]
        res = s[0]
        for i in range(len(s)):
            if i == 0:
                continue
            for j in range(i+1):
                
                if i-j<0 or i+j >len(s)-1:
                    continue
                # print(i,j)
                if j!=0 and s[i-j:i] == s[i+1:i+j+1][::-1]:
                    if len(res)<len(s[i-j:i+j+1]):
                        res = s[i-j:i+j+1]
                        # print(res)
                # print('left '+s[i-j:i+1],'right '+s[i+1:i+j+2][::-1])
                if i+j+1 < len(s)-1 and s[i-j:i+1] == s[i+1:i+j+2][::-1]:
                    if len(res)<len(s[i-j:i+j+2]):
                        res = s[i-j:i+j+2]
                        # print(res)
                # print('left '+s[i-j-1:i],'right '+s[i:i+j+1][::-1])
                if i-j-1 >=0 and s[i-j-1:i] == s[i:i+j+1][::-1]:
                    if len(res)<len(s[i-j-1:i+j+1]):
                        res = s[i-j-1:i+j+1]
                        # print(res)
        return res

时间复杂度O(n²)，因为用了2层循环，主要思路是遍历字符串，然后判断它的前后字符串是否镜像

 

官方推荐了2种方法：

动态规划

为了改进暴力法，我们首先观察如何避免在验证回文时进行不必要的重复计算。考虑 “ababa” 这个示例。如果我们已经知道 “bab” 是回文，那么很明显，“ababa” 一定是回文，因为它的左首字母和右尾字母是相同的。

我们给出 P(i,j)P(i,j) 的定义如下：

 

这产生了一个直观的动态规划解法，我们首先初始化一字母和二字母的回文，然后找到所有三字母回文，并依此类推…

复杂度分析

时间复杂度：O(n^2)，这里给出我们的运行时间复杂度为 O(n^2)。

空间复杂度：O(n^2)，该方法使用 O(n^2)的空间来存储表。

中心扩展算法

事实上，只需使用恒定的空间，我们就可以在 O(n^2)的时间内解决这个问题。

我们观察到回文中心的两侧互为镜像。因此，回文可以从它的中心展开，并且只有 2n −1 个这样的中心。

你可能会问，为什么会是 2n −1 个，而不是 n 个中心？原因在于所含字母数为偶数的回文的中心可以处于两字母之间（例如 “abba” 的中心在两个 ‘b’ 之间）。

class Solution:
    # 动态规划法-中心扩散法Spread From Center
    def longestPalindrome(self, s: str) -> str:
        if s==s[::-1]:
            return s
        res = s[:1]
        for i in range(len(s)):
            palindrome_odd= self.spread(s,i, i)
            palindrome_even= self.spread(s,i, i + 1)
            # 当前找到的最长回文子串
            res = max(palindrome_odd,palindrome_even,res,key=len)
        return res

#中心扩散法Spread From Center
    def spread(self, s, left, right):
        """
        left = right 的时候，此时回文中心是一条线，回文串的长度是奇数
        right = left + 1 的时候，此时回文中心是任意一个字符，回文串的长度是偶数
        """

        while left >= 0 and right < len(s) and s[left] == s[right]:
            left -= 1
            right += 1
        return s[left + 1:right]