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^2)，但是相比第一种方法，复杂度已经降低了很多，在这种方法中要特别注意，回文串是奇偶的区别对待，为了解决这个奇偶问题，可以考虑给每个原字符的左右两边添加特殊字符，这样就可以将奇偶问题统一处理，都变成基数问题处理，这样，需要一个P[i]的来记录以i为中心，向左/右能够移动的最大距离(包括i本身)，举例可以发现此时的P[i] - 1为原字符串中，以i为中心的回文串长度；

   有了第二种方法，统一处理奇偶回文串的思路，仔细分析，可以发现，其实在求解P[i]的时候，有时候计算是可以直接利用i之前的结果避免，这就是传说的Manacher算法，Manache算法对于P[i]的意思与第二种方法一致；关键是Manacher算法优化了P[i]的求解过程。其增加一个中心点id，以及以id为中心的回文串能够到达的右边界max;分析可以发现，当i < max时，可以找到i关于id的对称点j = id - (i - id) = 2 * id - i，如果P[j]小于max - i 的话，那么一定有p[j] = p[i]；如果p[j] > max - i， 那么至少可以保证，在max - i的范围内的字符串，是关于i对称的，也就是说，当i < max时，P[i] >= P[j]一定是成立的；如果i >= max，则无法根据i之前的来确定i的对称关系，所以初始化，P[i] = 1；然后以i为中心点，左右延伸，直到不对称为止;

   最后，求解完所有P[i]后，遍历找到最大的P[i]及下标i，那么在原串中该最大点的起始位置为(i - P[i]) / 2， 以该点为起点的最大回文串长度为P[i] - 1;

class Solution {
public:
    //DP实现, F[i]表示以i为中心向左/右能够移动的最大距离, 维护一个当前最大中心点id，以及最大中心点能够到达的右边界mx
    //为了统一处理奇偶问题，给原字符串添加特定的字符，使得字符串永远以奇数的方式处理，为了处理边界问题，增加两个哨兵
    void preprocess(string s, int n, string &newStr)
    {
        newStr.push_back('$');
        newStr.push_back('#');
        for(int i = 0; i < n; ++i)
        {
            newStr.push_back(s[i]);
            newStr.push_back('#');
        }
        newStr.push_back('^');
    }
    
    string longestPalindrome(string s) {
        int len = s.size();
        string maxStr = s;
        if(len > 1)
        {
            string newStr = "";
            preprocess(s, len, newStr);
            len = newStr.size();
            int *F = new int[len + 3];
            for(int i = 0; i < len + 3; ++i)
                F[i] = 0;
            int id = 0, max = 0;
            for(int i = 1; i < len - 1; ++i)
            {
                F[i] = (max > i) ? min(F[2 * id - i], max - i) : 1;
                while(newStr[i - F[i]] == newStr[i + F[i]]) ++F[i];
                if(i + F[i] > max)
                {
                    id = i;
                    max = i + F[i];
                }
            }
            
            max = -1;
            int maxIndex = 0;
            for(int i = 1; i < len - 1; ++i)
            {
                if(max < F[i])
                {
                    max = F[i];
                    maxIndex = i;
                }
            }
            
            maxStr = s.substr((maxIndex - max) / 2, max - 1);
        }
        
        return maxStr;
    }
};