【LeetCode】【5. Longest Palindromic Substring】(python版)

Description：
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"

思路：
题目要求是输入一个字符串，求包含的最大回文子串。
方法一：暴力算法，求出所有子串，判断是不是回文，记录最长的子串，时间复杂度为$O(n^3)$。
方法二：遍历字符串，以每个字符(或者每两个字符)为中心往两边延伸，求能达到的最大长度。对每个中心，延伸需要遍历一次字符串，时间复杂度为$O(n)$。每个字符需要作为中心延伸点2次，所以最终时间复杂度为$O(2n*n)=O(n^2)$

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        n = len(s)
        maxLen = 1
        if s == s[::-1]:
            return s
        maxstring = s[0]
        for i in range(1, 2 * n - 1):
            # start，end分别为延伸中心的字符下标，如果一个字符为中心，start=end，那么下一循环中，start不变，end+1，相当于以两个字符为中心。
            start = end = i / 2
            if i % 2 == 1:
                end += 1
            # 返回最大延伸的回文子串的左右边界下标
            start, end = self.expand(s, start, end)
            if end - start + 1 > maxLen:
                maxLen = end - start + 1
                maxstring = s[start: end + 1]
        return maxstring

    def expand(self, s, start, end):
        n = len(s)
        while start >= 0 and end < n and s[start] == s[end]:
            start -= 1
            end += 1
        return start + 1, end - 1

方法三：动态规划，如果我们已经知道“abba”是一个回文，那么在它两边各加一个c，变成“cabbac”，那么得到的一定也是一个回文。根据这个性质，我们可以将问题规模缩小。维护一个二维的布尔型数组$dp，dp[i][j]$表示区间[i,j]的字符串是否为回文。可以知道dp的计算公式：
$dp[i][j] = True$ 　　　　　　　　　　　　　　if (i == j)
$dp[i][j] = (s[i]==s[j])$ 　　　　　　　　　　if (j - i == 1)
$dp[i][j] = (s[i]==s[j])$ && $dp[i+1][j-1]$ 　if (j - i >= 2)
可以合并为：

class Solution(object):
    def longestPalindrome(self, s):
        n = len(s)
        maxLen = 1
        if n == 0 or n == 1:
            return s
        start = end = 0
        dp = [[False] * n for i in range(n)]
        for j in range(n):
            # 保证i是子串起始，j是子串末尾
            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 maxLen < j - i + 1:
                    maxLen = j - i + 1
                    start = i
                    end = j
            dp[j][j] = True
        return s[start: end+1]

方法四：(参考牛客网友@华科平凡 思路)从头到尾扫描字符串，每增加一个新的字符，判断以这个字符结尾，且长度为maxLen+1或者maxLen+2的子串是否为回文，如果是，更新。时间复杂度$O(n)$

class Solution(object):
    def longestPalindrome(self, s):
        n = len(s)
        maxLen = 1
        maxstring = s[0]
        if s == s[::-1]:
            return s
        for i in range(n):
            # 判断以i为结尾的，长度为maxlen+2的子串
            if i - maxLen >= 1 and s[i - maxLen - 1:i + 1] == s[i - maxLen - 1:i + 1][::-1]:
                maxstring = s[i - maxLen - 1:i + 1]
                maxLen += 2
                continue
            # 判断以i为结尾的，长度为maxlen+1的子串
            if i - maxLen >= 0 and s[i - maxLen:i + 1] == s[i - maxLen:i + 1][::-1]:
                maxstring = s[i - maxLen:i + 1]
                maxLen += 1
        return maxstring

方法五：