Longest Palindromic Substring

题目：https://leetcode.com/problems/longest-palindromic-substring/

算法分析

这道题的解法有三种：暴力法、动态规划、Manacher算法。三种方法的时间复杂度分别为O(n3),O(n2),O(n)。暴力法过于简单粗暴，Manacher算法又有点不好理解，所以，这里只介绍动态规划法。对于O(n2)的时间复杂度，也是可以接受的吧。如果，你想追求5G的极速享受，请转接http://articles.leetcode.com/2011/11/longest-palindromic-substring-part-ii.html。

既然要利用动态规划，首要任务就是要找到状态转移方程。乍看此题，哪里来的状态转移。所以，我们需要构建状态。

这里，我们要定义一个二维数组Matrix[len(str)][len(str)]，用来存储状态。对于为什么这么定义，我只能说记住就行了，以后类似的题目都是可以套用的。

下面，解释一下状态的含义。Matrix[i][j]表示的是字符串str从第i位置到第j位置是否为回文子串，如果是，则存储True，如果不是，则存储False。

这样状态转移方程就可以写出来了：

Matrix[i][j]={True,False,     Matrix[i+1][j−1] and str[i]=str[j]     else

最后，需要注意一些特殊状态的赋值：

Matrix[i][i]=True

Matrix[i][i+1]=True when str[i]=str[i+1]

这样，状态转移方程就建立完成了。我们只需要把这个矩阵填充完，就可以找到最大的回文子串了。

怎么找最大回文子串？你可以在程序开头定义两个变量，分别记录最大回文子串的长度和开始位置，这样在每次更新Matrix矩阵的过程中，比较当前找到的最大回文子串的长度与变量里记录的最大长度，然后决定是否更新，如果更新，就把最大回文子串的开始位置也更新一下。这样，当整个矩阵填充完，相应的最大回文子串也就找到了。

代码实现

动态规划：

class Solution(object):
    def longestPalindrome(self, s1):
        """
        :type s: str
        :rtype: str
        """
        length = len(s1)
        max = 0
        start = 0
        matrix = [[True if i == j else False for i in range(length)] for j in range(length)]
        for i in range(length-1):
            if s1[i] == s1[i+1]:
                matrix[i][i+1] = True
                max = 1
                start = i
        for step in range(2, length):
            for i in range(length-step):
                if s1[i] == s1[i+step] and matrix[i+1][i+step-1]:
                    matrix[i][i+step] = True
                    if max < step:
                        max = step
                        start = i
        return s1[start:start+max+1]

Manacher算法:

class Solution(object):
    def longestPalindrome(self, s):
        t = '$#' + '#'.join(s) + '#_'
        return t
        p = [0] * 4010
        mx, id, mmax, right = 0, 0, 0, 0
        for i in range(1, len(t) - 1):
            if mx > i:
                p[i] = min(p[2 * id - i], mx - i)
            else:
                p[i] = 1
            while t[i + p[i]] == t[i - p[i]]:
                p[i] += 1
            if i + p[i] > mx:
                mx = i + p[i]
                id = i
            if mmax < p[i]:
                mmax = p[i]
                right = i
        return s[right//2 - mmax//2: right//2 - mmax//2 + mmax - 1]