求一个字符串中的最长回文字符串

1. 参考文章http://www.leetcode.com/2011/11/longest-palindromic-substring-part-i.html

2. 文章中阐述了五种方法

　　（1）将str反转然后得到rstr，然后求str和rstr的最长公共子串。每次得到一个最长公共子串候选，还需要对子串下标和反转子串的原始下标进行判断，看是否相等：相等则得到的是合理的回文串；否则不合理。如果求最长公共子串使用DP算法，则时间复杂度为O(N²)，空间复杂度为O(N²)；如果采用广义后缀树（GST），则时间复杂度为O(2N)（具体算法还没细看）。

　　（2）暴力搜索，时间复杂度为O(N³)（代码中的方法1）

　　（3）动态规划时间复杂度为O(N²)，空间复杂度为O(N²)（代码中的方法2）

　　（4）从中间到两边扩展判断，时间复杂度为O(N²)，空间复杂度为O(1)（代码中的方法3）

　　（5）线性算法，这个算法技巧性非常强，有些地方还不是很清楚。时间复杂度为O(N)，空间复杂度为O(N)（代码中的方法5）

3. 重点掌握（2）（3）（4）

4. 感觉直接使用后缀树也可以得到线性时间的算法，具体算法有空实现。

5. 代码如下：

#include <iostream>
#include <cassert>
#include <string>
#include <algorithm>
using namespace std;

//方法一：暴力搜索
string IsPalindrome1(string str)
{
    if (str=="")
    {
        return "";
    }
    int n=str.length();
    int maxLength=-1;
    int maxIndex;
    for (int i=0;i<n;i++)
    {
        for (int j=i;j<n;j++)
        {
            int start=i;
            int end=j;
            bool flag=true;
            while (start<=end)
            {
                if (str[start]!=str[end])
                {
                    flag=false;
                    break;
                }
                start++;
                end--;
            }
            int tmpLength=j-i+1;
            if (flag && tmpLength>maxLength)
            {
                maxLength=tmpLength;
                maxIndex=i;
            }
        }
    }
    return str.substr(maxIndex,maxLength);
}

//方法2：动态规划
string IsPalindrome2(string str)
{
    if (str=="")
    {
        return "";
    }
    int n=str.length();
    int maxIndex=0;
    int maxLength=1;
    bool IsPal[1000][1000]={false};
    //bool **IsPal=new bool*[n];
    //for (int i=0;i<n;i++)
    //{
    //    IsPal[i]=new bool[n];
    //}
    //for (int i=0;i<n;i++)
    //{
    //    for (int j=0;j<n;j++)
    //    {
    //        IsPal[i][j]=false;
    //    }
    //}
    for (int i=0;i<n;i++)
    {
        IsPal[i][i]=true;
    }
    for (int i=0;i<n-1;i++)
    {
        if (str[i]==str[i+1])
        {
            IsPal[i][i+1]=true;
            maxIndex=i;
            maxLength=2;
        }
    }
    for (int len=3;len<=n;len++)
    {
        for (int i=0;i<=n-len;i++)
        {
            int j=i+len-1;
            if (IsPal[i+1][j-1] && str[i]==str[j])
            {
                IsPal[i][j]=true;
                maxIndex=i;
                maxLength=len;
            }
        }
    }
    //for (int i=0;i<n;i++)
    //{
    //    delete[] IsPal[i];
    //}
    //delete[] IsPal;
    return str.substr(maxIndex,maxLength);
}


//从中心向两端扩展
string expandAroundCenter(string s,int c1,int c2)
{
    int l=c1;
    int r=c2;
    int n=s.length();
    while (l>=0 && r<=n-1 && s[l]==s[r])
    {
        l--;
        r++;
    }
    return s.substr(l+1,r-l-1);
}

//方法3：从中心向两端扩展
string IsPalindrome3(string str)
{
    int n=str.length();
    if (n==0)
    {
        return "";
    }
    string longest=str.substr(0,1);
    for (int i=0;i<n-1;i++)
    {
        string p1=expandAroundCenter(str,i,i);
        if (p1.length()>longest.length())
        {
            longest=p1;
        }
        string p2=expandAroundCenter(str,i,i+1);
        if (p2.length()>longest.length())
        {
            longest=p2;
        }
    }
    return longest;
}

//方法5预处理
//若输入str="abba"
//则输出"^#a#b#b#a#$"
string preProcess(string str)
{
    int n=str.length();
    if (n==0)
    {
        return "^$";
    }
    string ret="^";
    for (int i=0;i<n;i++)
    {
        ret=ret+"#"+str.substr(i,1);
    }
    ret+="#$";
    return ret;
}
//方法5：
string IsPalindrome5(string str)
{
    string T=preProcess(str);
    int n=T.length();
    int *P=new int[n];
    int C=0;    //对称中心
    int R=0;    //对此字符串的最右端边界
    for (int i=1;i<n-1;i++)
    {
        int i_mirror=2*C-i;    //
        P[i]=(R>i)?min(R-i,P[i_mirror]):0;
        //以i为中心向两端扩充
        while (T[i+1+P[i]]==T[i-1-P[i]])
        {
            P[i]++;
        }
        //如果以i为中心扩展的回文字符串右边界
        //超过R则更新C和R
        if (i+P[i]>R)
        {
            C=i;
            R=i+P[i];
        }
    }
    int maxLen=0;
    int currentIndex=0;
    //搜索最大len和对应下标
    for (int i=0;i<n-1;i++)
    {
        if (P[i]>maxLen)
        {
            maxLen=P[i];
            currentIndex=i;
        }
    }
    delete[] P;
    return str.substr((currentIndex-1-maxLen)/2,maxLen);
}
int main()
{
    string str1="aaaaaaaa";
    string str2="abc";
    string str3="babcbabcbaccba";
    cout<<IsPalindrome1(str1)<<endl;
    cout<<IsPalindrome1(str2)<<endl;
    cout<<IsPalindrome1(str3)<<endl;

    cout<<IsPalindrome2(str1)<<endl;
    cout<<IsPalindrome2(str2)<<endl;
    cout<<IsPalindrome2(str3)<<endl;

    cout<<IsPalindrome3(str1)<<endl;
    cout<<IsPalindrome3(str2)<<endl;
    cout<<IsPalindrome3(str3)<<endl;

    cout<<IsPalindrome5(str1)<<endl;
    cout<<IsPalindrome5(str2)<<endl;
    cout<<IsPalindrome5(str3)<<endl;

}