给定一个字符串 s,找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
回文:字符串对称。“abba” "aba"
测试用例
示例1:
输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例2:
输入: “abbc”
输出: “bb”
解题思路
动态规划
对于一个子串而言,如果它是回文串,并且长度大于 2
,那么将它首尾的两个字母去除之后,它仍然是个回文串。例如对于字符串 “ababa”,如果我们已经知道 “bab” 是回文串,那么 “ababa” 一定是回文串,这是因为它的首尾两个字母都是 “a”。
根据这样的思路,我们就可以用动态规划的方法解决本题。我们用 P(i, j) 表示字符串 s 的第 i 到 j 个字母组成的串(下文表示成 s [ i : j ] s[i : j] s[i:j])是否为回文串:
P ( i , j ) = { t r u e , 如 果 子 串 S i . . . S j 是 回 文 串 f a l s e , 其 它 情 况 P(i,j)=\begin{cases} true, 如果子串 S_i...S_j 是回文串\\ false, 其它情况 \end{cases} P(i,j)={
true,如果子串Si...Sj是回文串false,其它情况
这里的「其它情况」包含两种可能性:
-
s [ i , j ] s[i, j] s[i,j] 本身不是一个回文串;
-
i > j,此时 s [ i , j ] s[i, j] s[i,j] 本身不合法。
那么我们就可以写出动态规划的状态转移方程:
P ( i , j ) = P ( i + 1 , j − 1 ) ∧ ( S i = = S j ) P(i,j)=P(i+1,j-1)∧(S_i==S_j) P(i,j)=P(i+1,j−1)∧(Si==Sj)
也就是说,只有 s [ i + 1 : j − 1 ] s[i + 1 : j − 1] s[i+1:j−1]是回文串,并且 s 的第 i 和 j 个字母相同时, s [ i , j ] s[i, j] s[i,j]才会是回文串。
我们还需要考虑动态规划中的边界条件
,即子串的长度为 1 或 2
。
- 对于长度为 1 的子串,它显然是个回文串;
- 对于长度为 2 的子串,只要它的两个字母相同,它就是一个回文串。
因此我们就可以写出动态规划的边界条件:
{ P ( i , j ) = t r u e P ( i , i + 1 ) = ( S i = = S i + 1 ) \begin{cases} P(i,j)=true\\ P(i,i+1)=(S_i==S_{i+1}) \end{cases} { P(i,j)=trueP(i,i+1)=(Si==Si+1)
根据这个思路,我们就可以完成动态规划了,最终的答案即为所有 P(i, j) = true 中 j − i + 1(即子串长度)的最大值
。
注意:在状态转移方程中,我们是从长度较短的字符串向长度较长的字符串进行转移的,因此一定要注意动态规划的循环顺序
。
由 P ( i + 1 , j − 1 ) P(i+1,j-1) P(i+1,j−1)的状态 ⇒ P ( i , j ) P(i,j) P(i,j)的状态。
Code
class Solution {
public String longestPalindrome(String s) {
int n = s.length();
if (n < 2) {
return s;
}
int max = 1,p = 0;
// dp[i][j] 表示 s[i, j] 是否是回文串
boolean[][] dp = new boolean[n][n];
char[] charArray = s.toCharArray();
for (int i = 0; i < n; i++) {
dp[i][i] = true;
}
//注意循环顺序 从上到下 从左到右
for (int j = 1; j < n; j++) {
for (int i = 0; i < j; i++) {
if (charArray[i] != charArray[j]) {
dp[i][j] = false;
} else {
if (j - i < 3) {
dp[i][j] = true;
} else {
dp[i][j] = dp[i + 1][j - 1];
}
}
if (dp[i][j] && j - i + 1 > max) {
max = j - i + 1;
p = i;
}
}
}
return s.substring(p, p + max);
}
}
复杂度分析
- 时间复杂度: O ( n 2 ) O(n^2) O(n2),其中 n 是字符串的长度。动态规划的状态总数为 O ( n 2 ) O(n^2) O(n2),对于每个状态,我们需要转移的时间为 O(1)。
- 空间复杂度: O ( n 2 ) O(n^2) O(n2),即存储动态规划状态需要的空间。