BZOJ3676：[Apio2014]回文串 （Manacher+后缀自动机+树上倍增）

题目传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=3676

---

题目分析：找后缀自动机练习题的时候看到这题的，结果想不出怎么用SAM。看了黄学长的博客才知道要先写个manacher，再在parent树上玩倍增。后来又听说这题是裸的回文树……我还不知道什么是回文树啊，我也不是擅长现学现卖的类型，于是就写了这个SB的O(nlog(n))的方法。
首先我们知道，一个串不同的回文子串个数不会超过该串的长度，这点从manacher算法的执行过程就可以看出，只有当tail指针右移时，才有可能出现新的回文子串。那么我们先用manacher将每个回文子串的L和R算出来，然后用后缀自动机找它出现了几次。我们可以记录下插入完字符s[R]之后last指针的位置，这样last[R]~Root的路径上状态Right集就一定包含R，而parent树的其他部分则不包含。由于路径上的每个状态所包含的区间[Min,Max]随深度不断减小，具有单调性，我们可以倍增地往上跳，找到对应的状态。出现次数即为该状态的Right集大小。
虽然看起来方法很简单，但由于太久没有编Manancher，我YY了1h才写出来。然后WA了，我还以为是交上去运行时空间爆了（本题ML=128M，我开内存116M，加上我手出好几组数据+网上AC代码对拍没问题，而且BZOJ说不定将MLE报成WA），不停地修改数组大小，但还是不行。后来又觉得可能是特殊数据卡了，于是出了个小数据。结果发现字符串长度为1的时候我输出0（因为这时我的manacher崩掉了），而我由于一直用极限数据对拍，找不出错……然后一改就A了。
By the way.我发现我用来对拍的网上某大神代码没有用long long，这样是会被300000个a的字符串卡爆的，然而他还是AC了。我只能说数据好弱……（一开始我还想着要不要跟他一样用int自然溢出来着）

---

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=300010;
const int maxl=22;
const int maxc=26;
typedef long long LL;

struct State
{
    int val,Size;
    State *son[maxc],*fa[maxl];
} SAM[maxn<<1];
State *last[maxn];
State *Root;
int cur=-1;

State *Rank[maxn<<1];

char s[maxn];
char t[maxn<<1];
int temp[maxn<<1];
int slen,tlen;

int L[maxn<<1];
int R[maxn<<1];
int num=0;

void Manacher()
{
    tlen=(slen<<1)|1;
    t[0]='$';
    for (int i=0; i<slen; i++) t[(i<<1)|1]=s[i];
    for (int i=1; i<=slen; i++) t[i<<1]='#';
    t[tlen-1]='@';

    int p=1;
    temp[0]=temp[1]=0;
    for (int i=2; i<tlen; i++)
    {
        temp[i]=max(0, min(p+temp[p]-i,temp[ (p<<1)-i ]) );
        while ( t[ i-temp[i]-1 ]==t[ i+temp[i]+1 ] )
            temp[i]++,num++,L[num]=i-temp[i],R[num]=i+temp[i];
        if (i+temp[i]>p+temp[p]) p=i;
    }

    for (int i=1; i<=num; i++)
    {
        if ( !(L[i]&1) ) L[i]++;
        L[i]^=1,L[i]>>=1;
        if ( !(R[i]&1) ) R[i]--;
        R[i]^=1,R[i]>>=1;
    }
}

State *New_state(int v,int s)
{
    cur++;
    SAM[cur].val=v;
    SAM[cur].Size=s;
    for (int i=0; i<maxc; i++) SAM[cur].son[i]=NULL;
    for (int i=0; i<maxl; i++) SAM[cur].fa[i]=NULL;
    return SAM+cur;
}

void Build(int x)
{
    int to=s[x]-'a';
    x++;
    State *NP=New_state(x,1),*P=last[x-1];
    last[x]=NP;
    while ( P && !P->son[to] ) P->son[to]=NP,P=P->fa[0];
    if (!P)
    {
        NP->fa[0]=Root;
        return;
    }
    State *Q=P->son[to];
    if (P->val+1==Q->val) NP->fa[0]=Q;
    else
    {
        State *NQ=New_state(P->val+1,0);
        for (int i=0; i<maxc; i++) NQ->son[i]=Q->son[i];
        NQ->fa[0]=Q->fa[0];
        NP->fa[0]=Q->fa[0]=NQ;
        while ( P && P->son[to]==Q ) P->son[to]=NQ,P=P->fa[0];
    }
}

LL Get(int x,int y)
{
    int len=y-x+1;
    State *P=last[++y];
    for (int j=maxl-1; j>=0; j--)
        if ( P->fa[j] && P->fa[j]->val>=len )
            P=P->fa[j];
    LL temp=P->Size;
    temp*=len;
    return temp;
}

int main()
{
    freopen("c.in","r",stdin);
    freopen("c.out","w",stdout);

    scanf("%s",&s);
    slen=strlen(s);
    Manacher();

    last[0]=Root=New_state(0,0);
    for (int i=0; i<slen; i++) Build(i);

    for (int j=1; j<maxl; j++)
        for (int i=0; i<=cur; i++)
        {
            State *P=SAM+i;
            if (!P->fa[j-1]) P->fa[j]=NULL;
            else P->fa[j]=P->fa[j-1]->fa[j-1];
        }

    for (int i=0; i<=slen; i++) temp[i]=0;
    for (int i=0; i<=cur; i++) temp[ SAM[i].val ]++;
    for (int i=1; i<=slen; i++) temp[i]+=temp[i-1];
    for (int i=0; i<=cur; i++) Rank[ --temp[ SAM[i].val ] ]=SAM+i;
    for (int i=cur; i>=1; i--) Rank[i]->fa[0]->Size+=Rank[i]->Size;

    LL ans=1;
    for (int i=1; i<=num; i++) ans=max(ans, Get(L[i],R[i]) );
    printf("%I64d\n",ans);

    //printf("%d\n",sizeof(SAM)/1024/1024);

    return 0;
}

---

通过这题我发现了另外一些好玩的东西：我们在建好SAM，并维护出倍增数组之后，可以在log(n)的时间内知道s[L]~s[R]所组成的子串在s中出现了几次。如果要求支持在串的末尾加字符呢？要动态维护Right集的大小可以用LCT或Splay+DFS序；要动态维护倍增数组也很简单，在每一次有状态要修改parent的地方用log(n)暴力重算即可，或者还可以Access之后在Splay上二叉查找。后来我和tututu交流了一下，发现如果可以离线，我们可以先构造完整个串的SAM，然后处理询问。对于一个询问[L,R]，假设当时s添加到第x个字符，那么我们就是要求其对应状态的Right集中<=x的元素个数，这可以通过DFS序+可持久化线段树用log(n)的时间实现。