LeetCode 5 各种解法详解 python

LeetCode 5 各种解法详解 python

题目：
寻找一个字符串的最长回文子串。

解法一

暴力法
时间复杂度$O（N^3）$
这种方法思路就比较简单，意思就是字符串里$i!=j$,但是s[i]==s[j]，那么从i到j的这段子串就有可能是回文串，python里只要s[::-1]就能把字符串翻转进而判断一个字符串是否回文串。

class Solution:
    def longestPalindrome(self, s):
        if len(s)<=0:
            return
        if len(s)==1:
            return s
        res = ''
        i = 0
        length = len(s)
        while i<length-1:
            for j in range(i+1,length):
                if s[j]==s[i]:
                    if self.isPalindrome(s[i:j+1]):
                        if len(s[i:j+1])>len(res):
                            res = s[i:j+1]
            i+=1
        return res
    def isPalindrome(self,s):
        return s==s[::-1]

中心拓展法

时间复杂度$O(N^2)$，空间复杂度$O(1）$
这一想法比暴力法略复杂一丢丢。但其实实现起来很简单。
顾名思义从字符串中心开始找回文串。
(s,i,i)即以i 为中心的最长回文子串
(s,i,i+1)即以i，i+1为中心的最长回文子串。

class Solution:
    def longestPalindrome(self, s):
        length = len(s)
        if length==0 or length ==1:
            return s
        start = 0
        end = 0
        mlen = 0
        for i in range(length):
            len1 = self.lengthofpalindrome(s,i,i)#以1个点为中心
            len2 = self.lengthofpalindrome(s,i,i+1)#以两个点为中心
            mlen = max(len1,len2,mlen)
            if mlen>=(end-start+1):
                start = i-(mlen-1)//2
                end = i+mlen//2+1
        return s[start:end]
  #计算最大回文长度
    def lengthofpalindrome(self,s,left,right):
        L,R = left,right
        while (L>=0 and R<=len(s)-1 and s[L]==s[R]):
            L -= 1
            R += 1
        return R-L-1

马拉车法（manacher）

这一方法略有些复杂。不过理解以后其实很有趣。
但是时间复杂度只有$O(n)$
首先在字符串首尾以及每个字符之间都加上一个其他字符，比如字符串‘abc’，变成：‘#a#b#c#’

这样以后不管原来的回文串长度是奇数还是偶数，新字符串中回文串长度都将是奇数。我们把原子符串记为S，新字符串记为T

我这里用一个数组le记录下每个字符作为回文串中心，到该回文串最右边的字符的字符个数，可以理解为回文串的半径，不过注意这里的“半径”’其实是包含了中心的那个字符串的。比如说假如一个回文串的“半径”为R，那么这个回文串的长度就应该是$2R-1$
比如：

T	#	a	#	b	#	c	#
le	1	2	1	2	1	2	1

这时候，在le数组中最大的R,就一定是原字符串中最长回文子串的对称点了，如果这个点是添加进去的‘#’，对应的是原字符串中对应回文子串中间两个字符之间，也即这时候原回文子串长为偶，比如‘bb’，反之则原回文子串长为奇数。

这里贴几个大佬们的写的比较详细的解释：
manacher

class Solution:
    def longestPalindrome(self, s):
        length = len(s)
        if length==0 or length==1:
            return s
        i = 1
        ts = ''.join(['#'+i for i in s])+'#'
        le = [1]
        p0 = 0
        p = 0
        rescenter = 0 #记录中心点
        resmlen = 1#记录中心点到回文串最右边字符的长度
        while i<=length*2:
            if i<=p:
                j = 2*p0-i
                if le[j] < p-i:
                    le.append(le[j])
                else:
                    count = p-i+1
                    r = p+1
                    while r<=len(ts)-1 and ts[r]==ts[2*i-r]:
                        count += 1
                        r +=1
                    le.append(count)
                    p0 = i
                    p = r-1
            else:
                count = 1
                r = i+1
                while r<=len(ts)-1 and ts[r] == ts[2*i-r]:
                    count += 1
                    r += 1
                le.append(count)
                p0 = i
                p = r-1
            if le[i]>resmlen:
                rescenter = i
                resmlen = le[i]
            i += 1
        start = (rescenter-(resmlen-1))//2
        end = start + (resmlen-1)
        return s[start:end]