最长回文子串(MIDDLE-5)

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：

输入：s = "cbbd"
输出："bb"
示例 3：

输入：s = "a"
输出："a"
示例 4：

输入：s = "ac"
输出："a"

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

分析

•  注意是串，而非序列

• 回文串众所周知，即对折的相对位置元素相同

• 从上一点对折的相对位置元素相同有没有考虑到一个比较直观的想法？（中心拓展法）

解法一 动态规划

比较简单 直接上Leetcode官方思路

思路与算法

对于一个子串而言，如果它是回文串，并且长度大于 22，那么将它首尾的两个字母去除之后，它仍然是个回文串。例如对于字符串 “ababa”，如果我们已经知道 “bab” 是回文串，那么 “ababa” 一定是回文串，这是因为它的首尾两个字母都是 “a”。

根据这样的思路，我们就可以用动态规划的方法解决本题。我们用 P(i,j)P(i,j) 表示字符串 ss 的第 ii 到 jj 个字母组成的串（下文表示成 s[i:j]s[i:j]）是否为回文串：

  

 

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/longest-palindromic-substring/solution/zui-chang-hui-wen-zi-chuan-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 此类体型是含模板的哟；基本用得到动态规划的串问题，使用二维的dp可解决。模板如下：

n = len(s)
m = len(p)
#有时候s和p是一个东西
dp = [[0] * m for _ in range(m)]
#有时候记录的是真假
#dp = [[False] * m for _ in range(m)]

for i in range(n -  1, -1, -1):
    for j in range(i, n):
       #状态转移

def longestPalindrome(self, s: str) -> str:
    n = len(s)
    dp = [[0] * n for _ in range(n)]
    maxLen = 0
    begin = 0
    for i in range(n - 1, -1, -1):
        for j in range(i, n):
            if s[i] == s[j]:
                if j - i < 3:
                    dp[i][j] = True  # 小于3 那必然是真呀  因为要么两个 要么只有一个
                else:
                    dp[i][j] = dp[i + 1][j - 1]   #状态转移  上一个状态到本状态（此处相比不明白可以那个绳子模拟下；）
            if dp[i][j] and j - i + 1 > maxLen:
                maxLen = j - i + 1
                begin = i
    return s[begin : begin + maxLen]

解法二  中心拓展法

中心拓展法的思想真的很简单，回文是啥意思？-->对称；对称是啥意思-->左右两边相同；OK没了(代码来自Leetcode官网，思想很简单 懒得写了)

def expandAroundCenter(s, left, right):
    while left >= 0 and right < len(s) and s[left] == s[right]:
        left -= 1
        right += 1
    return left + 1, right - 1  #  切记 跳出循环时的位置 已经不再是回文，所以记录上一次的地点

def longestPalindrome(s: str) -> str:
    start, end = 0, 0
    for i in range(len(s)):
        left1, right1 = self.expandAroundCenter(s, i, i)
        left2, right2 = self.expandAroundCenter(s, i, i + 1)
        if right1 - left1 > end - start:
            start, end = left1, right1
        if right2 - left2 > end - start:
            start, end = left2, right2
    return s[start: end + 1]