算法———最长回文子串

题目描述：给定一个字符串，求其中包括的最长回文子串，返回最长回文串

方法1：我使用的方法：中心扩展法，枚举回文串的中心位置，分奇偶两种情况讨论，选定中心元素后，向左和右扩展，如果是回文串，记录长度与当前长度比较，更新为长度较大者，遍历完成后返回最长子串，时间复杂度O(n2)，空间复杂度O(1)

def longest(s):
    n = len(s)
    if n < 2:
        return s
    ans = ""
    # 中心扩展法，枚举回文串的中心位置
    for i in range(n):
        # 向两端扩展，注意要分奇偶情况讨论
        # 当回文子串长度是奇数
        left, right = i, i     
        while left >= 0 and right < n and s[left] == s[right]:
            left -= 1
            right += 1
        if right - left - 1 > len(ans):  # 更新最长回文串
            ans = s[left+1:right]
        # 当回文子串长度是偶数
        left, right = i, i+1    
        while left >= 0 and right < n and s[left] == s[right]:
            left -= 1
            right += 1
        if right - left - 1 > len(ans):  # 更新最长回文串
            ans = s[left+1:right]
    return ans

方法2：动态规划——我们定义了一个二维数组f，用来表示子串s[i:j+1]是否为回文串。然后将所有长度为1的子串都标记为回文串，即f[i][i]=True。

从长度为2开始枚举区间长度，对于每个区间长度，枚举区间左端点l，计算出区间右端点r=l+length-1。如果区间左右端点对应的字符相等，那么只需要判断s[l+1:r]是否为回文串即可。如果f[l+1][r-1]为True，或者区间长度为2，那么s[l:r+1]就是回文串。将f[l][r]标记为True，然后更新最长回文子串的开始位置和长度。时间复杂度O(n2)，空间复杂度O(n2)

class Solution:
    def longestPalindrome(self, s: str) -> str:
        n = len(s)
        if n < 2: return s   # 长度为1直接返回

        start, maxLen = 0, 1  # 维护最长回文串的开始位置以及长度
        f = [[False] * n for _ in range(n)] 
        for i in range(n): f[i][i] = True  # 长度为1的区间为回文串

        for length in range(2, n + 1):  # 从2开始枚举区间长度
            for l in range(n):  # 枚举区间左端点
                r = l + length - 1
                if r >= n: break  # 避免出现右端点越界的情况
                if s[l] == s[r]:
                    if f[l+1][r-1] or length == 2: # 长度为2需要特判
                        f[l][r] = True
                        if length > maxLen:
                            start, maxLen = l, length
        
        return s[start:start + maxLen]

 方法三：暴力解法

两层for循环--外层枚举最大长度，内层枚举所有可能，从外层向内层逼近，用j从字符串的长度开始递减到0，每次递减1，求长度等于j的字符串，有则返回最长回文子串

class Solution(object):
    def longestPalindrome(self, s):
        # 从字符串的长度开始递减枚举区间长度
        for j in range(len(s), -1, -1):
            # 枚举区间的左端点
            for i in range(len(s)-j, -1, -1):
                # 如果区间s[i:i+j]是回文串，返回该子串
                if (s[i:i+j]) == s[i:i+j][::-1]:
                    return s[i:i+j][::-1]