【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[30],step;
}t[Maxn*2];

struct nnode
{
    int son[2],fa,val,laz;
    nnode() {son[0]=son[1]=fa=val=laz=0;}
}tr[Maxn*2];

char s[Maxl];
void init(int mask)
{
    scanf("%s",s);
    int l=strlen(s);
    for(int i=0;i<l;i++)
    {
        mask=(mask*131+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[0]!=x&&tr[tr[x].fa].son[1]!=x;
    }
    bool pushdown(int x)
    {
        int lc=tr[x].son[0],rc=tr[x].son[1];
        if(tr[x].laz)
        {
            add(lc,tr[x].laz);add(rc,tr[x].laz);
            tr[x].laz=0;
        }
    }
    void rot(int x)
    {
        int fa=tr[x].fa,yy=tr[fa].fa;
        int w=tr[tr[x].fa].son[0]==x;
        
        if(!is_root(fa))
        {
            if(tr[yy].son[0]==fa) tr[yy].son[0]=x;
            else tr[yy].son[1]=x;
        }tr[x].fa=yy;
        
        tr[fa].son[1-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[2*Maxn];
    void pre(int x)
    {
        int tp=0;
        while(!is_root(x)) q[++tp]=x,x=tr[x].fa;
        q[++tp]=x;
        for(int i=tp;i>=1;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[0]==fa)==(tr[fa].son[0]==x)) rot(fa);
                else rot(x);
            }
            rot(x);
        }//upd(x);
    }
    void access(int x)
    {
        int t=0;
        while(x)
        {
            splay(x);
            tr[x].son[1]=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[0],-tr[x].val);
        tr[tr[x].son[0]].fa=0;
        tr[x].son[0]=0;
    }
}lct;

int mask;
struct sam
{
    int last,tot;
    void extend(int k)
    {
        int np=++tot,p=last;
        t[np].step=t[p].step+1;
        tr[np].val=1;
        while(p&&!t[p].son[k])
        {
            t[p].son[k]=np;
            p=t[p].pre;
        }
        if(!p) t[np].pre=1,lct.link(np,1);
        else
        {
            int q=t[p].son[k];
            if(t[q].step==t[p].step+1) t[np].pre=q,lct.link(np,q);
            else
            {
                int nq=++tot;//upd(tot);
                t[nq].step=t[p].step+1;
                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=0;i<l;i++) extend(s[i]-'A'+1);
    }
    int query()
    {
        init(mask);
        int nw=1,l=strlen(s);
        for(int i=0;i<l;i++)
        {
            int ind=s[i]-'A'+1;
            if(!t[nw].son[ind]) return 0;
            nw=t[nw].son[ind];
        }
        lct.splay(nw);
        return tr[nw].val;
    }
}sam;

char ss[10];

int main()
{
    int q;
    scanf("%d",&q);
    sam.tot=sam.last=1;
    scanf("%s",s);
    int l=strlen(s);
    for(int i=0;i<l;i++) sam.extend(s[i]-'A'+1);
    while(q--)
    {
        scanf("%s",ss);
        if(ss[0]=='A') sam.add();
        else
        {
            int ans=sam.query();
            printf("%d
",ans);
            mask^=ans;
        }
    }
    return 0;
}

2017-04-19 07:48:14