5. 最长回文子串 [中等] 暴力法 中心扩散法 动态规划法

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

如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

示例 1：

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

输入：s = "cbbd"
输出："bb"
 

提示：

1 <= s.length <= 1000
s 仅由数字和英文字母组成

方法一：中心扩散法：

思路

• 枚举每个点作为回文串的中心点，左右扩散，如果左边等于右边则继续扩散
• 注意要考虑回文串长度为奇偶的情况

  class Solution:
      def longestPalindrome(self, s: str) -> str:
          #分函数处理,while循环
          def palindrome(s,l,r):
              while l>=0 and r<len(s) and s[l]==s[r]:
                  l-=1
                  r+=1
              return s[l+1:r]
          res=""
          for i in range(len(s)):
              #奇数和偶数分别调用函数
              sub1=palindrome(s,i,i)
              sub2=palindrome(s,i,i+1)
              res=sub1 if len(sub1)>len(res) else res
              res=sub2 if len(sub2)>len(res) else res
          return res

  方法二：动态规划法

动态规划：填dp表、当前ij状态、过去ij状态、如何联合得到输出、边界条件

定义状态：题目让我们求什么，就把什么设置为状态
题目求s中最长的回文子串，那就判断所有子串是否为回文子串，选出最长的
因此：dp[i][j]表示s[i:j+1]是否为回文子串（这里+1是为了构造闭区间）

状态转移方程：对空间进行分类讨论（当前ij状态、过去ij状态 如何联合得到输出）
当前ij状态：头尾必须相等（s[i]==s[j]）
过去ij状态：去掉头尾之后还是一个回文（dp[i+1][j-1] is True）
边界条件：只要是找过去ij状态的时候，就会涉及边界条件（即超出边界情况处理）
当i==j时一定是回文
j-1-(i+1)<=0,即j-i<=2时，只要当s[i]==s[j]时就是回文，不用判断dp[i+1][j-1]
dp[i][j] 为截取的子串

初始状态：这里已经直接判断j-i<=2的情况了，因此用不到初始状态，可以不设

输出内容：每次发现新回文都比较一下长度，记录i与长度

优化空间提速

class Solution:
    def longestPalindrome(self, s: str) -> str:
        size=len(s)
        #特殊处理
        if size==1:
            return s
        #创建动态规划dynamic programing表
        dp=[[False for _ in range(size)]for _ in range(size)]
        #初始长度为1，这样万一不存在回文，就返回第一个值，初始条件设置的时候一定要考虑输出
        max_len=1
        start=0
        for i in range(size):
            dp[i][i]=True
        #递推开始
        for j in range(1,size):
            for i in range(j):
                #边界条件
                #只要头尾相等(s[i]==s[j])就能返回true
                if j-i<=2:
                    if s[i]==s[j]:
                        dp[i][j]=True
                        cur_len=j-i+1
                #状态转移方程
                #当前dp[i][j]状态：头尾相等(S[i]=s[j])
                #过去dp[i][j]状态：去掉头尾之后还是一个回文dp[i+1][j-1]is True
                else:
                    if s[i]==s[j] and dp[i+1][j-1]:
                        dp[i][j]=True
                        cur_len=j-i+1
                #出现回文更新输出
                if dp[i][j]:
                    if cur_len>max_len:
                        max_len=cur_len
                        start=i

        return s[start:start+max_len]

方法三：暴力解法

class Solution:
    def longestPalindrome(self, s: str) -> str:
        #暴力法
        #如果全部是回文子串直接返回
        if s==s[::-1]:
            return s
        size=len(s)
        #设置最大长度和结果字符串
        max_len=1
        res=s[0]#先存储第一个
        for i in range(size-1):
            for j in range(i+1,size):
                if j-i+1 >max_len and s[i:j+1]==s[i:j+1][::-1]:
                    max_len=j-i+1
                    res=s[i:j+1]
        return res