【LeetCode】5. 最长回文子串

一、题目描述

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

二、解题思路 & 代码

2.1 动态规划

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

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

$$P(i,j)=\{\begin{array}{ll}\text{ true, }& 如果子串S_i\dots S_j是回文串\\ \text{ false, }& 其它情况\end{array}$$

这里的「其它情况」包含两种可能性：

1. s[i, j]本身不是一个回文串；
2. i > j，此时 s[i,j] 本身不合法。

动态规划的状态转移方程：
$$P(i,j)=P(i+1,j-1)\wedge \left(S_i==S_j\right)$$

也就是说，只有 s[i+1:j−1] 是回文串，并且 s 的第 i 和 j 个字母相同时，s[i:j] 才会是回文串。

上文的所有讨论是建立在子串长度大于 2 的前提之上的，我们还需要考虑动态规划中的边界条件，即子串的长度为 1 或 2。对于长度为 1 的子串，它显然是个回文串；对于长度为 2 的子串，只要它的两个字母相同，它就是一个回文串。因此我们就可以写出动态规划的边界条件：
$$\{\begin{array}{l}P(i,i)=\text{ true }\\ P(i,i+1)=\left(S_i==S_{i+1}\right)\end{array}$$

最终的答案即为所有

$P(i,j)=\text{true}中j-i+1$（即子串长度）的最大值。

**注意：**在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。

class Solution:
    def longestPalindrome(self, s: str) -> str:
        n = len(s)
        dp = [[False] * n for _ in range(n)]
        ans = ""
        # 枚举子串的长度 l+1
        for l in range(n):
            # 枚举子串的起始位置 i，这样可以通过 j=i+l 得到子串的结束位置
            for i in range(n):
                j = i + l
                if j >= len(s):
                    break
                if l == 0:
                    dp[i][j] = True
                elif l == 1:
                    dp[i][j] = (s[i] == s[j])
                else:
                    dp[i][j] = (dp[i + 1][j - 1] and s[i] == s[j])
                if dp[i][j] and l + 1 > len(ans):
                    ans = s[i:j+1]
        return ans

复杂度分析：

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

2. 空间复杂度 $O(n^2)$，即存储动态规划状态需要的空间。

2.2 中心扩展法

观察一下方法一中的状态转移方程：
$$\{\begin{array}{ll}P(i,i)& =\text{ true }\\ P(i,i+1)& =\left(S_i==S_{i+1}\right)\\ P(i,j)& =P(i+1,j-1)\wedge \left(S_i==S_j\right)\end{array}$$

其中的状态转移链:

$$P(i,j)\leftarrow P(i+1,j-1)\leftarrow P(i+2,j-2)\leftarrow \cdots \leftarrow \text{ 某一边界情况 }$$

可以发现，所有的状态在转移的时候的可能性都是唯一的。也就是说，我们可以从每一种边界情况开始「扩展」，也可以得出所有的状态对应的答案。

边界情况即为子串长度为 1 或 2 的情况。我们枚举每一种边界情况，并从对应的子串开始不断地向两边扩展。如果两边的字母相同，我们就可以继续扩展，例如从 P(i+1,j−1) 扩展到 P(i,j)；如果两边的字母不同，我们就可以停止扩展，因为在这之后的子串都不能是回文串了。

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]

复杂度分析

1. 时间复杂度：$O(n^2)$，其中 n 是字符串的长度。长度为 1 和 2 的回文中心分别有 n 和 n−1 个，每个回文中心最多会向外扩展 O(n) 次。
2. 空间复杂度：O(1)。

2.3 Manacher 算法

Manacher 算法的复杂度为 O(n)

1. 时间复杂度：O(n)，其中 n 是字符串的长度。由于对于每个位置，扩展要么从当前的最右侧臂长 right 开始，要么只会进行一步，而 right 最多向前走 O(n) 步，因此算法的复杂度为 O(n)。
2. 空间复杂度：O(n)，我们需要 O(n) 的空间记录每个位置的臂长。

见文末参考的链接

参考：

LeetCode官方题解