Leetcode 5. Longest Palindromic Substring

此题为借鉴的别人的思路（在复杂度方面实在没有更好的自我实现方法）
代码部分1 参考链接 http://blog.csdn.net/asd136912。 https://blog.csdn.net/asd136912/article/details/78987624
代码部分2 理论部分参考链接 https://segmentfault.com/a/1190000003914228
代码部分参考链接 https://blog.csdn.net/tuobadon/article/details/78989601

题目说明

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example 1:
Input: “babad”
Output: “bab”
Note: “aba” is also a valid answer.

Example 2:
Input: “cbbd”
Output: “bb”

代码部分1

class Solution:
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        substring = ''
        maxlen = 0
        if s == '':
            return s
        for i in range(len(s)):
            for j in range(len(s)-1,i,-1):
                if j-i+1 > maxlen:
                    ss = s[i:j+1]
                    ss1 = list(ss)
                    ss2 = list(ss)
                    ss2.reverse()
                    if ss1 == ss2:
                        substring = s[i:j+1]
                        maxlen = j-i+1
        if substring == '':
            substring = s[0]
        return substring

Time Limit Exceeded

主要思路：
代码部分1主要参考转载链接1. Brute method 时间复杂度o(n^2)
求解想法：一层i循环range(len(s))，再一层j循环range(len(s)-1,i,-1){倒着来可以更快的找到最长的回文子串从而减少比较次数}，不停向后移动位置和缩减长度来寻找回文子串
位置关系： i…k…j
结合自己的经验小改动：
1.在双层循环直接比较子串是否为回文串时，并没有采用k的比较方法，而是将之转化为list以调用reverse()函数判断
2.增加判断条件if j-i+1 > maxlen，当剩下的待比较子串长度小于已有的maxlen时跳过比较环节

代码部分2 Manacher算法

此种算法算法复杂度为O(n2)，相比较于前一种代码O(n3)简洁许多，但理论性比较强，需在理解了理论原理的基础上才可以理解代码

class Solution:
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        #step 1
        T='#'.join('@{}$'.format(s))
        lens=len(T)
        RL=[0]*lens
        pos=0                                            
        maxright=0
        for i in range(1,lens-1):
            j=pos-(i-pos)                #i关于中心c的对称位置，记为j
            if maxright>i:                               
            #如果i在maxright以内，则必有对应j在pos回文子串内，则i的起点可以从RL[j]或maxright-i中较小者开始
                RL[i]=min(maxright-i,RL[j])
            # 中心扩展法完成之前没有涉及的字符比对
            while T[i+1+RL[i]]==T[i-1-RL[i]]:    #默认从RL[i]=1向上开始比较（因为#的加入所有字母起点为1）
                RL[i]=RL[i]+1
            #更新当前最右回文串中心pos及终止位置maxright
            if i+RL[i]>maxright:
                pos=i
                maxright=i+RL[i]
        #找到最大回文半径及对应的回文中心
        maxlen=0
        centeridx=0
        for i in range(1,lens-1):
            if RL[i]>maxlen:
                maxlen=RL[i]
                centeridx=i
        #获取最长回文串
        begin=(centeridx-maxlen)//2
        end=(centeridx+maxlen)//2
        return s[begin:end]

Runtime: 124 ms, faster than 92.20% of Python3

主要思路：
参考代码部分2 理论参考链接

动态规划

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        lens=len(s)
        dp=[[0 for i in range(lens)] for j in range(lens)]
        maxl=0
        beg=0
        end=0
        if lens<=1:
            return s
        for j in range(lens):
            for i in range(j):
                dp[i][j]=s[i]==s[j] and (j-i<2 or dp[i+1][j-1])
                if dp[i][j] and j-i+1>maxl:
                    maxl=j-i+1
                    beg=i
                    end=j
            dp[j][j]=1
        return s[beg:end+1]

网上的思路解释有很多，自我主要是记录