【LeetCode系列】最长回文子串 Longest Palindromic Substring

题目描述（难度M）： 

解法：马拉车算法（Manacher's Algorithm） 

马拉车算法是解决最长回文子串长度的经典算法，时间复杂度和空间复杂度均只有O(n)。

参考博客：

https://articles.leetcode.com/longest-palindromic-substring-part-ii/

http://windliang.cc/2018/08/05/leetCode-5-Longest-Palindromic-Substring/

https://www.cnblogs.com/grandyang/p/4475985.html

首先对字符串进行预处理操作：因为回文字符串可能有奇数个字符也可能有偶数个字符，该算法在每个字符间插入"#"，并在最开头插入"^"，结尾插入"$"（防止越界），这样所有的字符串经过处理后都有奇数个字符，处理后的字符用T表示。

如：abba    ==>    "^#a#b#b#a#$"

       abcba    ==>    "^#a#b#c#b#a#$"

用 P[i] 表示以为中心的处理后的回文字符串一半的长度（包括字符"#"）

如：T  =  ^  #  a  #  b  #  a  #  a  #  b  #  a  #  $

       P  =     0  1  0  3  0  1  6  1  0  3  0  1  0

上面的 是字符"#"，它是边界 P[1] = 0；  是字符"a"，以它为中心左边有一个"#"右边有一个"#"，P[2] = 1；是第二个"#"，它左边是a右边是b不是回文，P[3] = 0；是字符"b"，以它为中心左边有一个"#a#"右边有一个"#a#"，长度为3，P[4] = 3。以此类推。我们可以很明显地看到上例的最长回文字符串为"abaaba"，长度为6，刚好 P[6] = 6。

我们现在考虑一下怎么求 P[i] 

图片来源： http://windliang.cc/2018/08/05/leetCode-5-Longest-Palindromic-Substring/

我们定义C表示当前最长的回文子串的中心，R表示最长回文子串的右边界，i_mirror表示 i 相对于 C 对称的另一侧数组下标。

利用回文的对称性很明显我们可以看到 P[i] = P[i_mirror] = 3。

但情况并不总是这么乐观

图片来源： http://windliang.cc/2018/08/05/leetCode-5-Longest-Palindromic-Substring/ 

如上图，很明显 P[15] ≠ P[7]，因为 i 为 15，P[i_mirror] = P[7]为7，15 + 7 = 22，它超过了R。那为什么超过R就不行呢，因为当前的C智能保证到R以内是回文，R以外就无法保证了，也就是说 P[i] = P[15] 一定大于等于 R - i ，即在 i 到 R 的这个区间肯定是回文的，但是超过R的话就要继续判断了。

因此可以描述为：

if P[ i_mirror ] ≤ R – i,（说明 i 在 C 的控制范围之内）
then P[ i ] ← P[ i_mirror ]（可以直接赋值）
else P[ i ] ≥ R - i. （这里我们就需要扩展R来找到P[i]了）

这样下面这行代码就比较好理解了：

P[i] = (R > i) ? min(R-i, P[i_mirror]) : 0;

若仍不能理解可参考https://www.cnblogs.com/grandyang/p/4475985.html

那么接下来如果超出了边界怎么样呢，要一个一个找。此时已经给 P[i] 赋值了 R - i，我们就要看 T[i + P[i] + 1] 和 T[i - P[i] - 1] 是否相等，相等则P[i] 加一。i + P[i] 就是下标 i 指向的元素向右迈 P[i] 步，我们知道此时的 T[i + P[i]] 和 T[i - P[i]] 是相等的，我们只需要分别再向外扩张一步即可（循环执行直到不相等）。

这样我们就能得出所有的 P[i] 了，得到 P[i] 以后我们只要找到最大的 P[i] 即为最长的回文子串的长度。

那怎么得到最长的回文子串呢？

事实是用 P 的下标 i - P[i] - 1，再除以 2 ，就是原字符串的开头下标了。其实用 i - P[i] 也可以，但是处理速度要慢一些。

因为处理后的字符串 字母 的下标均为偶数，"#" 的下标均为奇数，而当 字母 为最长回文子串的中心时P肯定为奇数（最终会扩展到#为止），当 "#" 为最长回文子串的中心时P肯定为偶数。 i - 1 - P[i] 则可以将所有情况均转化为偶数，除以2速度更快。

class Solution {
public:
    //字符串预处理
    string preProcess(string s){
        int length = s.length();
        if(length == 0){
            return "^$";
        }
        string after = "^";
        for(int i = 0; i < length; i++){
            after += "#" + s.substr(i, 1);
        }
        after += "#$";
        return after;
    }
    
    string longestPalindrome(string s) {
        string T = preProcess(s);
        int n = T.length();
        int* P = new int[n];    //动态定义数组P
        int C = 0; int R = 0;
        for(int i = 1; i < n-1; i++){    //从1开始循环到n-1，忽略前后的字符"^"和"$"
            int i_mirror = C - (i - C);    //i_mirror是i相对于C的另一侧的对称点
            P[i] = R > i ? min(R - i, P[i_mirror]) : 0;
            while(T[i +P[i] + 1] == T[i - P[i] - 1]){    //扩展i的P[i]
                P[i]++;
            }
            if(i + P[i] > R){    //如果以i为中心的回文右侧超过了R,则更新R和C
                R = i + P[i];
                C = i;
            }
        }
        int maxLen = 0;
        int centerIndex = 0;
        for(int i = 1; i < n-1; i++){    //获取数组中最大的P[i]即为最长长度
            if(P[i] > maxLen){
                maxLen = P[i];
                centerIndex = i;
            }
        }
        delete[] P;
        return s.substr((centerIndex - maxLen - 1)/2, maxLen);
    }
};