leetcode5 最长回文子串 python

题目：

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

思路：

参考了官方答案 https://leetcode-cn.com/problems/longest-palindromic-substring/solution/，写了下面几种答案

1. 中心扩展方法

    思路：扫一遍字符串s，对于回文子串长为奇数的情况，求s[i]为轴对称中心的回文子串最长值；回文子串长偶数的情况，求s[i]s[i+i] 为中心的最长值。最后求最长。时间复杂度o(n^2)，因为扫一遍o(n)，中心扩展也是o(n)。注意数组越界和下标。

    参考：https://blog.csdn.net/u012560212/article/details/71708982

class Solution:
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        start = end = 0
        
        for i in range(len(s)):
            len1 = self.centerexpand(s, i, i)   #回文串长度为奇数，aba
            len2 = self.centerexpand(s, i, i+1)  #回文串长度为偶数，abba
            maxlen = max(len1, len2)
            if maxlen > end - start + 1:
                start = i - (maxlen - 1)//2
                end = i + maxlen//2
        return s[start: end+1]
                
    def centerexpand(self,s,l,r):
        while l >= 0 and r < len(s) and s[l] == s[r]:
            l -= 1
            r += 1
        return r - l - 1

2.Manacher

思路：https://segmentfault.com/a/1190000003914228 
            https://www.felix021.com/blog/read.php?2040
            https://articles.leetcode.com/longest-palindromic-substring-part-ii/

    首先向字符串的空位插入'#'，这样可以避免奇偶长度分类。
    然后也是扫一遍字符串，主要是记录了已访问过的最右侧字符maxright 和其对称轴pos，并加利用，避免重复访问。
    时间o(n)。
    具体的逻辑截了第一个参考链接的图，画的超棒。（侵权请联系）

需要注意下面的各种情况都是为了找RL[i]可能的最大起始点，这样就不用从0开始试了。

1）i<maxright

      (1) RL[j] 比较短的情况：（j是i关于pos的对称点）RL[i] 从RL[j] 开始

       (2)RL[j] 比较长的情况：RL[i] 从maxright - i 开始

2) i>=maxright
     RL[i] 从0开始。

class Solution:
    def longestPalindrome(self,s):
        """
        :type s: str
        :rtype: str
        """
        s = '#'+'#'.join(s)+'#'   #例如'#a#b#a#'
        pos = maxright = 0
        RL = [0]*len(s)     #RL是回文串半径，如回文串长3，RL=1，回文串长5，RL=2
        maxcenter = 0        #记录最长回文中心序号
        
        for i in range(len(s)):
            if i<maxright:              #i在maxright左侧
                RL[i] = min(maxright-i, RL[pos*2-i] )
            else:                       #i在maxright右侧（含）
                RL[i] = 0
            while i-RL[i]-1>=0 and i+RL[i]+1<len(s) and s[i-RL[i]-1] == s[i+RL[i]+1]:
                RL[i] += 1              #继续扩展（RL[j]短的情况是不需要继续扩展的，但多扩展一次也就出循环了）
            if i+RL[i] > maxright:      #更新maxright和i
                maxright = RL[i] + i
                pos = i
            if RL[i] > RL[maxcenter]:    #更新maxcenter
                maxcenter = i
        return s[maxcenter-RL[maxcenter]:maxcenter+RL[maxcenter]+1].replace('#','')

3. 正反字符串的最长公共子串

思路：官方答案的思路1。
具体实现上，求最长公共子串用动态规划参考 
https://blog.csdn.net/u012102306/article/details/53184446
如果是第一次看到，注意c[i][j]是(len+1)*(len+1)大小的，动态规划一般更新每个状态c[i][j]后才会得到答案。
像官网说的，为了区分字符串中子串非回文反向副本如abacfgcaba，要验证公共子串的索引。

class Solution:
    def longestPalindrome(self,s):
        """
        :type s: str
        :rtype: str
        """
        lens = len(s)
        maxlen = 0
        maxindex = 0
        s_rev = s[::-1]
        c = [[0]*(lens+1) for i in range(lens+1)]
        for i in range(1,lens+1):
            for j in range(1,lens+1):
                if s[i-1] == s_rev[j-1]:
                    c[i][j] = c[i-1][j-1]+1
                    if c[i][j]>maxlen and i+j-c[i][j] == lens: #验证索引
                        maxlen = c[i][j]    
                        maxindex = i
                else:
                    c[i][j] = 0
        return s[maxindex-maxlen:maxindex]

（上面这个答案...第一次提交94/103，超时。再试过了，看来还是用时比较长的方法）