BZOJ5408: string(广义后缀自动机，LCT)

传送门

解题思路：

首先在后缀树上，确定了一个节点就相当于确定了一个串，那么一个点对应的串在另外一个点对应的串产生贡献，当且仅当这个点在当前点子树内。

那么考虑一个新的点在串中对串答案的贡献在一条树链上或者反过来说，就是产生贡献的点在这个点子树内。

才知道自己写的广义后缀自动机板子是错的QAQ

考虑n非常小，贡献可以单独算，再配合BZOJ2555的启发，这道题就可以使用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]
 typedef long long lnt;
 struct trnt{
     int ch[];
     int fa;
     int val[];
     int lzt[];
     bool anc;
 }tr[];
 struct sant{
     int tranc[];
     int pre;
     int len;
 }s[];
 int n,m;
 lnt sum;
 int siz;
 int type;
 int lastans;
 int pos[][];
 char str[];
 bool whc(int spc)
 {
     return tr[tr[spc].fa].rs==spc;
 }
 void add(int spc,int no,int v)
 {
     if(!spc)return ;
     tr[spc].val[no]+=v;
     tr[spc].lzt[no]+=v;
     return ;
 }
 void pushdown(int spc)
 {
     for(int i=;i<=n;i++)
     {
         if(tr[spc].lzt[i])
         {
             add(lll,i,tr[spc].lzt[i]);
             add(rrr,i,tr[spc].lzt[i]);
             tr[spc].lzt[i]=;
         }
     }
 }
 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=false;
         tr[spc].anc=true;
     }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;
     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[rrr].anc=true;
         tr[lst].anc=false;
         rrr=lst;
         lst=spc;
         spc=tr[spc].fa;
     }
     return ;
 }
 void ADD(int from,int to,int cmd)
 {
     recal(from);
     for(int i=;i<=n;i++)
     {
         if(tr[from].val[i])
         {
             add(to,i,tr[from].val[i]*cmd);
         }
     }
     return ;
 }
 void link(int x,int f)
 {
     access(f);
     splay(f);
     splay(x);
     ADD(x,f,);
     tr[x].fa=f;
     return ;
 }
 void cut(int spc)
 {
     access(spc);
     splay(spc);
     int spc_=lll;
     lll=tr[spc_].fa=;
     tr[spc_].anc=true;
     splay(spc_);
     ADD(spc,spc_,-);
     return ;
 }
 int decode(int c)
 {
     if(type)return (c xor lastans)%;
     return c;
 }
 int Insert(int fin,int no,int c)
 {
     if(s[fin].tranc[c]&&s[s[fin].tranc[c]].len==s[fin].len+)
     {
         int spc=s[fin].tranc[c];
         access(spc);
         splay(spc);
         add(spc,no,);
         return spc;
     }
     int nwp,lsp,nwq,lsq,flag=;
     nwp=++siz;tr[nwp].val[no]=;
     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{
             if(s[nwp].len==s[lsp].len+)flag=;
             nwq=++siz;
             s[nwq]=s[lsq];
             s[nwq].len=s[lsp].len+;
             s[nwp].pre=s[lsq].pre=nwq;
             cut(lsq);
             link(nwq,s[nwq].pre);
             link(nwp,nwq);
             link(lsq,nwq);
             while(s[lsp].tranc[c]==lsq)
             {
                 s[lsp].tranc[c]=nwq;
                 lsp=s[lsp].pre;
             }
         }
     }
     sum+=s[nwp].len-s[s[nwp].pre].len;
     if(flag)return nwq;
     return nwp;
 }
 void init(void)
 {
     for(int i=;i<=;i++)tr[i].anc=true;
     siz=;
     return ;
 }
 int query(char *a)
 {
     int len=strlen(a+);
     int spc=;
     for(int i=;i<=len;i++)
     {
         int c=a[i]-'';
         spc=s[spc].tranc[c];
         if(!spc)return ;
     }
     int ans=-;
     recal(spc);
     for(int i=;i<=n;i++)
         ans=std::max(ans,tr[spc].val[i]);
     return ans;
 }
 int main()
 {
     scanf("%d%d",&n,&type);
     init();
     for(int i=;i<=n;i++)
     {
         scanf("%s",str+);
         int len=strlen(str+);
         pos[i][]=;
         for(int j=;j<=len;j++)
             pos[i][]=Insert(pos[i][],i,str[j]-'');
     }
     scanf("%d",&m);
     for(int r=;r<=m;r++)
     {
         for(int i=;i<=n;i++)pos[i][r]=pos[i][r-];
         int opt;
         scanf("%d",&opt);
         if(opt==)
         {
             int x,y;
             scanf("%d%d",&x,&y);
             y=decode(y);
             pos[x][r]=Insert(pos[x][r],x,y);
         }
         if(opt==)
         {
             int x,y,z;
             scanf("%d%d%d",&x,&y,&z);
             int spc=pos[x][y];
             recal(spc);
             lastans=tr[spc].val[z];
             printf("%d\n",lastans);
         }
         if(opt==)printf("%lld\n",sum);
         if(opt==)
         {
             scanf("%s",str+);
             lastans=query(str);
             printf("%d\n",lastans);
         }
     }
     return ;
 }