Leetcode 5. 最长回文子串

1.题目描述

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

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

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

提示：

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

2.思路分析

2.1 暴力解法

从大到小枚举回文字符串长度后搜寻回文串的起始点

2.2 动态规划

1.确定dp数组（dp table）以及下标的含义

• dp[i][j]：表示区间范围[i,j] (注意是左闭右闭)的子串是否是回文子串，如果是dp[i][j]为true，否则为false。

2.确定递推公式

• 当s[i]与s[j]不相等，dp[i][j]一定是false。
• 当s[i]与s[j]相等，有如下三种情况:
• 情况一：下标i 与 j相同，同一个字符例如a，当然是回文子串
• 情况二：下标i 与 j相差为1，例如aa，也是回文子串
• 情况三：下标：i 与 j相差大于1时，例如cabac，此时s[i]与s[j]已经相同了，判断i到j区间是不是回文子串就要看aba是不是回文就可以了，那么aba的区间就是 i+1 与 j-1区间，这个区间是不是回文就看dp[i + 1][j - 1]是否为true。
• 在得到[i,j]区间是否是回文子串的时候，直接保存最长回文子串的左边界和右边界

3.dp数组如何初始化

• dp[i][j]初始化为false

4.确定遍历顺序

• 从下到上, 从左到右遍历

5.举例推导dp数组

• 输入：“aaa”，dp[i][j]状态如下：

2.3 中心扩展法

中心扩散法怎么去找回文串？

从每一个位置出发，向两边扩散即可。遇到不是回文的时候结束。举个例子，str = acdbbdaa 我们需要寻找从第一个 b（位置为 33）出发最长回文串为多少。怎么寻找？
首先往左寻找与当期位置相同的字符，直到遇到不相等为止。
然后往右寻找与当期位置相同的字符，直到遇到不相等为止。
最后左右双向扩散，直到左和右不相等。如下图所示：

g)]

每个位置向两边扩散都会出现一个窗口大小（len）。如果 len>maxLen(用来表示最长回文串的长度）。则更新 maxLen 的值。
因为我们最后要返回的是具体子串，而不是长度，因此，还需要记录一下 maxLen 时的起始位置（maxStart），即此时还要 maxStart=len。

3.代码实现

3.1 暴力法

class Solution:
    def longestPalindrome(self, s: str) -> str:
        # 如果长度为1，肯定为回文子串
        if s == s[::-1]: return s
        max_len=1
        res = s[0]
        for i in range(len(s) - 1):
            for j in range(i+1, len(s)):
                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

复杂度分析

• 时间复杂度：O(n^2) ，其中 n是字符串的长度。
• 空间复杂度：O(n^2)。

3.2 动态规划

# 写法1:
class Solution:
    def longestPalindrome(self, s: str) -> str:
        n = len(s)
        if n < 2:
            return s

        max_len = 1
        begin = 0
        # dp[i][j] 表示 s[i..j] 是否是回文串 二维dp数组 此处j>=i 故仅仅填充dp数组的上半部分
        dp = [[False] * n for _ in range(n)]
        for i in range(n):
            dp[i][i] = True

        # 递推开始
        # 先枚举子串长度
        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]:
                    dp[i][j] = False
                else:
                    if j - i < 3:
                        dp[i][j] = True
                    else:
                        dp[i][j] = dp[i + 1][j - 1]
                # 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
                if dp[i][j] and j - i + 1 > max_len:
                    max_len = j - i + 1
                    begin = i
        return s[begin:begin + max_len]
# 写法2
class Solution:
    def longestPalindrome(self, s: str) -> str:
        dp = [[False] * len(s) for _ in range(len(s))]
        maxlenth = 0
        left = 0
        right = 0
        # 反向遍历
        for i in range(len(s) - 1, -1, -1):  # 遍历顺序
            for j in range(i, len(s)):
                if s[j] == s[i]:
                    if j - i <= 1 or dp[i + 1][j - 1]:
                        dp[i][j] = True
                if dp[i][j] and j - i + 1 > maxlenth:
                    maxlenth = j - i + 1
                    left = i
                    right = j
        return s[left:right + 1]

复杂度分析

• 时间复杂度：O(n^2) ，其中 n是字符串的长度。动态规划的状态总数为 O(n^2)，对于每个状态，我们需要转移的时间为 O(1) 。
• 空间复杂度：O(n^2), 即存储动态规划状态需要的空间。

3.3 中心扩散法

class Solution:
    def expandAroundCenter(self, 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(self, 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]

复杂度分析

• 时间复杂度：O(n^2)。
• 空间复杂度：O(1)。

参考https://leetcode.cn/problems/longest-palindromic-substring/solution/zhong-xin-kuo-san-fa-he-dong-tai-gui-hua-by-reedfa/