最长回文子串

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

示例 1：

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。

示例 2：

输入: “cbbd”
输出: “bb”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

注:
打个比方 ： “上海自来水来自海上” 既是回文

自己解答
1 暴力遍历

class Solution:
    def decide(self,str_):
        str_len = len(str_)
        # print(str_)
        len2=str_len // 2
        if str_len % 2 == 0:
            sss=str_[:len2 - 1:-1]
        else:
            sss=str_[:len2:-1]
        if str_[0:len2] != sss:
            return False
        return True

    def longestPalindrome(self, s: str) -> str:
        if len(s)==1:
            return s
        maxStr = ""
        maxlen = len(s)
        ret = ""
        for i in range(maxlen):
            # print(s[i:maxlen])
            # print("=====")
            # print(s[i:maxlen])
            thislen = maxlen - i
            # print(thislen)
            for j in range(i + 1):
                # print('j :', j)
                # print(s[j:thislen + j])
                if self.decide(s[j:thislen + j]):
                    # print('res:', s[j:thislen + j])
                    return s[j:thislen + j]

超出时限，去看看思路再解答试试。
2 动态规划

class Solution:
    def longestPalindrome(self, s: str) -> str:
        slen=len(s)
        if slen==1:
            return s
        dp=[[False for i in range(slen)]for i in range(slen)]
        maxlen=0
        maxStr=""
        start=0
        end=0
        for i in range(slen):
            dp[i][i] = True
        for i in range(2,slen+1):  # 遍历子串的长度
            # print(i)
            for j in range(slen): #遍历子串的起始位置
                cur_end=j+i
                sub_s=s[j:cur_end]
                if len(sub_s)<i:
                    break
                if sub_s[0]==sub_s[-1]:
                    if i <3 :
                        dp[j][cur_end - 1] =True
                        start=j
                        end=cur_end
                        # maxStr = sub_s
                    else :
                        st=dp[j+1][cur_end-2]
                        if st:
                            dp[j][cur_end - 1] = st
                            start=j
                            end=cur_end                       
                            # maxStr = sub_s
        if start==0 and end==0:
            return s[0]
        return s[start:end]

看了官方的思路,然后自己尝试着写，结果还是超时。emm,然后测试了官方的代码，官方的代码也是超时的。。。。我只能。。。不过确实学习了一下动态规划是个什么。官方上已经写的很清楚，这里就不再重复。
3 中心查找

class Solution:
    def decide(self, str_, index,slen_,d):
        if index+1==slen_:
            return index-1,index
        if d == 1:
            left = index
            right = index
        else:
            left = index
            right = index + 1
        while True:
            if str_[left] != str_[right]:
                return left+1,right
            else:
                left = left - 1
                right = right + 1
            if right>=slen_ or left<0:
                return left+1,right

    def longestPalindrome(self, s: str) -> str:
        slen = len(s)
        if slen < 2:
            return s
        maxlen=0
        maxStr=""
        for i in range(0, slen):
            start1,end1=self.decide(s,i,slen,1)
            if maxlen<len(s[start1:end1]):
                maxlen=len(s[start1:end1])
                maxStr=s[start1:end1]
            start2, end2 = self.decide(s, i, slen, 2)
            if maxlen<len(s[start2:end2]):
                maxlen=len(s[start2:end2])
                maxStr=s[start2:end2]
        return maxStr

花了不少时间，反复看思路。终于还是出来了 ，代码似乎还有不合理的地方，下面看看能不能再改一下。
执行用时：852 ms, 在所有 Python3 提交中击败了85.90% 的用户
内存消耗：13.6 MB, 在所有 Python3 提交中击败了50.86% 的用户

class Solution:
    def decide(self, str_, index,slen_,d):
        print('decide',index,slen_)
        if index+1==slen_:  # 当下标是最后一个字符时 ，可以直接返回
            return index-1,index
        if d: # 当 d 为True ,以index下标的字符为中心
            left = index
            right = index
        else:   # 否则 以 index 和 index+1 为中心
            left = index
            right = index + 1
        while True:
            if str_[left] != str_[right] or left<0:
                return left+1,right  #  注意 返回值为 最长回文在字符串s中左边和右边的截取位置。
            else:
                left = left - 1
                right = right + 1
            if right==slen_:
                return left+1,right

    def longestPalindrome(self, s: str) -> str:
        slen = len(s)
        if slen < 2:
            return s
        maxlen=0
        maxStr=""
        for i in range(0, slen):
            start1,end1=self.decide(s,i,slen,True)  #　中心字符的长度为 1
            s1=s[start1:end1]
            s1len=len(s1)
            if maxlen<s1len:
                maxlen=s1len
                maxStr=s1
            start2, end2 = self.decide(s, i, slen, False) # 中心字符的长度为2
            s2=s[start2:end2]
            s2len=len(s2)
            if maxlen<s2len:
                maxlen=s2len
                maxStr=s2
        return maxStr

大神解答

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s: return ""
        length = len(s)
        if length == 1 or s == s[::-1]: return s
        max_len,start = 1,0
        for i in range(1, length):
            even = s[i-max_len:i+1]
            odd = s[i-max_len-1:i+1]
            if i - max_len - 1 >= 0 and odd == odd[::-1]:
                start = i - max_len - 1
                max_len += 2
                continue
            if i - max_len >= 0 and even == even[::-1]:
                start = i - max_len
                max_len += 1
                continue
        return s[start:start + max_len]

执行用时：64 ms, 在所有 Python3 提交中击败了99.03% 的用户
内存消耗：13.7 MB, 在所有 Python3 提交中击败了47.74% 的用户
ps :
此代码为leetcode排名靠前的他人所写
这代码没有注释，一下竟然看不懂。。。回头看了看官方讲解，应该就是传说中的 Manacher 算法。感兴趣的可以自己看看。