5. Longest Palindromic Substring（最长回文子串）

---

---

1. 原题

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

2. 分析：

1. 求一个字符串中的最长回文，最容易想到的一种就是：使用循环，在 str[ i ] 这个字符的时候， 不断同时向前和向后一样长的单位直到出现不同的字符, 记录每个字符作为中心点的时候的回文长度， 并更新max

count = 0;
while(str[i - count] == str[i + count])
    count++;
max = 2 * count - 1;

---

2.第二种方法，采用的思想是回文的首尾一定一样。
对于 char ch= str[ i ]， 每次从 j = i + 1开始向后继续开始， 检查 str[ j ] == str[ i ]， 如果相等就检查 substr(str [ i ], j - i + 1) 是不是回文，用 max 来记录回文字串的最大长度并更新。并且记录 str[ i ] 的值， 在后面的 substr(str[i + 1])里面遇见str[ i ]就不再执行。

    set<char> hasCheck;
    for (int i = 0; i < str.size(); i++) {
        if (hasCheck.count(str[i]) == 1) 
            continue;
        else
            hasCheck.insert(str[i]);
        for (j = i + 1; j < str.size(); j++) {
            if (str[i] == str[j])
                checkPalindromic(str.substrg(str[i], j - i + 1));
        }
    }

3 . 最长回文子串——Manacher 算法

详细参考：
https://www.61mon.com/index.php/archives/181/
https://segmentfault.com/a/1190000003914228 (以下内容和图片来自这个大神的博客)

• Manacher算法首先对字符串做一个预处理，在所有的空隙位置(包括首尾)插入同样的符号，要求这个符号是不会在原串中出现的。这样会使得所有的串都是奇数长度的。以插入#号为例：

  aba ———> #a#b#a#
  abba ———> #a#b#b#a#
  插入的是同样的符号，且符号不存在于原串，因此子串的回文性不受影响，原来是回文的串，插完之后还是回文的，原来不是回文的，依然不会是回文。

• 我们把一个回文串中最左或最右位置的字符与其对称轴的距离称为回文半径。Manacher定义了一个回文半径数组RL，用RL[i]表示以第i个字符为对称轴的回文串的回文半径。我们一般对字符串从左往右处理，因此这里定义RL[i]为第i个字符为对称轴的回文串的最右一个字符与字符i的距离。对于上面插入分隔符之后的两个串，可以得到RL数组：
  char: # a # b # a #
  RL : 1 2 1 4 1 2 1
  RL-1: 0 1 0 3 0 1 0
  i : 0 1 2 3 4 5 6

  char:    # a # b # b # a #
   RL :    1 2 1 2 5 2 1 2 1
  RL-1:    0 1 0 1 4 1 0 1 0
    i :    0 1 2 3 4 5 6 7 8
  

• 上面我们还求了一下RL[i]-1。通过观察可以发现，RL[i]-1的值，正是在原本那个没有插入过分隔符的串中，以位置i为对称轴的最长回文串的长度。那么只要我们求出了RL数组，就能得到最长回文子串的长度。

于是问题变成了，怎样高效地求的RL数组。基本思路是利用回文串的对称性，扩展回文串。

• 我们再引入一个辅助变量MaxRight，表示当前访问到的所有回文子串，所能触及的最右一个字符的位置。另外还要记录下MaxRight对应的回文串的对称轴所在的位置，记为pos，它们的位置关系如下。

我们从左往右地访问字符串来求RL，假设当前访问到的位置为i，即要求RL[i]，在对应上图，i必然是在po右边的(obviously)。但我们更关注的是，i是在MaxRight的左边还是右边。我们分情况来讨论。

1）当i在MaxRight的左边

情况1) 可以用下图来刻画：

我们知道，图中两个红色块之间（包括红色块）的串是回文的；并且以i为对称轴的回文串，是与红色块间的回文串有所重叠的。我们找到i关于pos的对称位置j，这个j对应的RL[j]我们是已经算过的。根据回文串的对称性，以i为对称轴的回文串和以j为对称轴的回文串，有一部分是相同的。这里又有两种细分的情况。

以j为对称轴的回文串比较短，短到像下图这样。

这时我们知道RL[i]至少不会小于RL[j]，并且已经知道了部分的以i为中心的回文串，于是可以令RL[i]=RL[j]。但是以i为对称轴的回文串可能实际上更长，因此我们试着以i为对称轴，继续往左右两边扩展，直到左右两边字符不同，或者到达边界。

以j为对称轴的回文串很长，这么长：

这时，我们只能确定，两条蓝线之间的部分（即不超过MaxRight的部分）是回文的，于是从这个长度开始，尝试以i为中心向左右两边扩展，，直到左右两边字符不同，或者到达边界。

不论以上哪种情况，之后都要尝试更新MaxRight和pos，因为有可能得到更大的MaxRight。

具体操作如下：

step 1: 令RL[i]=min(RL[2*pos-i], MaxRight-i)
step 2: 以i为中心扩展回文串，直到左右两边字符不同，或者到达边界。
step 3: 更新MaxRight和pos

2）当i在MaxRight的右边

遇到这种情况，说明以i为对称轴的回文串还没有任何一个部分被访问过，于是只能从i的左右两边开始尝试扩展了，当左右两边字符不同，或者到达字符串边界时停止。然后更新MaxRight和pos。

3. 代码

class Solution {
public:
    string preProcess(string& s) {
        string str;
        str.push_back('$');
        str.push_back('#');
        for (int i = 0; i < s.size(); i++) {
            str.push_back(s[i]);
            str.push_back('#');
        }
        str.push_back('^');
        return str;
    }
    string longestPalindrome(string s) {
        if (s.size() <= 1) return s;
        string str = preProcess(s);
        int len = str.size(), pos = 1, maxRight = 1;
        vector<int> p(len, 0);
        for (int i = 1; i < len - 1; i++) {
            if (i <= maxRight) {
                p[i] = min(p[2 * pos - i], maxRight - i);
                while (str[i + p[i]] == str[i - p[i]])
                    p[i]++;
                if (p[i] + i > maxRight) {
                    maxRight = p[i] + i;
                    pos = i;
                }
            }
        }
        int index = 0;
        int maxLen = 0;
        for (int i = 1; i < len - 1; i++) {
            if (p[i] > maxLen) {
                maxLen = p[i];
                index = i;
            }
        }
        return s.substr((index - maxLen) / 2, maxLen - 1);  
    }
};