最长回文子串——Manacher 算法

最长回文子串——Manacher 算法

问题定义

最长回文子串问题：给定一个字符串，求它的最长回文子串长度。

如果一个字符串正着读和反着读是一样的，那它就是回文串。下面是一些回文串的实例：

12321 a aba abba aaaa tattarrattat（牛津英语词典中最长的回文单词）

Brute-force 解法

对于最长回文子串问题，最简单粗暴的办法是：找到字符串的所有子串，遍历每一个子串以验证它们是否为回文串。一个子串由子串的起点和终点确定，因此对于一个长度为n的字符串，共有n^2个子串。这些子串的平均长度大约是n/2，因此这个解法的时间复杂度是O(n^3)。

改进的方法

显然所有的回文串都是对称的。长度为奇数回文串以最中间字符的位置为对称轴左右对称，而长度为偶数的回文串的对称轴在中间两个字符之间的空隙。可否利用这种对称性来提高算法效率呢？答案是肯定的。我们知道整个字符串中的所有字符，以及字符间的空隙，都可能是某个回文子串的对称轴位置。可以遍历这些位置，在每个位置上同时向左和向右扩展，直到左右两边的字符不同，或者达到边界。对于一个长度为n的字符串，这样的位置一共有n+n-1=2n-1个，在每个位置上平均大约要进行n/4次字符比较，于是此算法的时间复杂度是O(n^2)。

Manacher 算法

对于一个比较长的字符串，O(n^2)的时间复杂度是难以接受的。Can we do better?

先来看看解法2存在的缺陷。

1) 由于回文串长度的奇偶性造成了不同性质的对称轴位置，解法2要对两种情况分别处理；
2) 很多子串被重复多次访问，造成较差的时间效率。

缺陷2）可以通过这个直观的小?体现：

char: a b a b a
  i : 0 1 2 3 4

当i==1，和i==2时，左边的子串aba分别被遍历了一次。

如果我们能改善解法2的不足，就很有希望能提高算法的效率。Manacher正是针对这些问题改进算法。

解决长度奇偶性带来的对称轴位置问题

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数组。基本思路是利用回文串的对称性，扩展回文串。

通过观察我们还可以发现，上面RL数组的值以及RL-1的值，也是关于回文串中心店对称的。例如：

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

上面RL[0]与RL[2]的值关于i=1点对称，RL[0]，RL[1]，RL[2]的值与RL[4]，RL[5]，RL[6]的值关于i=3点对称，这个结论可以说即正确又不正确，原因我们后面再解释，先卖个关子。

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

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

1，当i在MaxRight的左边

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

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

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

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

上面这个例子是有前提条件的：i < MaxRight 且 （MaxRight - i） > RL[2*pos - i ] 。这个时候我们可以令RL[i] = RL[2*pos -i] = RL[j] ，然后再以i为对称轴，继续往左右两边扩展，直到左右两边字符不同，或者到达边界。

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

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

这个时候，由于满足i < MaxRight 且 （MaxRight - i） < RL[2*pos - i ]这两个条件，我们应当令

RL[i] = MaxRight - i = 20 - 15 = 5;

眼尖的同学可能已经发现，你图片中明明RL[15]值为6？
这里我要说明的是，这个时候得到的RL[i]只是个过程值，不一定是RL[i]的最后结果，这里只是下面我们总结的3步操作中的step 1，后面step 2中，满足条件还会更改RL[i]，如下面我们截取的程序片段就是step 2对应的程序。

 while( i - rl[i] >=0 && i+rl[i] < len2 && temp[i-rl[i]] == temp[i+rl[i]] )
 {
      rl[i]++;
 }

看到这里，如果大家能够理解，说明对这个算法最经典的位置大家都已经可以理解了，其实这里的step 1和step 2正好规避了我们上面所说的缺陷2。

总结

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

具体操作如下：

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

注意step 1这个说的是令，就是我们程序中赋值的意思，不一定是RL[i]的最终值，后面还要执行step 2，这个赋值其实就是规避了上面所说的两个缺陷，跳过min(RL[2*pos-i], MaxRight-i)这个长度的字符，然后在进行step 2的扩展，这样很优雅的规避了上面提到的缺陷2的问题，避免重复访问，提高了算法效率。

2，当i在MaxRight的右边

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

算法实现

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

class Solution {
public:
    string longestPalindrome(string& str) {
        int pos = 0,centerIndex = 0 ,maxLength = 0,maxRight = 0;
        string temp(str);
        const int len1 = str.length();

        for( int i=0,k=0;i<=len1;i++)
        {
            temp.insert(k,"#");
            k += 2;
        }
        const int len2 = temp.length();
        int *rl = new int[len2];
        for( int i=0;i<len2;i++)
        {
            if( i < maxRight )
            {
                rl[i] = min(rl[2*pos-i],maxRight-i);
            }
            else
            {
                rl[i] = 1;
            }

            while( i - rl[i] >=0 && i+rl[i] < len2 && temp[i-rl[i]] == temp[i+rl[i]] )
            {
                rl[i]++;
            }

            if( rl[i] + i -1 > maxRight )
            {
                maxRight = rl[i] + i - 1;
                pos = i;
            }
            //maxLength = max(maxLength,rl[i]);
            if( maxLength < rl[i] - 1 )
            {
                maxLength = rl[i] - 1;
                centerIndex = i;
            }
        }
        delete[] rl;
        return str.substr( (centerIndex - maxLength )/2 ,maxLength );
    }

};



int main()
{
    string str;
    vector <string> v;

    while( getline(cin,str) &&  !str.empty() )
    {
        v.push_back(str);
    }

    for( vector<string>::iterator iter = v.begin(); iter != v.end(); ++iter)
    {
        string result = Solution().longestPalindrome(*iter);

        cout<< " result = " << result << endl;
    }
    return 0;
} 

复杂度分析

空间复杂度：插入分隔符形成新串，占用了线性的空间大小；RL数组也占用线性大小的空间，因此空间复杂度是线性的。
时间复杂度：尽管代码里面有两层循环，通过amortized analysis我们可以得出，Manacher的时间复杂度是线性的。由于内层的循环只对尚未匹配的部分进行，因此对于每一个字符而言，只会进行一次，因此时间复杂度是O(n)。

参考：https://segmentfault.com/a/1190000003914228
https://www.felix021.com/blog/read.php?2040
https://articles.leetcode.com/longest-palindromic-substring-part-ii/