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=;i<=len;i++)
                 tmp[i-]=a[i];
             for(int i=;i<len;i++)
             {
                 upg=(upg*+i)%len;
                 std::swap(tmp[i],tmp[upg]);
             }
             for(int i=;i<=len;i++)
                 a[i]=tmp[i-];
             return ;
         }
     private:
         int tmp[];
         int mask;
 }U;
 struct trnt{
     int ch[];
     int fa;
     int is;
     int lzt;
     int wgt;
     int wgti;
     bool anc;
 }tr[];
 struct sant{
     int tranc[];
     int len;
     int pre;
 }s[];
 int Q;
 int siz;
 int fin;
 int lasans;
 char tmp[];
 int atp[];
 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^=;
     return ;
 }
 void pushdown(int spc)
 {
     if(tr[spc].lzt)
     {
         trr(lll);
         trr(rrr);
         tr[spc].lzt=;
     }
     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=;
         tr[spc].anc=;
     }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=;
     while(spc)
     {
         splay(spc);
         tr[spc].wgti-=tr[lst].wgt;
         tr[spc].wgti+=tr[rrr].wgt;
         tr[rrr].anc=;
         tr[lst].anc=;
         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=;
     tr[y].ls=;
     tr[x].anc=;
     pushup(y);
     return ;
 }
 void Insert(int c)
 {
     int nwp,nwq,lsp,lsq;
     nwp=++siz;
     tr[nwp].anc=;
     tr[nwp].is=;
     s[nwp].len=s[fin].len+;
     for(lsp=fin;lsp&&!s[lsp].tranc[c];lsp=s[lsp].pre)
         s[lsp].tranc[c]=nwp;
     if(!lsp)
     {
         s[nwp].pre=;
         link(nwp,);
     }else{
         lsq=s[lsp].tranc[c];
         if(s[lsq].len==s[lsp].len+)
         {
             s[nwp].pre=lsq;
             link(nwp,lsq);
         }else{
             nwq=++siz;
             tr[nwq].anc=;
             s[nwq]=s[lsq];
             cut(s[lsq].pre,lsq);
             link(s[nwq].pre,nwq);
             s[nwq].len=s[lsp].len+;
             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();
     access(root);
     return tr[root].wgti+tr[root].is;
 }
 int main()
 {
     fin=++siz;
     tr[fin].anc=;
     scanf("%d",&Q);
     scanf("%s",tmp+);
     int len=strlen(tmp+);
     for(int i=;i<=len;i++)
         Insert(tmp[i]-'A');
     while(Q--)
     {
         scanf("%s",tmp);
         if(tmp[]=='A')
         {
             scanf("%s",tmp+);
             len=strlen(tmp+);
             for(int i=;i<=len;i++)
                 atp[i]=tmp[i]-'A';
             U.decode(atp,len);
             for(int i=;i<=len;i++)
                 Insert(atp[i]);
         }else{
             scanf("%s",tmp+);
             len=strlen(tmp+);
             for(int i=;i<=len;i++)
                 atp[i]=tmp[i]-'A';
             U.decode(atp,len);
             int root=;
             for(int i=;i<=len;i++)
             {
                 root=s[root].tranc[atp[i]];

             }
             if(!root)
                 lasans=;
             else
                 lasans=Query(root);
             printf("%d\n",lasans);
             U.update(lasans);
         }
     }
     return ;
 }