LeetCode 5 Longest Palindromic Substring（最长回文子串，暴力剪枝/DP/曼彻斯特算法）

Longest Palindromic Substring

题目链接：Longest Palindromic Substring

Description

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example:

Input: “babad”

Output: “bab”

Note: “aba” is also a valid answer.

Example:

Input: “cbbd”

Output: “bb”

解题思路

题意很简单，就是求一个字符串的最长回文字串。解题思路也有很多种，普通的思路就是遍历对称中心，从中心向两头扩散，看最长扩散距离即得到最长回文子串。这种暴力的方法显然是O(n^2)的复杂度，但是可以通过剪枝得到很好的优化，比如在遍历中心时若一直是一个重复字母，则可以跳过这些字母。

另外一个自然的想法是利用动态规划（DP）的思路来求解，dp[i][j]存储从第i位开始到第j位结束的子串是否为回文串，遍历开始位置i和结束位置j，也可以找到最长回文子串。这个方法也是O(n^2)的复杂度，但是通过DP来做不好进行优化，效果比第一种差多了。

以上的算法的复杂度都是O(n^2)，实际上对于最长回文子串有一种O(n)的算法，那就是曼彻斯特算法（Manacher’s algorithm）。这个算法利用了DP的思想，并巧妙地将奇数长度和偶数长度的情况整合起来，求出以每个字符为对称中心时的回文长度。具体介绍可以参考这篇博客：Manacher’s ALGORITHM: O(n)时间求字符串的最长回文子串。

我分别使用上述三种方法实现了最长回文子串的查找，三种方法的耗时分别为：3ms，119ms和9ms。可以看到，第1种方法和第3种方法比第2种方法快很多，但是第1种方法要比第3种方法还要快。我分析可能是由于测试样例中重复元素较多（即第1种方法基本上也是O(n)的复杂度），而第3种方法还需要遍历一遍构造一个长度为2n的字符串，故而比第1种算法要慢一些。

AC代码

暴力剪枝

class Solution {
public:
string longestPalindrome(string s) {
int len=s.size();
if(len<2)   return s;
int maxlen=1,maxleft=0,left,right;
for(int start=0;start<len&&len-start>maxlen/2;){//注意这里，len-start>maxlen/2剪枝的提升运算效果很明显
left=right=start;
while(right<len&&s[right]==s[right+1]){//排除重复元素影响，剪枝核心
right++;
}
start=right+1;
while(right<len-1&&left>0&&s[right+1]==s[left-1]){//从对称中心向两头遍历
right++;
left--;
}
if(right-left+1>maxlen){
maxlen=right-left+1;
maxleft=left;
}
}
return s.substr(maxleft,maxlen);
}
};

动态规划

class Solution {
public:
string longestPalindrome(string s) {
if(s.size()<2)  return s;
int len=s.size();
vector<vector<bool> >dp(len,vector<bool>(len,0));
int maxlen=1,maxleft=0;
dp[len-1][len-1]=true;
for(int i=len-2;i>=0;i--){
int maxright=i;
for(int j=i+1;j<len;j++){
if(s[i]==s[j]&&(j-i<3||dp[i+1][j-1])){
dp[i][j]=true;
maxright=j;
}
else{
dp[i][j]=false;
}
}
if(maxright-i+1>maxlen){
maxlen=maxright-i+1;
maxleft=i;
}
}
return s.substr(maxleft,maxlen);
}
};

Manacher算法

class Solution {
public:
string longestPalindrome(string s) {
string t="";
for(int i=0;i<s.size();i++){//重构字符串
//t+="#"+s[i];//这样写会出错
t+="#"+s.substr(i,1);
}
t+="#";
vector<int> p(t.size(),0);
int id=0,mx=0,maxlen=0,center=0,tlen=t.size();
for(int i=1;i<tlen;i++){
p[i]=(mx>i)?min(mx-i,p[2*id-i]):1;
while(i+p[i]<tlen&&i-p[i]>=0&&t[i+p[i]]==t[i-p[i]]) p[i]++;
if(i+p[i]>mx){
id=i;
mx=i+p[i];
}
if(p[i]-1>maxlen){
maxlen=p[i]-1;
center=i;
}
}
return s.substr((center-maxlen)/2,maxlen);
}
};