【史上最详细解释】最长回文子串手把手教学【包你学会】

题目描述：

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

示例 1：

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

输入：s = “cbbd”
输出：“bb”

解题思路：

中心扩散法：

中心扩散法的思想是遍历一遍字符串，以单个字符为中心和以两个字符为中心的，遍历某个字符（或者某两个字符的时候）时，找到以这个字符为中心的最长回文串。将我们找到的回文子串保存在一个列表里面，最后找到最长的那个就行了。

代码：

class Solution:
    def helper(self,s,left,right):
        a =""
        while 0 <= left and right < len(s) and s[left] == s[right]:
                left -= 1
                right += 1
                a = s[left+1:right]
        # return s[left+1:right]
        return a

    def longestPalindrome(self, s):
        res = ""
        for i in range(len(s)):#遍历字符串中的每个字符为中心的所有回文子串，找到最长的那个
            res = max(self.helper(s,i,i), self.helper(s,i,i+1), res, key=len)
        return res

思路二： 动态规划：

怎么理解动态规划这个问题呢？

可以这样理解，我们要求一个字串符"abccba"是不是回文串，设s=“abccba”,我们判断字符串s是不是回文串，我们就需要判断当前字符串最外面的字符是不是相等和除去最外面字符的字符串是不是回文子串。即要判断s[i:j]是不是回文串，那么我们需要判断s[i]和s[j]是不是相等，以及s[i+1:j-1]是不是回文串。只要这两个条件有一个不满足那就不是回文串。

在这里我们用一个二维数组dp来表示，dp[i][j] 表示字符串s[i:j]是不是回文串。

代码：

class Solution:
    def longestPalindrome(self, s: str) -> str:
        n = len(s)#首先判断这个字符串的长度，如果字符串的长度小于2，那这个字符串就只有一个字符，那必定是回文串
        if n < 2:
            return s

        max_len = 1
        begin = 0
        # dp[i][j] 表示 s[i..j] 是否是回文串
        dp = [[False] * n for _ in range(n)]#设定一个二维数组，里面填满False,False表示s[i:j]不是回文串
        for i in range(n):
            dp[i][i] = True#这里把对角线的值都设置为True
            #表示字符串里面的每单个字符都是回文串，比如在字符串"abc","a","b","c"单独拿出来都是回文串，这里就是这个意思
        # 递推开始
        # 先枚举子串长度，我们直接枚举子串的长度，检查所有长度为某个固定数值的所有子串是不是都是回文子串
        for L in range(2, n + 1):
            # 枚举左边界，左边界的上限设置可以宽松一些
            for i in range(n):
                # 由 L 和 i 可以确定右边界，即 j - i + 1 = L 得
                j = L + i - 1
                # 如果右边界越界，就可以退出当前循环
                if j >= n:
                    break

                if s[i] != s[j]:# 因为判断s[i:j]是不是回文串需要满足2个条件，
                #1、s[i]==s[j],2、s[i+1:j-1]也是回文子串，这里先判断一个条件
                    dp[i][j] = False
                else:
                    if j - i < 3: # 这里的条件是用来判断的s[i+1:j-1]子串的长度是不是严格小于2，即这个子串只有1个字符，那么那就是回文子串， j-1 - (i+1) + 1 < 2 ==> j-i < 3
                        dp[i][j] = True
                    else: 
                    """如果子串s[i+1:j-1]的长度大于2，那么我们直接把dp[i+1][j-1]的值赋给dp[i][j],
                    不用担心我们对子串s[i+1:j-1]是不是回文串在此之前有没有做判断，
                    因为我们是根据子串长度遍历的，且因为子串s[i:j]的长度必然大于s[i+1:j-1]的长度，
                    所有我们在判断s[i:j]是不是回文串的时候，那么我们必然已经判断过了s[i+1:j-1]了"""
                        dp[i][j] = dp[i + 1][j - 1]

                # 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
                #这里是在判断s[i:j]是不是回文串，并且回文串的长度是不是大于我们设定的最长长度，
                #每次有长度大于之前回文串长度的回文串时我们就会更新这个max_len和begin，保证我们最后返回的回文串都是最长
                if dp[i][j] and j - i + 1 > max_len:
                    max_len = j - i + 1
                    begin = i
        return s[begin:begin + max_len]


s = "abbccbbd"
a = Solution()
print(a.longestPalindrome(s))