【BZOJ 2555】 2555: SubString （SAM+LCT）

2555: SubString

Time Limit: 30 Sec  Memory Limit: 512 MB
Submit: 2548  Solved: 762

Description

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

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

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

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

Input

第一行一个数Q表示操作个数
    
    第二行一个字符串表示初始字符串init
    
    接下来Q行，每行2个字符串Type,Str 
    
    Type是ADD的话表示在后面插入字符串。
    
    Type是QUERY的话表示询问某字符串在当前字符串中出现了几次。
    
    为了体现在线操作，你需要维护一个变量mask，初始值为0
   
    
    读入串Str之后，使用这个过程将之解码成真正询问的串TrueStr。
    询问的时候，对TrueStr询问后输出一行答案Result
    然后mask = mask xor Result  
    插入的时候，将TrueStr插到当前字符串后面即可。

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

Output

Sample Input

2

A

QUERY B

ADD BBABBBBAAB

Sample Output

0

HINT

40 % 的数据字符串最终长度 <= 20000，询问次数<= 1000，询问总长度<= 10000

100 % 的数据字符串最终长度 <= 600000，询问次数<= 10000,询问总长度<= 3000000

新加数据一组--2015.05.20

Source

Ctsc模拟赛By 洁妹

【分析】

　　一开始都没想着用LCT，后来发现我的SAM的right数组一直都是要逆拓扑序求的。

　　在线的话，还要在线维护。把pre边看成一棵树，就是要支持link，cut操作的，求子树和的东西。

　　其实LCT我只会做路径的，不会做子树了。看了hzwer的代码。【然后好像是，其实也是维护了路径，就是link x和f 的时候就是把f到根的路径都加上val[x]

　　【ORZ欧颓果说用splay维护dfs序也可以啊？

 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 using namespace std;
 #define Maxn 600010
 #define Maxl 3000010
 
 struct node
 {
     int pre,son[],step;
 }t[Maxn*];
 
 struct nnode
 {
     int son[],fa,val,laz;
     nnode() {son[]=son[]=fa=val=laz=;}
 }tr[Maxn*];
 
 char s[Maxl];
 void init(int mask)
 {
     scanf("%s",s);
     int l=strlen(s);
     for(int i=;i<l;i++)
     {
         mask=(mask*+i)%l;
         swap(s[i],s[mask]);
     }
 }
 
 struct lct
 {
     void add(int x,int y)
     {
         if(x) tr[x].val+=y,tr[x].laz+=y;
     }
     bool is_root(int x)
     {
         return tr[tr[x].fa].son[]!=x&&tr[tr[x].fa].son[]!=x;
     }
     bool pushdown(int x)
     {
         int lc=tr[x].son[],rc=tr[x].son[];
         if(tr[x].laz)
         {
             add(lc,tr[x].laz);add(rc,tr[x].laz);
             tr[x].laz=;
         }
     }
     void rot(int x)
     {
         int fa=tr[x].fa,yy=tr[fa].fa;
         int w=tr[tr[x].fa].son[]==x;
 
         if(!is_root(fa))
         {
             if(tr[yy].son[]==fa) tr[yy].son[]=x;
             else tr[yy].son[]=x;
         }tr[x].fa=yy;
 
         tr[fa].son[-w]=tr[x].son[w];
         tr[tr[x].son[w]].fa=fa;
 
         tr[x].son[w]=fa;
         tr[fa].fa=x;
         //upd(fa);//upd(x);
     }
     int q[*Maxn];
     void pre(int x)
     {
         int tp=;
         while(!is_root(x)) q[++tp]=x,x=tr[x].fa;
         q[++tp]=x;
         for(int i=tp;i>=;i--) pushdown(q[i]);
     }
     void splay(int x)
     {
         pre(x);
         while(!is_root(x))
         {
             int fa=tr[x].fa,yy=tr[fa].fa;
             if(!is_root(fa))
             {
                 if((tr[yy].son[]==fa)==(tr[fa].son[]==x)) rot(fa);
                 else rot(x);
             }
             rot(x);
         }//upd(x);
     }
     void access(int x)
     {
         int t=;
         while(x)
         {
             splay(x);
             tr[x].son[]=t;
             t=x;
             x=tr[x].fa;
         }
     }
     /*void split(int x,int y)
     {
         make_root(x);
         access(y);
         splay(y);
     }*/
     void link(int x,int f)
     {
         tr[x].fa=f;
         access(f);
         splay(f);
         add(f,tr[x].val);
     }
     void cut(int x)
     {
         access(x);splay(x);
         add(tr[x].son[],-tr[x].val);
         tr[tr[x].son[]].fa=;
         tr[x].son[]=;
     }
 }lct;
 
 int mask;
 struct sam
 {
     int last,tot;
     void extend(int k)
     {
         int np=++tot,p=last;
         t[np].step=t[p].step+;
         tr[np].val=;
         while(p&&!t[p].son[k])
         {
             t[p].son[k]=np;
             p=t[p].pre;
         }
         if(!p) t[np].pre=,lct.link(np,);
         else
         {
             int q=t[p].son[k];
             if(t[q].step==t[p].step+) t[np].pre=q,lct.link(np,q);
             else
             {
                 int nq=++tot;//upd(tot);
                 t[nq].step=t[p].step+;
                 memcpy(t[nq].son,t[q].son,sizeof(t[nq].son));
                 t[nq].pre=t[q].pre;
                 lct.link(nq,t[nq].pre);
                 t[q].pre=t[np].pre=nq;
                 lct.cut(q);lct.link(q,nq);lct.link(np,nq);
                 while(p&&t[p].son[k]==q)
                 {
                     t[p].son[k]=nq;
                     p=t[p].pre;
                 }
             }
         }
         last=np;
     }
     void add()
     {
         init(mask);
         int l=strlen(s);
         for(int i=;i<l;i++) extend(s[i]-'A'+);
     }
     int query()
     {
         init(mask);
         int nw=,l=strlen(s);
         for(int i=;i<l;i++)
         {
             int ind=s[i]-'A'+;
             if(!t[nw].son[ind]) return ;
             nw=t[nw].son[ind];
         }
         lct.splay(nw);
         return tr[nw].val;
     }
 }sam;
 
 char ss[];
 
 int main()
 {
     int q;
     scanf("%d",&q);
     sam.tot=sam.last=;
     scanf("%s",s);
     int l=strlen(s);
     for(int i=;i<l;i++) sam.extend(s[i]-'A'+);
     while(q--)
     {
         scanf("%s",ss);
         if(ss[]=='A') sam.add();
         else
         {
             int ans=sam.query();
             printf("%d\n",ans);
             mask^=ans;
         }
     }
     return ;
 }

2017-04-19 07:48:14