manacherO(n)求最长回文子串 hihocoder1032

原文地址：https://segmentfault.com/a/1190000003914228   http://blog.csdn.net/synapse7/article/details/18908413

灰常不错的学习资料

先预处理下：在每个字符的两边都插入一个特殊的符号，比如abba变成#a#b#b#a#，aba变成 #a#b#a#（因为Manacher算法只能处理奇数长度的字符串）。同时，为了避免数组越界，在字符串开头添加另一特殊符号，比如$#a#b#a#。

以字符串3212343219为例，处理后变成S[] = "$#3#2#1#2#3#4#3#2#1#9#"。
然后用一个数组Len[i]来记录以处理后的字符S[i]为中心的最长回文子串的半长度（包括S[i]）：

 S   #  #  #  #  #  #  #  #  #  #  #
 Len                       

最终的回文子串的长度即为maxLen-1）

Manacher算法的核心就在于减少Len[i]的计算量，使得原来O(n^2)的算法优化为O(n)。

下面两幅图的红框中的字符串为当前的右边界下标最大的回文子串，mid为其中心，right为其最右端+1，i'=2*mid-i为i关于mid的对称点。

现要计算Len[i]，若以i'为中心的回文串（黄框）包含在最长回文子串中，则由回文串的对称性，以i为中心的回文串亦在最长回文子串中，即有Len[i]=Len[2*mid-i]

若以i'为中心的回文串（黄框）不包含在最长回文子串中，则以i为中心的回文串的半长度Len[i]=right-i+(之后继续判断的长度)

那么，为什么复杂度是O(n)的呢？

首先，主要影响复杂度的是s[i + len[i]] == s[i - len[i]]这一判断。

由下面的代码可知，当i<right时，我们就用常数的时间计算Len[i]（此时不会执行while中的语句）；当i>=right时，我们就继续判断：while (s[i + len[i]] == s[i - len[i]]) ++len[i]; 结束后，right < i + len[i]为真，更新right值。这样，我们至多进行n次s[i + len[i]] == s[i - len[i]]判断，故复杂度为O(n)。

完整代码：

 #include<bits/stdc++.h>
 using namespace std;
 const int mx = ;  

 char ss[mx + ], s[(mx << ) + ]; /// ss为源串，s为处理后的字符串
 int len[(mx << ) + ];  

 void debug()
 {
     int i;
     for (i = ; s[i]; ++i) printf("%c ", s[i]);
     puts("");
     for (i = ; s[i]; ++i) printf("%d ", len[i]);
     puts("");
 }  

 int main()
 {
     int right, mid, i, maxlen;
     while (gets(ss))
     {
         memset(s, , sizeof(s));
         s[] = '$';
         for (i = ; ss[i]; ++i) s[(i << ) + ] = '#', s[(i << ) + ] = ss[i];
         s[(i << ) + ] = '#';
         memset(len, , sizeof(len));
         maxlen = right = mid = ;
         for (i = ; s[i]; ++i)
         {
             len[i] = (i < right ? min(len[(mid << ) - i], right - i) : );
             /* 取min的原因：记点i关于mid的对称点为i'，
             若以i'为中心的回文串范围超过了以mid为中心的回文串的范围
             (此时有i + len[(mid << 1) - i] >= right，注意len是包括中心的半长度)
             则len[i]应取right - i(总不能超过边界吧) */
             while (s[i + len[i]] == s[i - len[i]]) ++len[i];
             maxlen = max(maxlen, len[i]);
             if (right < i + len[i]) mid = i, right = i + len[i];
         }
         printf("%d\n", maxlen - );
         debug();
     }
     return ;
 }  

补充：使用 Manacher 算法后我们得到了一个 len 数组，利用它我们可以在 O(1) 的时间内判断该字符串的任意子串是不是回文串，方法如下：

 inline bool Query(int l, int r) /// 判断源串中的某一子串 ss[l...r] 是否为回文串
 {
     return len[l + r + ] >= r - l + ;
 }  

0. 问题定义

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

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

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

1. Brute-force 解法

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

2. 改进的方法

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

3. Manacher 算法

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

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

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

缺陷2）可以通过这个直观的小