Manacher算法--最长回文 HDU - 3068

工具：char Ma[2maxn];//作为一个转化数组
int Mp[maxn2];//该点为中点时的半径
int mx = 0, id = 0;//mx为目前最长回文最右端，id为最大中心的位置
核心步骤：
for(int i = 0; i < l; i++){//遍历
Mp[i] = mx>i?min(Mp[2id-i], mx-i):1;//i是否越过最右端，是则从从该点进行匹配，否则选择（以id对称的中点的回文数，目前最长回文右端与i的差）中的最小值，因为有可能为半包含，此时不知超出部分是否匹配，故选mx-1，换句话说，M[2id-i]与mx-i的大小关系与i的位置关系是对应的，无法直接判断是与i对应的已计算的Mp[j]大还是Mx-i大，实际上，最先需要满足的条件就是Mp[i]<=Mx-i,其次再以Mp[j]的大小来成为第二个限制条件
while(Ma[i+Mp[i]] == Ma[i - Mp[i]]) Mp[i]++;//匹配
if(i + Mp[i] > mx){//如果以i为中心的右端值大于原来的，更新
mx = i + Mp[i];
id = i;
}
技巧：‘#’的加入

转自：http://blog.csdn.net/dyx404514/article/details/42061017

给出一个只由小写英文字符a,b,c...y,z组成的字符串S,求S中最长回文串的长度.
回文就是正反读都是一样的字符串,如aba, abba等
Input
输入有多组case,不超过120组,每组输入为一行小写英文字符a,b,c...y,z组成的字符串S
两组case之间由空行隔开(该空行不用处理)
字符串长度len <= 110000
Output
每一行一个整数x,对应一组case,表示该组case的字符串中所包含的最长回文长度.
Sample Input
aaaa

abab
Sample Output
4
3

Manacher算法

算法总结第三弹 manacher算法，前面讲了两个字符串相算法——kmp和拓展kmp，这次来还是来总结一个字符串算法，manacher算法，我习惯叫他 “马拉车”算法。

相对于前面介绍的两个算法，Manacher算法的应用范围要狭窄得多，但是它的思想和拓展kmp算法有很多共通支出，所以在这里介绍一下。Manacher算法是查找一个字符串的最长回文子串的线性算法。

在介绍算法之前，首先介绍一下什么是回文串，所谓回文串，简单来说就是正着读和反着读都是一样的字符串，比如abba，noon等等，一个字符串的最长回文子串即为这个字符串的子串中，是回文串的最长的那个。

计算字符串的最长回文字串最简单的算法就是枚举该字符串的每一个子串，并且判断这个子串是否为回文串，这个算法的时间复杂度为O(n^{3)的，显然无法令人满意，稍微优化的一个算法是枚举回文串的中点，这里要分为两种情况，一种是回文串长度是奇数的情况，另一种是回文串长度是偶数的情况，枚举中点再判断是否是回文串，这样能把算法的时间复杂度降为O(n}2)，但是当n比较大的时候仍然无法令人满意，Manacher算法可以在线性时间复杂度内求出一个字符串的最长回文字串，达到了理论上的下界。

1.Manacher算法原理与实现

下面介绍Manacher算法的原理与步骤。

首先，Manacher算法提供了一种巧妙地办法，将长度为奇数的回文串和长度为偶数的回文串一起考虑，具体做法是，在原字符串的每个相邻两个字符中间插入一个分隔符，同时在首尾也要添加一个分隔符，分隔符的要求是不在原串中出现，一般情况下可以用#号。下面举一个例子：

image

（1）Len数组简介与性质

Manacher算法用一个辅助数组Len[i]表示以字符T[i]为中心的最长回文字串的最右字符到T[i]的长度，比如以T[i]为中心的最长回文字串是T[l,r],那么Len[i]=r-i+1。

对于上面的例子，可以得出Len[i]数组为:

image

Len数组有一个性质，那就是Len[i]-1就是该回文子串在原字符串S中的长度，至于证明，首先在转换得到的字符串T中，所有的回文字串的长度都为奇数，那么对于以T[i]为中心的最长回文字串，其长度就为2*Len[i]-1,经过观察可知，T中所有的回文子串，其中分隔符的数量一定比其他字符的数量多1，也就是有Len[i]个分隔符，剩下Len[i]-1个字符来自原字符串，所以该回文串在原字符串中的长度就为Len[i]-1。

有了这个性质，那么原问题就转化为求所有的Len[i]。下面介绍如何在线性时间复杂度内求出所有的Len。

（2）Len数组的计算

首先从左往右依次计算Len[i]，当计算Len[i]时，Lenj已经计算完毕。设P为之前计算中最长回文子串的右端点的最大值，并且设取得这个最大值的位置为po，分两种情况：

第一种情况：i<=P

那么找到i相对于po的对称位置，设为j，那么如果Len[j]

image

那么说明以j为中心的回文串一定在以po为中心的回文串的内部，且j和i关于位置po对称，由回文串的定义可知，一个回文串反过来还是一个回文串，所以以i为中心的回文串的长度至少和以j为中心的回文串一样，即Len[i]>=Len[j]。因为Len[j]

如果Len[j]>=P-i,由对称性，说明以i为中心的回文串可能会延伸到P之外，而大于P的部分我们还没有进行匹配，所以要从P+1位置开始一个一个进行匹配，直到发生失配，从而更新P和对应的po以及Len[i]。

image

第二种情况: i>P

如果i比P还要大，说明对于中点为i的回文串还一点都没有匹配，这个时候，就只能老老实实地一个一个匹配了，匹配完成后要更新P的位置和对应的po以及Len[i]。

image

2.时间复杂度分析

Manacher算法的时间复杂度分析和Z算法类似，因为算法只有遇到还没有匹配的位置时才进行匹配，已经匹配过的位置不再进行匹配，所以对于T字符串中的每一个位置，只进行一次匹配，所以Manacher算法的总体时间复杂度为O(n)，其中n为T字符串的长度，由于T的长度事实上是S的两倍，所以时间复杂度依然是线性的。

下面是算法的实现，注意，为了避免更新P的时候导致越界，我们在字符串T的前增加一个特殊字符，比如说‘$’,所以算法中字符串是从1开始的。

#include 
#include
#include
using namespace std;

const int maxn = 1100100;
char Ma[2*maxn];//作为一个转化数组
int Mp[maxn*2];//该点为中点时的半径
char s[maxn];//输入数组

void Manacher(char s[], int len){
    int l = 0;
    Ma[l++] = '$';//初始化Ma[0]，防止越界，也不用考虑边界的问题（按照正常思维即可）
    Ma[l++] = '#';//初始化Ma[1]
    for(int i = 0; i < len ;i++){
        Ma[l++] = s[i];
        Ma[l++] = '#';
    }
    Ma[l] = 0;
    int mx = 0, id = 0;//mx为目前最长回文最右端，id为最大中心的位置
    for(int i = 0; i < l; i++){//遍历
        Mp[i] = mx>i?min(Mp[2*id-i], mx-i):1;//i是否越过最右端，是则从从该点进行匹配，否则选择（以id对称的中点的回文数，目前最长回文右端与i的差）中的最小值，因为有可能为半包含，此时不知超出部分是否匹配，故选mx-1，换句话说，M[2*id-i]与mx-i的大小关系与i的位置关系是对应的
        while(Ma[i+Mp[i]] == Ma[i - Mp[i]]) Mp[i]++;//匹配
        if(i + Mp[i] > mx){//如果大于原来的，更新
            mx = i + Mp[i];
            id = i;
        } 
    }
}
int main(){
    while(scanf("%s", s) == 1){
        int len = strlen(s);
        Manacher(s,len);
        int ans = 0;
        for(int i = 0; i < 2*len+2;i++)
            ans = max(ans,Mp[i] -1);//Mp[i] - 1即为最大值
        printf("%d\n", ans);
    }
    
    return 0;
} 

还有两个问题，如何证明Mp[i] - 1就是最大值？为什么最大值不会出现在‘#’上？