AcWing 139 回文子串的最大长度

题目描述：

如果一个字符串正着读和倒着读是一样的，则称它是回文的。给定一个长度为N的字符串S，求他的最长回文子串的长度是多少。

输入格式

输入将包含最多30个测试用例，每个测试用例占一行，以最多1000000个小写字符的形式给出。输入以一个以字符串“END”（不包括引号）开头的行表示输入终止。

输出格式

对于输入中的每个测试用例，输出测试用例编号和最大回文子串的长度（参考样例格式）。每个输出占一行。

输入样例：

abcbabcbabcba
abacacbaaaab
END

输出样例：

Case 1: 13
Case 2: 6

分析：

本题是要求最大回文子串的长度，既然是回文串，自然有对称中心，比如aba的对称中心是b，abba的对称中心是两个b之间，通常，为了统一处理，我们会在字符串之间加入填充字符来统一回文串长度的奇偶性。

方法一：（字符串Hash+二分，时间复杂度：O（nlogn））

按照yxc大佬的思路，仅在每个字符前面添加#,比如aba就被扩充为#a#b#a，遍历每个字符，尝试以所有字符为对称中心的回文串最大的长度可能是多少，比如第一个a，最大回文串是#a#，第二个b，最大回文串是a#b#a。可以发现，当回文串最左边字符是#时，实际回文串的长度就是填充后对称中心左边子串的长度，例如#a#中对称中心a左边只有一个字符，回文串的长度就是1；而当回文串最左边字符是字母时，实际回文串的长度就是填充后对称中心左边子串的长度加上1，例如a#b#a中对称中心b左边有2个字符，回文串的长度就是2 + 1 = 3。可以发现，遍历一遍所有字符的复杂度为O（n），而对于下标为i的字符，其左边回文串最大的长度可能是min(i - 1,n - i)，因为i左边有i - 1个字符，右边有n - i个字符，最大回文串的长度不会超过二者中的较小者。

为了更快的找出以第i个字符为对称中心的长度，我们只要对长度进行二分即可在O（logn）的时间内找到以第i个字符为对称中心的最大回文串长度。

整理下思路，我们需要做什么。首先，对原字符串所有字符的左边位置都填充一个#；然后，对填充后的字符串正序逆序都求下哈希值的前缀和，以便后续在O（1）的时间内判断一段区间内字符是否为回文串；最后，遍历各个字符，二分找出最大回文子串的长度。鉴于需要处理的地方较多，大部分根据上面简单的描述结合代码即可理解，这里仅说下容易错的二分。

二分的第一步，明确查找的目标，我们需要找到一个len，使得在字符串在len的长度上恰好是回文的，而len + 1就不满足回文性质。可以理解为，二分最终的l就是len的长度，而r则是l + 1的位置，也就是说二分的区间为左闭右开，mid = l + r >> 1，一旦mid位置合法，则l = mid，否则r = mid，这样l指向的位置永远合法，而r的位置永远不合法，边界情况下就是r = l + 1，此刻终止循环。

还有个地方稍微解释下，对于以第i个元素为对称中心左边字符长度为mid的区间为[i - mid,i - 1]，原来与之对称的区间倒过来后变成了[n - (i + mid) + 1,n - i]，这里取几个特值即可理解，比如原来下标为1逆置后成了n，2成了n - 1。代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef unsigned long long ull;
const int maxn = 2000010;
char str[maxn];
ull hl[maxn],hr[maxn],p[maxn];
ull get(ull *h,int l,int r){
    return h[r] - h[l - 1] * p[r - l + 1];
}
int main(){
    int T = 1,base = 131;
    while(scanf("%s",str + 1),strcmp(str + 1,"END")){
        int n = strlen(str + 1);
        for(int i = n * 2;i;i -= 2){
            str[i] = str[i / 2];
            str[i - 1] = 'z' + 1;//填充字符
        }
        n *= 2;
        p[0] = 1;
        for(int i = 1,j = n;i <= n;i++,j--){//正反方向Hash数组
            hl[i] = hl[i - 1] * base + str[i] - 'a' + 1;
            hr[i] = hr[i - 1] * base + str[j] - 'a' + 1;
            p[i] = p[i - 1] * base;
        }
        int res = 0;
        for(int i = 1;i <= n;i++){
            int l = 0,r = min(i - 1,n - i) + 1;//左闭右开，r比最大值多1
            while(l < r - 1){
                int mid = l + r >> 1;
                if(get(hl,i - mid,i - 1) != get(hr,n - (i + mid) + 1,n - i))  r = mid;
                else    l = mid;
            }
            if(str[i - l] <= 'z')   res = max(res,l + 1);//回文串最左边是字符时
            else    res = max(res,l);
        }
        printf("Case %d: %d\n",T++,res);
    }
    return 0;
}

方法二：（字符串Hash优化，时间复杂度：O（n））

不难发现，虽然方法一O（nlogn）的时间复杂度已经算得上高效了，但是仍有改进空间。第一个需要改进的地方就是上面代码最后需要判断回文串最左边是不是字符，这完全是因为字符串最右边没有填充字符导致的，比如aba原先填充得到#a#b#a，最长回文串是a#b#a，之所以回文串最左边会是正常字符，完全是最右边没有与开头的填充字符匹配的#，那么，如果对字符串左右两边都加上#会如何呢？对于aba而言，填充后得到#a#b#a#，b左边最大回文串长度为三个字符，aba恰好是3，如果是#a#b#b#a#，中间的#左边有4个字符，最长回文串长度abba长度同样是4，如此，便不用在讨论回文串最左边的字符是什么了，因为，只要字符串中所有字符的左右两边都有填充字符，最长回文串的最左边必然都是填充字符。

上面的改进是为了统一处理，接下来的改进则是从复杂度层面提高了算法的效率。方法一的思路就是对以第i个字符为对称中心二分求出其最大回文串的长度后，再继续二分求第i + 1个字符的，再进行比较。可以发现，一旦后面第i个字符的最大回文串的长度为res，则后面字符回文串长度若是小于res则完全不会更新解，那么为什么还要浪费时间去二分求答案呢？所以，我们完全可以从上一个字符求出的最大回文串长度的基础上进行判断下一个字符是否会成为最大回文串的对称中心，因为每次判断的回文串长度都是非递减的，所以总的时间复杂度为O（n）。

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef unsigned long long ull;
const int maxn = 2000010;
char str[maxn];
ull hl[maxn],hr[maxn],p[maxn];
ull get(ull *h,int l,int r){
    return h[r] - h[l - 1] * p[r - l + 1];
}
int main(){
    int T = 1,base = 131;
    while(scanf("%s",str + 1),strcmp(str + 1,"END")){
        int n = strlen(str + 1);
        for(int i = n * 2;i;i -= 2){
            str[i] = str[i / 2];
            str[i - 1] = 'z' + 1;
        }
        n *= 2;
        p[0] = 1;
        str[++n] = 'z' + 1;
        for(int i = 1,j = n;i <= n;i++,j--){
            hl[i] = hl[i - 1] * base + str[i] - 'a' + 1;
            hr[i] = hr[i - 1] * base + str[j] - 'a' + 1;
            p[i] = p[i - 1] * base;
        }
        int ans = 1;
        for(int i = 1;i <= n;i++){
            int r = min(i - 1,n - i);
            if(ans >= r || get(hl,i - ans,i - 1) != get(hr,n - (i + ans) + 1,n - i))   continue;
            while(ans <= r && get(hl,i - ans,i - 1) == get(hr,n - (i + ans) + 1,n - i))    ans++;
            ans--;
        }
        printf("Case %d: %d\n",T++,ans);
    }
    return 0;
}

方法三：（马拉车算法，时间复杂度：O（n））

在介绍马拉车算法前，先说下较为普通的一种解法。和前面方法一样，遍历每个字符，找到以该字符为对称中心的最大回文串长度。不同的是，这里不再使用字符串Hash，而是逐个比较来判断是否是回文串。比如abcba，当对称中心遍历到c时逐对比较c两边的元素，b = b，继续向两边扩散，a = a，以此来找到以c为对称中心的最大回文串长度。对称中心的遍历复杂度是线性的，而每次回文串最大长度的查找也是线性的，总的时间复杂度为O（n^2）。

那么，在判断回文串的比对过程中，是否每次比对都是必要的呢？以本题样例为例，abcbabcbabcba。当遍历到第五个字符a时，向两边扩散来找回文串的长度，b = b，c = c，b = b，a = a，最后得到以第五个字符a为对称中心的最长回文串是abcbabcba，紧接着遍历到第六个字符b，发现a ！= c，继续遍历到第七个字符c，发现b = b，a = a，...。可能现在来看重复对比的行为还不够明显，我们是从左向右将每个字符依次选为对称中心再去判断最大回文串的。可以发现，以第五个字符a为对称中心的最长回文串中，a左边的字符串是abcb，右边的字符串是bcba，满足回文串的性质，彼此对称。不妨回忆下以第四个字符b为对称中心时回文串的查找操作，发现c ！= a，于是终止；那么第三个字符c为对称中心时回文串的查找操作呢？也就是b = b，a = a。规律已经很明显了，在已经判断过的回文串abcbabcba中，在遍历到对称中心a右边字符时，以某字符为对称中心查找最大回文串的比对操作早在之前查找以该字符与a的对称字符为对称中心的查找时就已经比对过了。（可以在纸上模拟下该过程，理解了这里的重复对比，后面的公式便好理解了）。

上图是基本每个介绍马拉车算法的博客都会列出的图，以及必须要列出的公式p[i] = min(p[2*id-1], mx-i)。

将抽象字母具体化，上图的id就是对称中心，相当于之前分析中的回文串abcbabcba中的第五个字符a的位置。mx相当于回文串最右边的位置，相当于最右边a的位置，公式中的数组p[i]表示以第i个字符为对称中心的最大回文串长度，可以发现，题目所求即是p数组中的最大值。根据上面的分析，一旦以j为对称中心的最大回文串范围不超过mx对称点到id之间，也就是长度不超过j - mx对称点，或者是不超过mx - i时，p[i]的值是完全和p[j]相等的，用语句来描述就是p[j] < mx - i 时，p[i] = p[j] = p[2*id - i]，当p[j] >= mx - i 时,即以j为对称中心的回文串也可能超出以id为对称中心回文串的范围时，由于超出回文串范围的部分可能不具有对称性，我们唯一能确定的是p[i]的值不会小于mx - i，具体是多少还需继续比对。针对以上两种情况，总结出的公式就是p[i] = min(p[2*id-1], mx-i)。当然，马拉车算法还有很多细节没讲，字符的填充与方法二完全一致。

至于为何马拉车算法的时间复杂度是线性的，可以直观上来理解：对于完全不对称的字符串比如abcde，以任意一个字符为对称中心在进行回文判断时，都只需比较一次；对于回文串比如abcbabcba，每个回文串中右边的字符都不用重复去比对了，而左边的字符每多一次比较，都会导致右边的字符在回文串内的比较减少了，平均下来一每个字符为对称中心回文串的判断操作也是线性的。

简单总结下马拉车算法的流程：首先，需要判断当前的第i个字符是否处于回文串内，即i是否小于mx，是则直接用上面公式，不是则令p[i] = 1，再开始比对。一旦发现新的回文串可以更新mx时就立刻更新mx和id。

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn = 2000010;
char str[maxn];
int p[maxn];
int main(){
    int T = 1;
    while(scanf("%s",str + 1),strcmp(str + 1,"END")){
        int n = strlen(str + 1);
        for(int i = n * 2;i;i -= 2){
            str[i] = str[i / 2];
            str[i - 1] = 'z' + 1;
        }
        n *= 2;
        str[0] = '$',str[++n] = 'z' + 1;//多了首字符哨兵，方便后面比对的终止
        memset(p,0,sizeof(p));
        int mx = 0,ans = 0,id = 0;
        for(int i = 1;i <= n;i++){
            if(mx > i)  p[i] = min(mx - i,p[2 * id - i]);
            else    p[i] = 1;
            while(str[i - p[i]] == str[i + p[i]])   p[i]++;
            if(p[i] + i > mx){
                mx = p[i] + i;
                id = i;
            }
            ans = max(ans,p[i]);
        }
        printf("Case %d: %d\n",T++,ans - 1);
    }
    return 0;
}