BZOJ2555: SubString（后缀自动机，LCT维护Parent树）

Description

懒得写背景了，给你一个字符串init，要求你支持两个操作

(1):在当前字符串的后面插入一个字符串

(2):询问字符串s在当前字符串中出现了几次？(作为连续子串)

你必须在线支持这些操作。

Input

第一行一个数Q表示操作个数

第二行一个字符串表示初始字符串init

接下来Q行，每行2个字符串Type,Str

Type是ADD的话表示在后面插入字符串。

Type是QUERY的话表示询问某字符串在当前字符串中出现了几次。

为了体现在线操作，你需要维护一个变量mask，初始值为0 

    

读入串Str之后，使用这个过程将之解码成真正询问的串TrueStr。

询问的时候，对TrueStr询问后输出一行答案Result

然后mask=maskxorResult

插入的时候，将TrueStr插到当前字符串后面即可。

HINT:ADD和QUERY操作的字符串都需要解压

长度 <= 600000，询问次数<= 10000,询问总长度<= 3000000

新加数据一组--2015.05.20

Output

 

Sample Input

2
A
QUERY B
ADD BBABBBBAAB

Sample Output

0

解题思路：

从后缀自动机构造的时候入手，因为Parent树是与pre指针直接相关，就在pre指针构造的时候快速维护Parent（LCT）。

剩下的就是两个模板堆叠，没什么思维含量。

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#define lll tr[spc].ch[0]
#define rrr tr[spc].ch[1]
#define ls ch[0]
#define rs ch[1]
class Unzip{
    public:
        void update(int lastans)
        {
            mask^=lastans;
            return ;
        }
        void decode(int *a,int len)
        {
            int upg=mask;
            for(int i=1;i<=len;i++)
                tmp[i-1]=a[i];
            for(int i=0;i<len;i++)
            {
                upg=(upg*131+i)%len;
                std::swap(tmp[i],tmp[upg]);
            }
            for(int i=1;i<=len;i++)
                a[i]=tmp[i-1];
            return ;
        }
    private:
        int tmp[1000000];
        int mask;
}U;
struct trnt{
    int ch[2];
    int fa;
    int is;
    int lzt;
    int wgt;
    int wgti;
    bool anc;
}tr[3000000];
struct sant{
    int tranc[26];
    int len;
    int pre;
}s[3000000];
int Q;
int siz;
int fin;
int lasans;
char tmp[1000000];
int atp[1000000];
bool whc(int spc)
{
    return tr[tr[spc].fa].rs==spc;
}
void pushup(int spc)
{
    tr[spc].wgt=tr[spc].wgti+tr[spc].is+tr[lll].wgt+tr[rrr].wgt;
    return ;
}
void trr(int spc)
{
    if(!spc)
        return ;
    std::swap(lll,rrr);
    tr[spc].lzt^=1;
    return ;
}
void pushdown(int spc)
{
    if(tr[spc].lzt)
    {
        trr(lll);
        trr(rrr);
        tr[spc].lzt=0;
    }
    return ;
}
void recal(int spc)
{
    if(!tr[spc].anc)
        recal(tr[spc].fa);
    pushdown(spc);
    return ;
}
void rotate(int spc)
{
    int f=tr[spc].fa;
    bool k=whc(spc);
    tr[f].ch[k]=tr[spc].ch[!k];
    tr[spc].ch[!k]=f;
    if(tr[f].anc)
    {
        tr[f].anc=0;
        tr[spc].anc=1;
    }else
        tr[tr[f].fa].ch[whc(f)]=spc;
    tr[spc].fa=tr[f].fa;
    tr[f].fa=spc;
    tr[tr[f].ch[k]].fa=f;
    pushup(f);
    pushup(spc);
    return ;
}
void splay(int spc)
{
    recal(spc);
    while(!tr[spc].anc)
    {
        int f=tr[spc].fa;
        if(tr[f].anc)
        {
            rotate(spc);
            return ;
        }
        if(whc(spc)^whc(f))
            rotate(spc);
        else
            rotate(f);
        rotate(spc);
    }
    return ;
}
void access(int spc)
{
    int lst=0;
    while(spc)
    {
        splay(spc);
        tr[spc].wgti-=tr[lst].wgt;
        tr[spc].wgti+=tr[rrr].wgt;
        tr[rrr].anc=1;
        tr[lst].anc=0;
        rrr=lst;
        pushup(spc);
        lst=spc;
        spc=tr[spc].fa;
    }
    return ;
}
void Mtr(int spc)
{
    access(spc);
    splay(spc);
    trr(spc);
    return ;
}
void split(int x,int y)
{
    Mtr(x);
    access(y);
    splay(y);
    return ;
}
void link(int x,int y)
{
    split(x,y);
    tr[x].fa=y;
    tr[y].wgti+=tr[x].wgt;
    pushup(y);
    return ;
}
void cut(int x,int y)
{
    split(x,y);
    tr[x].fa=0;
    tr[y].ls=0;
    tr[x].anc=1;
    pushup(y);
    return ;
}
void Insert(int c)
{
    int nwp,nwq,lsp,lsq;
    nwp=++siz;
    tr[nwp].anc=1;
    tr[nwp].is=1;
    s[nwp].len=s[fin].len+1;
    for(lsp=fin;lsp&&!s[lsp].tranc[c];lsp=s[lsp].pre)
        s[lsp].tranc[c]=nwp;
    if(!lsp)
    {
        s[nwp].pre=1;
        link(nwp,1);
    }else{
        lsq=s[lsp].tranc[c];
        if(s[lsq].len==s[lsp].len+1)
        {
            s[nwp].pre=lsq;
            link(nwp,lsq);
        }else{
            nwq=++siz;
            tr[nwq].anc=1;
            s[nwq]=s[lsq];
            cut(s[lsq].pre,lsq);
            link(s[nwq].pre,nwq);
            s[nwq].len=s[lsp].len+1;
            s[nwp].pre=s[lsq].pre=nwq;
            link(nwq,nwp);
            link(nwq,lsq);
            while(s[lsp].tranc[c]==lsq)
            {
                s[lsp].tranc[c]=nwq;
                lsp=s[lsp].pre;
            }
        }
    }
    fin=nwp;
    return ;
}
int Query(int root)
{
    Mtr(1);
    access(root);
    return tr[root].wgti+tr[root].is;
}
int main()
{
    fin=++siz;
    tr[fin].anc=1;
    scanf("%d",&Q);
    scanf("%s",tmp+1);
    int len=strlen(tmp+1);
    for(int i=1;i<=len;i++)
        Insert(tmp[i]-'A');
    while(Q--)
    {
        scanf("%s",tmp);
        if(tmp[0]=='A')
        {
            scanf("%s",tmp+1);
            len=strlen(tmp+1);
            for(int i=1;i<=len;i++)
                atp[i]=tmp[i]-'A';
            U.decode(atp,len);
            for(int i=1;i<=len;i++)
                Insert(atp[i]);
        }else{
            scanf("%s",tmp+1);
            len=strlen(tmp+1);
            for(int i=1;i<=len;i++)
                atp[i]=tmp[i]-'A';
            U.decode(atp,len);
            int root=1;
            for(int i=1;i<=len;i++)
            {
                root=s[root].tranc[atp[i]];
            
            }
            if(!root)
                lasans=0;
            else
                lasans=Query(root);
            printf("%d\n",lasans);
            U.update(lasans);
        }
    }
    return 0;
}