题目
给定一个字符串 s
,找到 s
中最长的回文子串。你可以假设 s
的最大长度为 1000。
示例 1:
输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2:
输入: "cbbd"
输出: "bb"
题解
摘要
这篇文章是为中级读者而写的。它介绍了回文,动态规划以及字符串处理。请确保你理解什么是回文。回文是一个正读和反读都相同的字符串,例如,“aba” 是回文,而 “abc” 不是。
解决方案
方法一:最长公共子串
常见错误
有些人会忍不住提出一个快速的解决方案,不幸的是,这个解决方案有缺陷(但是可以很容易地纠正):
反转 SS,使之变成 S’S′。找到 SS 和 S’S′ 之间最长的公共子串,这也必然是最长的回文子串。
这似乎是可行的,让我们看看下面的一些例子。
例如,S*=“caba” , S′=“abac”:
SS 以及 S’S′ 之间的最长公共子串为“aba”,恰恰是答案。
让我们尝试一下这个例子:S*=“abacdfgdcaba” , S′=“abacdgfdcaba”:
SS 以及 S’S′ 之间的最长公共子串为 “abacd”,显然,这不是回文。
算法
我们可以看到,当 SS 的其他部分中存在非回文子串的反向副本时,最长公共子串法就会失败。为了纠正这一点,每当我们找到最长的公共子串的候选项时,都需要检查子串的索引是否与反向子串的原始索引相同。如果相同,那么我们尝试更新目前为止找到的最长回文子串;如果不是,我们就跳过这个候选项并继续寻找下一个候选。
这给我们提供了一个复杂度为 O(n2)动态规划解法,它将占用 O(n2)的空间(可以改进为使用 O(n) 的空间)。请在这里阅读更多关于最长公共子串的内容。
方法二:暴力法
很明显,暴力法将选出所有子字符串可能的开始和结束位置,并检验它是不是回文。
复杂度分析
-
时间复杂度:O(n3),假设 n 是输入字符串的长度,则 ( n 2 ) = n ( n − 1 ) 2 \binom{n}{2} = \frac{n(n-1)}{2} (2n)=2n(n−1) 为此类子字符串(不包括字符本身是回文的一般解法)的总数。因为验证每个子字符串需要 O(n) 的时间,所以运行时间复杂度是 O ( n 3 ) O(n^3) O(n3)。
-
空间复杂度:O(1)。
方法三:动态规划
为了改进暴力法,我们首先观察如何避免在验证回文时进行不必要的重复计算。考虑 “ababa” 这个示例。如果我们已经知道 “bab” 是回文,那么很明显,“ababa” 一定是回文,因为它的左首字母和右尾字母是相同的。
我们给出 P(i,j)的定义如下:
$ P(i,j) = \begin{cases} \text{true,} &\quad\text{如果子串} S_i \dots S_j \text{是回文子串}\ \text{false,} &\quad\text{其它情况} \end{cases} $*
因此,
$ P(i, j) = ( P(i+1, j-1) \text{ and } S_i == S_j )$
基本示例如下:
P(i, i) = true
$ P(i, i+1) = ( S_i == S_{i+1} )$
这产生了一个直观的动态规划解法,我们首先初始化一字母和二字母的回文,然后找到所有三字母回文,并依此类推…
复杂度分析
- 时间复杂度:O(n2), 这里给出我们的运行时间复杂度为 O(n2) 。
- 空间复杂度:O(n2), 该方法使用 O(n2) 的空间来存储表。
补充练习
你能进一步优化上述解法的空间复杂度吗?
方法四:中心扩展算法
事实上,只需使用恒定的空间,我们就可以在 O(n2) 的时间内解决这个问题。
我们观察到回文中心的两侧互为镜像。因此,回文可以从它的中心展开,并且只有 2n - 1 个这样的中心。
你可能会问,为什么会是 2n - 1个,而不是 n个中心?原因在于所含字母数为偶数的回文的中心可以处于两字母之间(例如“abba” 的中心在两个 ‘b’ 之间)。
public String longestPalindrome(String s) {
if (s == null || s.length() < 1) return "";
int start = 0, end = 0;
for (int i = 0; i < s.length(); i++) {
int len1 = expandAroundCenter(s, i, i);
int len2 = expandAroundCenter(s, i, i + 1);
int len = Math.max(len1, len2);
if (len > end - start) {
start = i - (len - 1) / 2;
end = i + len / 2;
}
}
return s.substring(start, end + 1);
}
private int expandAroundCenter(String s, int left, int right) {
int L = left, R = right;
while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
L--;
R++;
}
return R - L - 1;
}
复杂度分析
-
时间复杂度:O(n2), 由于围绕中心来扩展回文会耗去 O(n)的时间,所以总的复杂度为 O(n2)。
-
空间复杂度:O(1)。
方法五:Manacher 算法
还有一个复杂度为 O(n) 的 Manacher 算法,你可以在这里找到详尽的解释。然而,这是一个非同寻常的算法,在45分钟的编码时间内提出这个算法将会是一个不折不扣的挑战。但是,请继续阅读并理解它,我保证这将是非常有趣的。
感想
方法五的马拉车算法在这里介绍一下:(引用自Manacher算法-经典算法与数据结构 )
参考这个自己写出的题解在这个:
class Solution {
public String longestPalindrome(String s) {
String str = InsertSharpToString(s);
String output = Manacher(str);
return output;
}
//构造插入了'#'的以'$'开头的新字符串
private String InsertSharpToString(String aS){
StringBuilder sb= new StringBuilder();
sb.append('$');
for(int i =0;i<aS.length();i++){
sb.append('#');
sb.append(aS.charAt(i));
}
sb.append('#');
String str = sb.toString();
return str;
}
//马拉车算法,复杂度O(n)
private String Manacher(String aStr){
int len = aStr.length();
int[] p=new int[len];//辅助数组,p[i]存储以i为中心的最长回文的半径
int mx=0;//代表以id为中心回文的右边界,mx=id+p[id]
int id=-1;//id必须赋个初值,java方法局部变量不初始化的话无法使用。
int max_len = -1;
int max=-1;
for(int i=1;i<len;i++){
if(i<mx) p[i]= (p[2*id-i]>mx-i)?mx-i:p[2*id-i];//p[i]取p[2*id-i]和mx-i的最小值。2*id-i是i关于id的对称点。
else p[i]=1;
while(i+p[i]<len && aStr.charAt(i-p[i])==aStr.charAt(i+p[i]))/*需要边界判断,因为java String结尾没有'\0' */
p[i]++;
// 我们每走一步 i,都要和 mx 比较,我们希望 mx 尽可能的远,这样才能更有机会执行 if (i < mx)这句代码,从而提高效率
if(mx<i+p[i]){
id=i;
mx=i+p[i];
}
if(max_len<p[i]-1){
max_len=p[i]-1;
max=i;
}
}
StringBuilder sb= new StringBuilder();
for(int i=max-p[max]+1;i<max+p[max];i++){
if (aStr.charAt(i)!='#') {
sb.append(aStr.charAt(i));
}
}
return (sb.toString());
}
}
一:背景
给定一个字符串,求出其最长回文子串。例如:
- s=“abcd”,最长回文长度为 1;
- s=“ababa”,最长回文长度为 5;
- s=“abccb”,最长回文长度为 4,即bccb。
以上问题的传统思路大概是,遍历每一个字符,以该字符为中心向两边查找。其时间复杂度为 O ( n 2 ) O(n^2) O(n2),效率很差。
1975年,一个叫Manacher的人发明了一个算法,Manacher算法(中文名:马拉车算法),该算法可以把时间复杂度提升到 O ( n ) O(n) O(n)。
二:算法过程分析
由于回文分为偶回文(比如 bccb)和奇回文(比如 bcacb),而在处理奇偶问题上会比较繁琐,所以这里我们使用一个技巧,具体做法是:在字符串首尾,及各字符间各插入一个字符(前提这个字符未出现在串里)。
举个例子:s="abbahopxpo"
,转换为s_new="$#a#b#b#a#h#o#p#x#p#o#"
(这里的字符 $
只是为了防止越界,下面代码会有说明),如此,s 里起初有一个偶回文abba
和一个奇回文opxpo
,被转换为#a#b#b#a#
和#o#p#x#p#o#
,长度都转换成了奇数。
定义一个辅助数组int p[]
,其中p[i]
表示以 i 为中心的最长回文的半径,例如:
i | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s_new[i] | $ | # | a | # | b | # | b | # | a | # | h | # | o | # | p | # | x | # | p | # |
p[i] | 1 | 2 | 1 | 2 | 5 | 2 | 1 | 2 | 1 | 2 | 1 | 2 | 1 | 2 | 1 | 4 | 1 | 2 | 1 |
可以看出,p[i] - 1
正好是原字符串中最长回文串的长度。
接下来的重点就是求解 p 数组:
设置两个变量,mx 和 id 。mx 代表以 id 为中心的最长回文的右边界,也就是mx = id + p[id]
。
假设我们现在求p[i]
,也就是以 i 为中心的最长回文半径,如果i < mx
,如上图,那么:
if (i < mx)
p[i] = min(p[2 * id - i], mx - i);
2 * id - i
为 i 关于 id 的对称点,即上图的 j 点,而p[j]表示以 j 为中心的最长回文半径,因此我们可以利用p[j]
来加快查找。
三:代码
C++代码如下:
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
char s[1000];
char s_new[2000];
int p[2000];
int Init()
{
int len = strlen(s);
s_new[0] = '$';
s_new[1] = '#';
int j = 2;
for (int i = 0; i < len; i++)
{
s_new[j++] = s[i];
s_new[j++] = '#';
}
s_new[j] = '\0'; // 别忘了哦
return j; // 返回 s_new 的长度
}
int Manacher()
{
int len = Init(); // 取得新字符串长度并完成向 s_new 的转换
int max_len = -1; // 最长回文长度
int id;
int mx = 0;
for (int i = 1; i < len; i++)
{
if (i < mx)
p[i] = min(p[2 * id - i], mx - i); // 需搞清楚上面那张图含义, mx 和 2*id-i 的含义
else
p[i] = 1;
while (s_new[i - p[i]] == s_new[i + p[i]]) // 不需边界判断,因为左有'$',右有'\0'
p[i]++;
// 我们每走一步 i,都要和 mx 比较,我们希望 mx 尽可能的远,这样才能更有机会执行 if (i < mx)这句代码,从而提高效率
if (mx < i + p[i])
{
id = i;
mx = i + p[i];
}
max_len = max(max_len, p[i] - 1);
}
return max_len;
}
int main()
{
while (printf("请输入字符串:\n"))
{
scanf("%s", s);
printf("最长回文长度为 %d\n\n", Manacher());
}
return 0;
}
四:算法复杂度分析
文章开头已经提及,Manacher算法为线性算法,即使最差情况下其时间复杂度亦为 O ( n ) O(n) O(n),在进行证明之前,我们还需要更加深入地理解上述算法过程。
根据回文的性质,p[i]
的值基于以下三种情况得出:
(1):j 的回文串有一部分在 id 的之外,如下图:
上图中,黑线为 id 的回文,i 与 j 关于 id 对称,红线为 j 的回文。那么根据代码此时p[i] = mx - i
,即紫线。那么p[i]
还可以更大么?答案是不可能!见下图:
假设右侧新增的紫色部分是p[i]
可以增加的部分,那么根据回文的性质,a 等于 d ,也就是说 id 的回文不仅仅是黑线,而是黑线+两条紫线,矛盾,所以假设不成立,故p[i] = mx - i
,不可以再增加一分。
(2):j 回文串全部在 id 的内部,如下图:
根据代码,此时p[i] = p[j]
,那么p[i]
还可以更大么?答案亦是不可能!见下图:
假设右侧新增的红色部分是p[i]
可以增加的部分,那么根据回文的性质,a 等于 b ,也就是说 j 的回文应该再加上 a 和 b ,矛盾,所以假设不成立,故p[i] = p[j]
,也不可以再增加一分。
(3):j 回文串左端正好与 id 的回文串左端重合,见下图:
根据代码,此时p[i] = p[j]
或p[i] = mx - i
,并且p[i]
还可以继续增加,所以需要
while (s_new[i - p[i]] == s_new[i + p[i]])
p[i]++;
根据(1)(2)(3),很容易推出Manacher算法的最坏情况,即为字符串内全是相同字符的时候。在这里我们重点研究Manacher()中的for语句,推算发现for语句内平均访问每个字符5次,即时间复杂度为: T w o r s t ( n ) = O ( n ) T_{worst}(n)=O(n) Tworst(n)=O(n)。
同理,我们也很容易知道最佳情况下的时间复杂度,即字符串内字符各不相同的时候。推算得平均访问每个字符4次,即时间复杂度为: T b e s t ( n ) = O ( n ) T_{best}(n)=O(n) Tbest(n)=O(n)。
综上,Manacher算法的时间复杂度为 O ( n ) O(n) O(n)。