Bzoj2555 SubString

Time Limit: 30 Sec  Memory Limit: 512 MB
Submit: 2430  Solved: 719

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

离线问子串出现次数的话，只需要在自动机上从底到顶更新fa结点的size，再回答询问即可。

如果要在线维护，那么每次新建一个结点，就需要从这个结点沿fa指针上溯，把经过的结点size都加1。

当数据很大的时候，这样暴力维护显然会T

然而似乎题目原本的数据比较弱，导致暴力操作并不会达到复杂度上界，甚至跑得比正解快……

数据加强以后，就只能写正解了。

我们需要一个能在树上区间加值的数据结构，同时要支持SAM的建中继结点操作。就决定是LCT了。

于是这就变成了一道考LCT的码农题……

蠢蠢地花了两晚上调过了样例，不过调过样例就直接A了也是带感。

マジやばくね

/*by SilverN*/
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
const int mxn=1100010;
struct LCT{
    int ch[mxn][2],fa[mxn];
    int val[mxn],mk[mxn];
    bool rev[mxn];
    int st[mxn],top;
    inline bool isroot(int x){
        return (ch[fa[x]][0]!=x)&&(ch[fa[x]][1]!=x);
    }
    inline void PD(int x){
        if(mk[x]){
            int &lc=ch[x][0],&rc=ch[x][1];
            mk[lc]+=mk[x];mk[rc]+=mk[x];
            val[lc]+=mk[x];val[rc]+=mk[x];
            mk[x]=0;
        }
        if(rev[x]){
            int &lc=ch[x][0],&rc=ch[x][1];
            swap(lc,rc);
            rev[lc]^=1;rev[rc]^=1;
            rev[x]^=1;
        }
        return;
    }
    void rotate(int x){
        int y=fa[x],z=fa[y],lc,rc;
        if(ch[y][0]==x)lc=0;else lc=1; rc=lc^1;
        if(!isroot(y)){
            ch[z][ch[z][1]==y]=x;
        }
        fa[x]=z;fa[y]=x;
        fa[ch[x][rc]]=y;
        ch[y][lc]=ch[x][rc];
        ch[x][rc]=y;
        return;
    }
    void Splay(int x){
        st[top=1]=x;
        for(int i=x;!isroot(i);i=fa[i])st[++top]=fa[i];
        while(top)PD(st[top--]);
        while(!isroot(x)){
            int y=fa[x],z=fa[y];
            if(!isroot(y)){
                if((ch[y][0]==x)^(ch[z][0]==y))rotate(x);
                else rotate(y);
            }
            rotate(x);
        }
        return;
    }
    void access(int x){
        for(int y=0;x;x=fa[x]){
            Splay(x);
            ch[x][1]=y;
            y=x;
        }
        return;
    }
    void link(int x,int y){
        fa[x]=y;access(y);Splay(y);
        val[y]+=val[x];mk[y]+=val[x];
        return;
    }
    void cut(int x,int y){
        access(y);Splay(y);
        if(ch[y][0]==x){
            fa[x]=ch[y][0]=0;
            val[x]-=val[y];mk[x]-=val[y];
        }
        return;
    }
    inline int query(int x){
        access(x);Splay(x);
        return val[x];
    }
}Lt;
struct SAM{
    int t[mxn][26],fa[mxn],l[mxn],sz[mxn];
    int S,last,cnt;
    void init(){S=last=cnt=1;return;}
    void add(int c){
        int p=last,np=++cnt;last=np;
        l[np]=l[p]+1;
        Lt.val[np]=1;
        sz[np]++;
        for(;p && !t[p][c];p=fa[p]){
            t[p][c]=np;
        }
        if(!p){
            fa[np]=S;
            Lt.link(np,S);
        }
        else{
            int q=t[p][c];
            if(l[q]==l[p]+1){
                fa[np]=q;
                Lt.link(np,q);
            }
            else{
                int nq=++cnt;
                l[nq]=l[p]+1;
                memcpy(t[nq],t[q],sizeof t[q]);
                //
                Lt.link(nq,fa[q]);
                Lt.cut(fa[q],q);
                Lt.link(np,nq);
                Lt.link(q,nq);
                //
                fa[nq]=fa[q];
                fa[q]=fa[np]=nq;
                for(;p && t[p][c]==q;p=fa[p]){
                    t[p][c]=nq;
                }
            }
        }
        return;
    }
    int query(char *s){
        int len=strlen(s);
        int now=S;
        for(int i=0;i<len;i++){
            if(t[now][s[i]-'A']){
                now=t[now][s[i]-'A'];
            }
            else return 0;
        }
        return Lt.query(now);
    }
}sa;
char s[3000002],op[10];
void decode(char *c,int mask){//解码 
    int len=strlen(s);
    for(int j=0;j<len;j++){
        mask=(mask*131+j)%len;
        char t=c[j];
        c[j]=c[mask];
        c[mask]=t;
    }
    return;
}
int Q,tlen,mask=0;
int main(){
    int i,j;
    scanf("%d",&Q);
    scanf("%s",s);
    sa.init();
    int len=strlen(s);tlen=len;
    for(i=0;i<len;i++) sa.add(s[i]-'A');
    while(Q--){
        scanf("%s%s",op,s);
        decode(s,mask);//解码 
        if(op[0]=='A'){
            int len=strlen(s);
            tlen+=len;
            for(i=0;i<len;i++){
                sa.add(s[i]-'A');
            }
        }
        else{
            int res=sa.query(s);
            mask^=res;
            printf("%d
",res);
        }
    }
    return 0;
}