bzoj 2555 SubString（SAM+LCT）

 

【题目链接】

 

    http://www.lydsy.com/JudgeOnline/problem.php?id=2555

 

【题意】

 

    给定一个字符串，可以随时插入字符串，提供查询s在其中作为连续子串的出现次数。

 

【思路】

 

    子串的出现次数，这使我们想到了后缀自动机，如果没有插入操作，则出现次数为字符串对应节点|right|集的大小。

    Right的递推方法为：|fa->right| <- |right|

    如果暴力做的话，可以每一次插入都重新计算right。时间复杂度为O(mn)。

　 因为需要不断地插入字符串，所以parent树会发生变化，我们考虑使用LCT维护parent树。SAM中插入字符串时需要改变父亲，对应到LCT中即切断原树中本来的父亲，连接新的父亲，最后还应该把np的所有fa的|right|加1，对应于LCT中的一次区间加值。

    这样只需要用LCT维护一个值与一个懒标记即可。

　注意LCT原来的Link是连接两个点，而这里的Link需要切断原来的父亲后连接新父亲。

 

【代码】

 

#include<cstdio>
#include<cstring>
#include<iostream>
#define FOR(a,b,c) for(int a=b;a<=c;a++)
#define trav(u,i) for(int i=front[u];i;i=e[i].nxt)
using namespace std;

const int N = 4e6+10;

namespace LCT {

    struct Node {
        Node *ch[2],*fa;
        int v,add,rev;
        Node() ;
        void addv(int x) {
            v=v+x;
            add=add+x;
        }
        void reverse() {
            rev^=1;
            swap(ch[0],ch[1]);
        }
        void up_push() {
            if(fa->ch[0]==this||fa->ch[1]==this)
                fa->up_push();
            if(add) {
                ch[0]->addv(add);
                ch[1]->addv(add);
                add=0;
            }
            if(rev) {
                ch[0]->reverse();
                ch[1]->reverse();
                rev=0;
            }
        }
        void maintain() {
        }
    } *null=new Node ;
    Node:: Node() {
        fa=ch[0]=ch[1]=null;
        add=v=rev=0;
    }
    
    void rot(Node* o,int d) {
        Node *p=o->fa;
        p->ch[d]=o->ch[d^1];
        o->ch[d^1]->fa=p;
        o->ch[d^1]=p;
        o->fa=p->fa;
        if(p==p->fa->ch[0])
            p->fa->ch[0]=o;
        else if(p==p->fa->ch[1])
            p->fa->ch[1]=o;
        p->fa=o;
        p->maintain();
    }
    void splay(Node* o) {
        o->up_push();
        Node *nf,*nff;
        while(o->fa->ch[0]==o||o->fa->ch[1]==o) {
            nf=o->fa,nff=nf->fa;
            if(o==nf->ch[0]) {
                if(nf==nff->ch[0]) rot(nf,0);
                rot(o,0);
            } else {
                if(nf==nff->ch[1]) rot(nf,1);
                rot(o,1);
            }
        }
        o->maintain();
    }
    void Access(Node* o) {
        Node* son=null;
        while(o!=null) {
            splay(o);
            o->ch[1]=son;
            o->maintain();
            son=o; o=o->fa;
        }
    }
    void evert(Node* o) {
        Access(o); 
        splay(o);
        o->reverse();
    }
    /*
    void Link(Node *u,Node *v) {
        evert(u);
        u->fa=v;
    }
    void Cut(Node *u,Node *v) {
        evert(u);
        Access(v); splay(v);
        u->fa=v->ch[0]=null;
        v->maintain();
    }
    */
    void Link(Node* u,Node* v) {    //改变父亲为v 需要切断原来的父亲 
        Access(u),splay(u);
        u->ch[0]->fa=u->ch[0]=null;
        u->fa=v;
    }

}

namespace SAM {

    struct Snode {
        Snode *ch[26],*fa;
        int l;
        LCT::Node *lct;
        Snode(int _=0) :fa(0x0),l(_) {
            memset(ch,0,sizeof(ch));
            lct=new LCT::Node;
        }
    } *root=new Snode,*last=root;
    
    void add(int x) {
        Snode *p=last,*np=new Snode(p->l+1);
        last=np;
        for(;p&&!p->ch[x];p=p->fa)
            p->ch[x]=np;        
        if(!p) {
            np->fa=root;
            LCT::Link(np->lct,root->lct);
        } else {
            Snode *q=p->ch[x];
            if(q->l==p->l+1) {
                np->fa=q;
                LCT::Link(np->lct,q->lct);
            } else {
                Snode* nq=new Snode(p->l+1);
                memcpy(nq->ch,q->ch,sizeof nq->ch);
                nq->fa=q->fa;
                LCT::Link(nq->lct,q->fa->lct);
                np->fa=nq; q->fa=nq;
                LCT::Link(q->lct,nq->lct);                    //修改parent树中的父亲 
                LCT::Link(np->lct,nq->lct);
                q->lct->up_push();
                nq->lct->v=q->lct->v;
                
                for(;p&&p->ch[x]==q;p=p->fa)
                    p->ch[x]=nq;
            }
        }
        LCT::Access(np->lct);
        LCT::splay(np->lct);
        np->lct->addv(1);
    }
    void insert(char *s) {
        for(int i=0;s[i];i++)
            add(s[i]-'A');
    }
    int query(char *s) {
        for(Snode *p=root;p;p=p->ch[(*s++)-'A'])
            if(!*s) return p->lct->up_push(),p->lct->v;
        return 0;
    }
    
}

void Decode(char s[],int mask)
{
    int i,n=strlen(s);
    for(int i=0;i<n;i++) {
        mask=(mask*131+i)%n;
        swap(s[i],s[mask]);
    }
}

int q,mask;
char s[N],op[20];

int main()
{
    scanf("%d%s",&q,s);
    SAM::insert(s);
    while(q--) {
        scanf("%s%s",op,s);
        Decode(s,mask);
        if(op[0]=='Q') {
            int ans=SAM::query(s);
            mask^=ans;
            printf("%d\n",ans);
        } else {
            SAM::insert(s);
        }
    }
    return 0;
}