leetcode5-Longest Palindromic Substring(最长回文子串)

问题描述：

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.

给定一个字符串，求出其最长回文子串。注意与子序列的区别：子串连续。

问题求解：

方法一：暴力法。
求出每一个子串，之后判断是不是回文，找到最长的那个。

求每一个子串时间复杂度O(N^2)，判断子串是不是回文O(N)，两者是相乘关系，所以时间复杂度为O(N^3)。

有可能超时。

class Solution {
public:
    string longestPalindrome(string s) {
        int length=s.size();//字符串长度  
        if(length==1) return s;
        int maxlength=0;//最长回文字符串长度  
        int start;//最长回文字符串起始地址  
        for(int i=0;i<length;i++)//起始地址  
            for(int j=i+1;j<length;j++)//结束地址  
            {  
                int tmp1,tmp2;  
                for(tmp1=i,tmp2=j;tmp1<tmp2;tmp1++,tmp2--)//判断是不是回文  
                {  
                    if(s.at(tmp1)!=s.at(tmp2))  
                        break;  
                }  
                if(tmp1>=tmp2&&j-i>maxlength)  
                {  
                    maxlength=j-i+1;  
                    start=i;  
                }  
            }  
        if(maxlength>0)  
            return s.substr(start,maxlength);//求子串  
        return NULL;  
    }
};

方法二：利用著名的Manacher算法，O(N)时间O(N)空间。

首先我们把字符串S改造一下变成T，改造方法是：在S的每个字符之间和S首尾都插入一个”#”。很巧妙地把奇数长度回文串与偶数长度回文串统一考虑。

例如，S="abaaba"，那么T="#a#b#a#a#b#a#"。

这样一来，原来的奇数长度回文串还是奇数长度，偶数长度的也变成以‘#’为中心奇数回文串了。

为了防止求P[i]向两边扩展时可能数组越界，我们需要在数组最前面和最后面分别加一个特殊字符如^ 和 $，最终T="^#a#b#a#a#b#a#$"。

为了改进最坏的情况，我们把各个Ti处的回文半径存储到数组P，用P[i]表示以Ti为中心的回文长度。那么当我们求出所有的P[i]，取其中最大值就能找到最长回文子串了。

对于上文的示例，我们先直接写出所有的P研究一下。

i = 0 1 2 3 4 5 6 7 8 9 A B C
T = # a # b # a # a # b # a #
P = 0 1 0 3 0 1 6 1 0 3 0 1 0

显然最长子串就是以P[6]为中心的”abaaba”。

你是否发现了，在插入”#”后，长度为奇数和偶数的回文都可以优雅地处理了？这就是其用处。

我们来看一个重叠得更典型的例子，即S=”babcbabcbaccba”。

扩展过程：

总结一下上述分析过程，就是这个算法的关键部分了。

if P[ i' ] < R – i,

then P[ i ] ← P[ i' ]

else P[ i ] ≥ R - i. (此时要穿过R逐个字符判定P[i]).

很明显C的位置也是需要移动的，这个很容易：

如果i处的回文超过了R，那么就C=i，同时相应改变L和R即可。

代码如下：

class Solution {
public:
    // Transform S into T.
    // For example, S = "abba", T = "^#a#b#b#a#$".
    // ^ and $ signs are sentinels appended to each end to avoid bounds checking
    string preProcess(string s) {
        int n = s.length();
        if (n == 0) return "^$";

        string ret = "^";
        for (int i = 0; i < n; i++)
        {//截取字符串内容最好用s.substr(i,1),若用s[i]与“#”相加出现错误
            ret += "#" + s.substr(i, 1);
        }
        ret += "#$";
        return ret;
    }

    string longestPalindrome(string s) {
        string T = preProcess(s);//(1)预处理
        int n = T.length();
        //int *P = new int[n];
        vector<int> P(n);
        int C = 0, R = 0;
        for (int i = 1; i < n-1; i++) {
            //(2)i以C为中心的对称点
            int i_mirror = 2*C-i; // equals to i' = C - (i-C)
            //(3)若R>i,说明当前i在C和R之间，可以利用回文的对称属性
            P[i] = (R > i) ? min(R-i, P[i_mirror]) : 0;
            //(4)以i为中心扩展回文的长度
            while (T[i + 1 + P[i]] == T[i - 1 - P[i]])
                P[i]++;
            //(5)如果以i为中心的回文扩展超出了右边界R，则更新回文中心C和回文边界R
            if (i + P[i] > R) {
                C = i;
                R = i + P[i];
            }
        }
        //以上操作得到了一个P[]数组
        //(6)在P中找到最大元素，即为最长回文串的长度
        int maxLen = 0;
        int centerIndex = 0;
        for (int i = 1; i < n-1; i++) {
            if (P[i] > maxLen) {
                maxLen = P[i];//回文长度
                centerIndex = i;//回文中心
            }
        }
        //delete[] P;
        //(7)上述得到的centerIndex是在T中的，要以此得到在S中的
        //最长回文子串的起点：(centerIndex - 1 - maxLen)/2
        return s.substr((centerIndex - 1 - maxLen)/2, maxLen);
    }
};

参考：http://articles.leetcode.com/longest-palindromic-substring-part-ii