leetcode python3 最长回文字串

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

示例 1：

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

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

最长回文字串是典型的dp问题，但是该题有多种实现方式。

首先是暴力法，对每个数组对，均判断是否是回文，并判断是否长度为最长，此时提交结果为超时。

class Solution:
    def longestPalindrome(self, s: str) -> str:
        n = len(s)
        if n == 0 or n == 1:
            return s
        length = 0
        res = s[0]
        for i in range(n-1):
            for j in range(i+1, n):
                start = i
                end = j
                flag = True
                while start < end:
                    if s[start] != s[end]:
                        flag = False
                        break
                    else:
                        start += 1
                        end -= 1
                if flag and j - i + 1 > length:
                    res = s[i:j+1]
                    length = j - i + 1
        return res

然后就是最大众的解法，动态规划。动态规划主要就是分析把大问题分解为小问题，分析状态转移方程，最直观的解法就是初始化一个字母和两个字母的回文情况，更长的则根据非最外两个字母的回文情况来确定，如果中间的是回文且两边元素相等，即为回文。因此可以写出状态转移方程：f(i,j)：s[i]==s[j] i-j<=1； f(i,j)：s[i]==s[j] and f(i+1,j-1) j-i>1，其中：f(i,j)表示s[i:j+1]是否回文串

class Solution:
    def longestPalindrome(self, s: str) -> str:
        # dp
        k = len(s)
        # 先定义dp空间
        dp = [[False for _ in range(k)] for _ in range(k)]
        longestsub = ''
        length = 0
        for i in range(k):
            for j in range(0, i+1): # 此处为j+1是为了处理一个字母的回文
                if i-j < 2:
                    if s[j] == s[i]:
                        dp[j][i] = True
                        if length < i-j+1:
                            length = i-j+1
                            longestsub = s[j:i+1]
                else:
                    if dp[j+1][i-1] and s[j] == s[i]:
                        dp[j][i] = True
                        if length < i-j+1:
                            length = i-j+1
                            longestsub = s[j:i+1]
        return longestsub

面试时可能会加分，马拉车，Manacher算法，是一种线性实现最长子串的算法，题解中有一个大神写的很清楚，这里借用一下。。

class Solution:
    def longestPalindrome(self, s: str) -> str:       
# 马拉车算法
# 先在字符串中间加符号隔开，使得奇偶回文数的形式统一
# 然后用kmp的思想去优化中心扩散
        if len(s)== 0:return ""
        s_new  = '#' + '#'.join(s) + '#'
        #print(s_new)
        
        #已遍历的最大右边界
        mx = 0
        #对应的中心点
        mid = 0  
        
        l = len(s_new)
        # 扩散半径数组，初始值1或者0都可以，只是代表刚开始的时候扩散半径是多少而已
        p = [1]*l
        
        for i in range(l):
            if i<mx:
                # 这个时候可以用已经计算过的值
                # 不能超过已遍历的右边界
                # i对应的镜像 = 2*mid - i
                # 由mx定义可知半径最长不会超过mx-i
                p[i] = min(mx-i,p[2*mid-i])
            
            # 主要的优化已经在上面节省了时间，接下来就是正常的扩散
            while( i-p[i]>=0 and i+p[i]<l and s_new[i-p[i]] == s_new[i+p[i]]):
                p[i] += 1
            
            # 记录一下mx和mid
            if i+p[i] > mx:
                mx = i+p[i]
                mid = i
        
        maxr = max(p)
        ans = p.index(maxr)
        # 因为跳出循环的时候多加了1，所以实际上的扩散半径应该减1
        maxr -= 1

        return s_new[ans-maxr:ans+maxr+1].replace('#',"")