Leetcode|Longest Palindromic Substring(最长回文的几种方法)（Manacher算法）

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^2)时间复杂度 常数空间复杂度

枚举中心位置，然后再在该位置上用扩展法，记录并更新得到的最长的回文长度。（注意奇数长度和偶数长度）

解法2：动态规划 O(n^2)时间复杂度，O(n^2)空间复杂度

思路：dp[i][j]表示字符串s.substr(i,j-i+1) 是否为回文，是就表示其回文长度，不是就是0；

以长度为变化，step为i,j的差，状态方程：dp[i][i+step]=s[i]==s[i+step]&&dp[i+1][i+step-1]!=0?2+dp[i+1][i+step-1]:0;

string longestPalindrome(string s) {
        int n=s.size();
        int dp[n][n];
        memset(dp,0,sizeof(dp));
        int longest=0;
        int start=0,end=0;
        for(int step=0;steplongest){
                    start=i,end=i+step;
                    longest=dp[i][i+step];
                }
            }
        }
        return s.substr(start,end-start+1);
    }

解法3： Manacher算法，线性时间复杂度O(n)[说明方法参考https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.05.md]

优点：利用之前读取的信息，所以快速很多。类似KMP的求next数组，在这里求一个数组p，p[i]表示以s[i]为中心的最大回文长度加1.

为了免除奇数和偶数的麻烦，首先需要变化字符串，插入'#';

ccd变为#c#c#d#

p数组为1232121

接下来怎么计算P[i]呢？Manacher算法增加两个辅助变量id和mx，其中id表示最大回文子串中心的位置，mx则为id+P[id]，也就是最大回文子串的边界。得到一个很重要的结论：

• 如果mx > i，那么P[i] >= Min(P[2 * id - i], mx - i)

下面，令j = 2*id - i，也就是说j是i关于id的对称点。

当 mx - i > P[j] 的时候，以S[j]为中心的回文子串包含在以S[id]为中心的回文子串中，由于i和j对称，以S[i]为中心的回文子串必然包含在以S[id]为中心的回文子串中，所以必有P[i] = P[j]；

当 P[j] >= mx - i 的时候，以S[j]为中心的回文子串不一定完全包含于以S[id]为中心的回文子串中，但是基于对称性可知，下图中两个绿框所包围的部分是相同的，也就是说以S[i]为中心的回文子串，其向右至少会扩张到mx的位置，也就是说 P[i] >= mx - i。至于mx之后的部分是否对称，再具体匹配。

此外，对于 mx <= i 的情况，因为无法对 P[i]做更多的假设，只能让P[i] = 1，然后再去匹配。

string longestPalindrome(string s){
    int n=s.size();
    int p[2*n+1];
    memset(p,0,sizeof(p));
    char *ss=new char[2*n+2];
    for(int i=0;i<2*n+1;i++){
       if(i&0x01) ss[i]=s[(i-1)/2];
       else ss[i]='#';
    }
    ss[2*n+1]='\0';
    int mx=0,id=0;
    int maxIndex=0,max1=0;
    for(int i=0;ss[i]!='\0';i++){
        p[i]=mx>i?min(p[2*id-i],mx-i):1;
        while(i-p[i]>=0&&ss[i+p[i]]==ss[i-p[i]]) p[i]++;
        if(i+p[i]>mx){
            mx=i+p[i];
            id=i;//id为mx最靠右的中心位置
        }
        if(p[i]>max1){
            max1=p[i];
            maxIndex=i;//maxIndex表示p[i]最大的位置
        }
    }
    //找到p[i]最大的那个
    id=maxIndex;
    if(id&0x01) return s.substr((id-1)/2-(p[id]-1)/2,p[id]-1);
    else return s.substr(id/2-(p[id]-1)/2,p[id]-1);
}