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);
    }
};