5. 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.

题意：

给定一个字符串S，找到给定S字符串中最长的回文子串，可以假定给定的字符串最大长度为1000，字符串中只存在唯一的最长回文子串。

转载：http://www.cnblogs.com/bitzhuwei/p/Longest-Palindromic-Substring-Par-I.html 文章写得非常好，非常清晰，感谢原博主！

常见错误：

有人很快会想到这样一个方法。这个方法有缺陷，不过很容易修正。
<<翻转S成为S’。查找S和S’最长公共子串，就是S的最长回文子串。>>
看起来有道理的样子。用实例检验下。
例如S=”caba”，S’=”abac”。
S和S’的最长公共子串是”aba”，确实是S的最长回文子串。
再看个例子。
S=”abacdfgdcaba”，S’=”abacdgfdcaba”。
S和S’的最长公共子串是”abacd”，不过很明显这不是回文。

思路一：暴力穷举法，时间复杂度为O(N^3)

最简单的就是暴力穷举(Brute Force)对每个start和end位置的子串进行检测，判断其是否回文。显然有C(N,2)（组合）个子串。检测每个子串都需要O(N)的时间，所以此方法的时间复杂度为O(N^3)。

思路二：动态规划法O(N2)时间O(N2)空间

我们可以用动态规划(Dynamic Programming即DP)法对暴力穷举法进行改进。记住，诀窍就是避免重复计算（即重复检测同一子串）。考虑这个例子”ababa”。如果我们已经检测过”bab”是回文，那么只需判断一下最左右的两个字符（即两个a）是否相同即可判定”ababa”是否回文了。
总结起来就是：
定义二维数组P[i,j]用以表示Si…Sj是回文（true）或不是回文（false）
那么可知P[i,j] = (P[i + 1, j - 1] && Si ==Sj)
初始条件是：P[i, i]=true，P[i, i + 1] = (Si == Si+1)
这个DP法的思路就是，首先可以知道单个字符和两个相邻字符是否回文，然后检测连续三个字符是否回文，然后四个。。。
此算法时间复杂度O(N2)，空间复杂度O(N2)。

代码：224ms

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.length();
        if (n<=1) return s;  //处理空串与只有一个字母情况
        
        int longestBegin = 0;
        int maxLen = 0;
        bool table[1000][1000] = {false};  //记录i到j之间是不是回文串
        
        for (int i=0; i<n; i++) {  //处理每个元素本身是回文的
            table[i][i] = true;
        }
        
        for (int i=0; i<n-1; i++) {  //处理如果前后两个元素相同，则为回文串，且长度为2
            if (s[i] == s[i+1]) {
                table[i][i+1] = true;
                longestBegin = i;
                maxLen = 2;
            }
        }
        
        for (int len=3; len<=n; len++) { //动态规划法实现是否为回文串，即i+1、j-1之间为回文串之后再判断该回文串两边的元素是否相等，如果相等则回文串i、j之间也为回文串
            for (int i=0; i<n-len+1; i++) {
                int j = i+len-1;
                if (s[i] == s[j] && table[i+1][j-1]) {
                    table[i][j] = true;
                    longestBegin = i;
                    maxLen = len;
                }
            }
        }
        
        return s.substr(longestBegin, maxLen); 返回最长子串
    }
};

思路三：更简单的算法O(N^2)时间O(1)空间

下面介绍一个O(N2)时间O(1)空间的算法。
回文的特点，就是中心对称。对于有N个字符的字符串S，只有2N-1个中心。
为何是2N-1？因为两个字符之间的空档也可以是一个中心。例如”abba”的两个b中间就是一个中心。
围绕一个中心检测回文需要O(N)时间，所以总的时间复杂度是O(N2)。

代码：C++版：80ms

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.length();
        if (n <= 1) return s;
        
        string longest = s.substr(0,1);
        
        for (int i=0; i<n-1; i++) {
            string p1 = expandAroundCenter(s, i, i);  //以每个元素作为中心旋转点
            if (p1.length() > longest.length()) 
                longest = p1;
            
            string p2 = expandAroundCenter(s, i, i+1);  //以两个元素中间的空白作为中心旋转点
            if (p2.length() > longest.length())
                longest = p2;
        }
        return longest;
    }
    
    string expandAroundCenter(string s, int c1, int c2) {  //计算中心点左右最长的回文子串
        int l = c1, 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);
    }
};

代码：C++版：4ms 用时最短

class Solution {
public:
    string longestPalindrome(string s) {
        if (s.length()<=1) return s;
        
        int min_start = 0, max_len = 1;
        for (int i=0; i<s.size(); ) {
            if (s.size() - i <= max_len/2) 
                break;
            int j = i, k = i;  //i代表当前字符元素，j、k分别为了寻找当前字符i左右两边字符的
            while (k < s.size()-1 && s[k+1] == s[k])  //处理相同两个相邻元素
                ++k;
            i = k + 1;
            while (k < s.size()-1 && j > 0 && s[k+1] == s[j-1]) {  //如果左右两个元素相同，则++k向右，--j向左。
                ++k;
                --j;
            }
            int new_len = k - j + 1;  //计算以当前字符为中心的回文串长度
            if (new_len > max_len) {  //如果新长度大于最大长度，则更新开始位置与最大回文串长度。
                min_start = j;
                max_len = new_len;
            }
        }
        return s.substr(min_start, max_len);
    }
};

思路四：著名的Manacher算法，时间复杂度为O(N);

提示：

先想想有什么办法能改进中心检测法。
考虑一下最坏的情况。★
最坏的情况就是各个回文相互重叠的时候。例如"aaaaaaaaaa"和" cabcbabcbabcba"。
为什么说有重叠时是最坏的情况？因为会发生重复计算。★（换句话说，没有重叠时，必须要一点一点计算，也就没有可改进的余地了。）
花费一些空间来避免重复计算。★
利用回文的特性避免重复计算。★

算法分析：

首先我们把字符串S改造一下变成T，改造方法是：在S的每个字符之间和S首尾都插入一个"#"。这样做的理由你很快就会知道。

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

 

想一下，你必须在以Ti为中心左右扩展才能确定以Ti为中心的回文长度d到底是多少。（就是说这一步是无法避免的）

为了改进最坏的情况，我们把各个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"。

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

现在，想象你在"abaaba"中心画一道竖线，你是否注意到数组P围绕此竖线是中心对称的？再试试"aba"的中心，P围绕此中心也是对称的。这当然不是巧合，而是在某个条件下的必然规律。我们将利用此规律减少对数组P中某些元素的重复计算。

 

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

 

上图展示了把S转换为T的样子。假设你已经算出了一部分P。竖实线表示回文"abcbabcba"的中心C，两个虚实线表示其左右边界L和R。你下一步要计算P[i]，i围绕C的对称点是i’。你有办法高效地计算P[i]吗？

 

我们先看一下i围绕C的对称点i’（此时i’=9）。

 

据上图所示，很明显P[i]=P[i’]=1。这是因为i和i’围绕C对称。同理，P[12]=P[10]=0，P[14]=P[8]=0。

 

现在再看i=15处。此时P[15]=P[7]=7？错了，你逐个字符检测一下会发现此时P[15]应该是5。

为什么此时规则变了？

 

如上图所示，两条绿色实线划定的范围必定是对称的，两条绿色虚线划定的范围必定也是对称的。此时请注意P[i’]=7，超过了左边界L。超出的部分就不对称了。此时我们只知道P[i]>=5，至于P[i]还能否扩展，只有通过逐个字符检测才能判定了。

在此例中，P[21]≠P[9]，所以P[i]=P[15]=5。

 

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

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即可。

 

每次求P[i]，都有两种可能。如果P[i'] < R – i，我们就P[i] = P[i’]。否则，就从R开始逐个字符求P[i]，并更新C及其R。此时扩展R（逐个字符求P[i]）最多用N步，而求每个C也总共需要N步。所以时间复杂度是2*N，即O(N)。

（注：原作者计算时间复杂度的这句话我没看懂。我自己想办法理解了，详情见下图。

图中i为索引，T为加入"#"、"^"和"$"后的字符串，P[i]就是算法里的p[i]，calc[i]是为了求出P[i]而需要执行比较的次数。

"V"表示此列的字符与其左侧的字符进行了比较，在左侧用"X"对应。绿色的表示比较结果为两个字符相同（即比较结果为成功），红色的表示不同（即比较结果为失败）。

很显然"X"和"V"的数量是相等的。

你可以看到，所需的成功比较的次数（绿色的"V"，表现为横向增长）不超过N，失败的次数（红色的"V"，表现为纵向增长）也不超过N，所以这个算法的时间复杂度就是2N，即O(N)。

）

代码：java版本：60ms

public class Solution {
    public String longestPalindrome(String s) {
        String T = preProcess(s);
        int length = T.length();
        int[] p = new int[length];
        int C = 0, R = 0;
        
        for (int i=1; i<length-1; i++) {
            int i_mirror = C - (i - C);
            int diff = R - i;
            if (diff >= 0) {  //当前i在C和R之间，可以利用回文的对称属性
                if (p[i_mirror] < diff) {
                    p[i] = p[i_mirror];
                } else {
                    p[i] = diff;
                    //i处的回文可能超出C的大回文范围了
                    while (T.charAt(i + p[i] + 1) == T.charAt(i - p[i] - 1)) {
                        p[i]++;
                    }
                    C = i;
                    R = i + p[i];
                }
            } else {
                p[i] = 0;
                while (T.charAt(i + p[i] + 1) == T.charAt(i - p[i] - 1)) {
                    p[i]++;
                }
                C = i;
                R = i + p[i];
            }
        }
        
        int maxLen = 0;
        int centerIndex = 0;
        for (int i=1; i<length-1; i++) {
            if (p[i] > maxLen) {
                maxLen = p[i];
                centerIndex = i;
            }
        }
        return s.substring((centerIndex - 1 - maxLen)/2, (centerIndex - 1 - maxLen)/2 + maxLen);
    }
    
    public String preProcess(String s) {
        int n = s.length();
        if (n == 0) return "^$";
        
        String ret = "^";
        for (int i=0; i<n; i++) {
            ret += "#" + s.substring(i, i+1);
        }
        
        ret += "#$";
        return ret;
    }
}

思路五：后缀树（suffix tree）。

不过其复杂度为O(N log N)，构建后缀树也比较费劲，算法实现还比这个复杂。当然它也有其优势：能解决很多类似的问题。