【bzoj2555】SubString LCT+后缀自动机

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…细节处理什么的早忘了TAT

因为强制在线，还支持后面插入字符串，所以需要用后缀自动机，要找某个串在其中出现多少次，就是求这个串的right集合大小，也就是parent树的子树大小…

插入一个字符，这个字符在它所处的parent链上对它的祖先每个贡献了1，需要每个祖先加1

然而因为数据加强了，不能暴力修改（实测T掉了…）所以需要把这个点到根节点的权值加1…

因为后缀自动机的建立过程中parent树是不断加边、删边的，所以LCT维护parent树…

细节处理：copy的时候别忘了copyright集合大小，想得到q的在LCT中的权值v需要先pushpath一遍，查询的时候需要得到LCT中的真实值所以要pushpath一遍

这是我学的最复杂的两个数据结构了…

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;

const int SZ = 2000010;
const int MAXN = 1200010;

namespace LCT{
    struct node{
        node *ch[2],*f;
        int sz,sum,v;
        bool rev;
        int add;
        void maintain()
        {
            sum = v + ch[0] -> sum + ch[1] -> sum;
            sz = ch[0] -> sz + 1 + ch[2] -> sz;
        }
        void pushdown();

        int dir() { return f -> ch[1] == this; }

        bool isroot() { return f -> ch[0] != this && f -> ch[1] != this;}

        void setc(node* x,int d) { (ch[d] = x) -> f = this; }

    }T[SZ],*tree[SZ],*null;

    int Tcnt = 0;

    node* newnode(int x)
    {
        node *k = T + (Tcnt ++);
        k -> ch[1] = k -> ch[0] = k -> f = null;
        k -> sz = 1;
        k -> sum = k -> v = x;
        k -> add = k -> rev = 0;
        return k;
    }

    void pushrev(node *p)
    {
        if(p == null) return;
        p -> rev ^= 1;
        swap(p -> ch[0],p -> ch[1]);
    }

    void pushadd(node *p,int add)
    {
        if(p == null) return;
        p -> v += add;
        p -> sum += add * p -> sz;
        p -> add += add;
    }

    void node :: pushdown()
    {
        if(rev)
            pushrev(ch[0]),pushrev(ch[1]),rev = 0;
        if(add)
            pushadd(ch[0],add),pushadd(ch[1],add),add = 0;
    }

    node *S[SZ];
    int top = 0;

    void pushpath(node *p)
    {
        while(!p -> isroot())
            S[++ top] = p,p = p -> f;
        S[++ top] = p;
        while(top) S[top --] -> pushdown();
    }

    void rotate(node *p)
    {
        node *fa = p -> f;
        int d = p -> dir();
        p -> f = fa -> f;
        if(!fa -> isroot())
            p -> f -> ch[fa -> dir()] = p;
        fa -> ch[d] = p -> ch[d ^ 1];
        if(fa -> ch[d] != null)
            fa -> ch[d] -> f = fa;
        p -> setc(fa,d ^ 1);
        fa -> maintain(); p -> maintain();
    }

    void splay(node *p)
    {
        pushpath(p);
        while(!p -> isroot())
        {
            if(p -> f -> isroot()) rotate(p);
            else
            {
                if(p -> dir() == p -> f -> dir())
                    rotate(p -> f),rotate(p);
                else
                    rotate(p),rotate(p);
            }
        }
        p -> maintain();
    }

    void access(node *p)
    {
        node *last = null;
        while(p != null)
        {
            splay(p);
            p -> ch[1] = last;
            p -> maintain();
            last = p;
            p = p -> f;
        }
    }

    void toroot(node *p)
    {
        access(p);
        splay(p);
        pushrev(p);
    }

    void cut(node *x,node *y)
    {
        toroot(x);
        access(y);
        splay(y);
        y -> ch[0] = x -> f = null;
    }

    void link(node *x,node *y)
    {
        toroot(x);
        x -> f = y;
    }

    void add(node *x,node *y,int d)
    {
        toroot(x);
        access(y);
        splay(y);
        pushadd(y,d);
    }

    int ask(node *x,node *y)
    {
        toroot(x);
        access(y);
        splay(y);
        return y -> sum;        
    }

    void init()
    {
        null = newnode(0);
        null -> sz = 0;
        for(int i = 0;i <= MAXN;i ++)
            tree[i] = newnode(0);
    }
};


namespace SAM{
    struct sam_node{
        sam_node *ch[5],*par;
        int val;
    }T[SZ], *root, *last;

    LCT :: node* getnode(sam_node *p)
    {
        return LCT :: tree[p - T];
    }

    int Tcnt = 0;

    sam_node* newnode(int x)
    {
        sam_node *k = T + (Tcnt ++);
        k -> val = x;
        k -> par = 0;
        memset(k -> ch,0,sizeof(k -> ch));
        return k;
    }

    void sam_insert(int x)
    {
        sam_node *p = last,*np = newnode(last -> val + 1);
        while(p && !p -> ch[x])
            p -> ch[x] = np,p = p -> par;
        if(!p)
        {
            np -> par = root;
            LCT :: link(getnode(np),getnode(root));
        }
        else
        {
            sam_node *q = p -> ch[x];
            if(q -> val == p -> val + 1)
            {
                np -> par = q;
                LCT :: link(getnode(np),getnode(q));
            }
            else
            {
                sam_node *nq = newnode(p -> val + 1);

                LCT :: cut(getnode(q),getnode(q -> par));
                LCT :: link(getnode(nq),getnode(q -> par));
                LCT :: link(getnode(nq),getnode(q));
                LCT :: link(getnode(nq),getnode(np));
                pushpath(getnode(q)); 
                getnode(nq) -> v = getnode(q) -> v;
                memcpy(nq -> ch,q -> ch,sizeof(nq -> ch));
                nq -> par = q -> par;
                np -> par = q -> par = nq;
                while(p && p -> ch[x] == q)
                    p -> ch[x] = nq,p = p -> par;
            }
        }
        LCT :: add(getnode(np),getnode(root),1);                
        last = np;
    }

    int ask(char s[])
    {
        int l = strlen(s);
        sam_node *p = root;
        for(int i = 0;i < l;i ++)
        {
            int c = s[i] - 'A' + 1;
            if(!p -> ch[c]) return 0;
            p = p -> ch[c];
        }
        LCT :: pushpath(getnode(p));
        return getnode(p) -> v;
    }

    void init()
    {
        root = newnode(0);
        last = root;
    }
}



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


char s[SZ],opt[233];

int main()
{
    SAM :: init();
    LCT :: init();
    int n;
    scanf("%d",&n);
    scanf("%s",s);
    int l = strlen(s);
    for(int i = 0;i < l;i ++)
        SAM::sam_insert(s[i] - 'A' + 1);
    int mask = 0,ans = 0;
    while(n --)
    {
        scanf("%s",opt);
        if(opt[0] == 'Q')
        {
            scanf("%s",s);
            jieya(s,mask);
            ans = SAM::ask(s);
            printf("%d\n",ans);
            mask ^= ans;
        }
        else
        {
            scanf("%s",s);
            jieya(s,mask);
            int l = strlen(s);
            for(int i = 0;i < l;i ++)
                SAM::sam_insert(s[i] - 'A' + 1);
        }
    }
    return 0;
}
/*
5
AAA
QUERY A
QUERY AA
ADD BA
QUERY A
QUERY AB
*/