Longest Palindromic Substring [Leetcode 解题报告]

Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.

题目大意就是给定一个字符串，返回该字符串的最长回文子串。
这个我在这里说三种方法：
1）暴力搜索
该方法从前往后以此判断以该字母为首字母的最长子串，遍历一遍，返回最大的那个子串，时间复杂度太高，大概为O（n*n），一般不满足要求。
2）动态规划
主要思想是：状态转移，已知前k个字母的最长子串情况下，求k+1个字母的最长回文子串。首先记录下当前状态的最长子串的起始点start和长度len，然后在字符串尾端加入一个字母，判断以新加入节点为结尾，向前延伸len+1个字符串是否为回文子串，如果是则更新start和len，否则判断延伸len+2个字符是否为回文串，如果是则更新，否则继续加入新的字符，直至结尾，得到最长回文子串。（此处为何向前延伸len+1和len+2，不太好解释，用笔在纸上画画就清楚了），代码如下：

 bool isPalindrome(string s,int start,int end){
        for(int i=start,j=end;i<=j;i++,j--){
            if(s[i]!=s[j])return false;

        }
        return true;
    }
    string longestPalindrome(string s) {
        int n=s.size();
        int start=0,len=0;
        for(int i=0;i<n;i++){
            if(isPalindrome(s,i-len,i)){
                start=i-len;
                len++;
            }
            else if(i-len-1>=0&&isPalindrome(s,i-len-1,i)){
                start=i-len-1;
                len=len+2;
            }

        }
        return s.substr(start,len);
    }

3）这个方法比较有名，复杂度也是线性的，俗称Manacher算法。算法的核心就在这一句上了：p[i] = min(p[2*id-i], p[id] + id - i);
这个算法有一个很巧妙的地方，它把奇数的回文串和偶数的回文串统一起来考虑了。这一点一直是在做回文串问题中时比较烦的地方。这个算法还有一个很好的地方就是充分利用了字符匹配的特殊性，避免了大量不必要的重复匹配。
算法大致过程是这样。先在每两个相邻字符中间插入一个分隔符，当然这个分隔符要在原串中没有出现过。一般可以用‘#’分隔。这样就非常巧妙的将奇数长度回文串与偶数长度回文串统一起来考虑了（见下面的一个例子，回文串长度全为奇数了），然后用一个辅助数组P记录以每个字符为中心的最长回文串的信息。P［id］记录的是以字符str［id］为中心的最长回文串，当以str［id］为第一个字符，这个最长回文串向右延伸了P［id］个字符。
原串： w aa bwsw f d
新串： # w# a # a # b# w # s # w # f # d #
辅助： 1 2 1 2 3 2 1 2 1 2 1 4 1 2 1 2 1 2 1
这里有一个很好的性质，P［id］-1就是该回文子串在原串中的长度（包括‘#’）。如果这里不是特别清楚，可以自己拿出纸来画一画，自己体会体会。当然这里可能每个人写法不尽相同，不过我想大致思路应该是一样的吧。
好，我们继续。现在的关键问题就在于怎么在O（n）时间复杂度内求出P数组了。只要把这个P数组求出来，最长回文子串就可以直接扫一遍得出来了。
由于这个算法是线性从前往后扫的。那么当我们准备求P［i］的时候，i以前的P［j］我们是已经得到了的。我们用mx记在i之前的回文串中，延伸至最右端的位置。同时用id这个变量记下取得这个最优mx时的id值。（注：为了防止字符比较的时候越界，我在这个加了‘#’的字符串之前还加了另一个特殊字符‘$’，故我的新串下标是从1开始的）

if( mx > i) p[i]=MIN( p[2*id-i], mx-i);

就是当前面比较的最远长度mx>i的时候，P［i］有一个最小值。这个算法的核心思想就在这里，为什么P数组满足这样一个性质呢?

代码如下：

string longestPalindrome(string s) {
        string s1;
        s1.resize(2*s.length()+2);
        s1[0]='$';
        s1[1]='#';
        for(int i=0;i<s.length();i++){
            s1[(i+1)<<1]=s[i];
            s1[((i+1)<<1)+1]='#';
        }
        int id,i,res=0;
        vector<int> p(s1.length(),0);
        for(i=1,id=0;i<s1.length();i++){
            if(p[id]+id>i)p[i]=min(p[2*id-i],p[id]+id-i);
            else p[i]=1;
            while(s1[i+p[i]]==s1[i-p[i]])p[i]++;
            if(p[id]+id<p[i]+i)id=i;
            if(p[i]>p[res])res=i;
        }
       if(res%2==0){
            return s.substr((res/2-1)-(p[res]-1)/2,p[res]-1);
        }
        else
        return s.substr((res/2-1)-p[res]/2+1,p[res]-1);
    }