[BZOJ2555]-SubString-后缀自动机+LCT维护parent树

说在前面

今天写了好多后缀自动机的题啊…
感觉me又变强了hhhhh（然而这一定是错觉=w=

---

题目

BZOJ2555传送门

题目大意

给定一个初始字符串S，现在需要支持以下两种操作：
1. 在S后面添加一段字符串
2. 查询某个字符串在 S 中出现的次数（可重）
强制在线

输入输出格式

输入输出格式比较复杂，这里就不写了…
可以直接去B站上看，不是权限题

---

解法

如果没有第一种操作，这就是一道 后缀自动机 模板题了（参见「SPOJ NSUBSTR - Substrings」）
那么如何维护第一种操作呢= =？
注意到添加字符串只会在尾部加入，那这就是后缀自动机的增量构造，然而增量构造是会修改parent树的，因此信息需要动态维护。具体的，每加入一个字符（假设这个当前节点为node），需要维护的操作是：在parent树上连接一个节点，修改一个节点的父亲，更新链的信息。发现这不就是LCT干的事情嘛= =，然后直接无脑套LCT维护parent树就行了

LCT维护有两种方式，第一种是维护子树信息（参见「BZOJ4530 大融合」），另一种就是常规的打标记，me使用的是第一种方式

注意一个小地方，mask在decode函数里是传参，外面的mask是不会变的

---

下面是自带大常数的代码

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

int N , Q , mask , qlen , id_c ;
char ss[600005] , qs[3000005] ;
struct SAM_Node{
    int len , id ;
    SAM_Node *ch[26] , *par ;
}w[1200005] , *tw = w , *SAM_root , *last ;
struct Splay_Node{
    bool isMain ;
    int isiz , rsiz , id ;
    Splay_Node *fa , *ch[2] ;
    void update(){
        rsiz = isMain ;
        if( ch[0] ) rsiz += ch[0]->rsiz + ch[0]->isiz ;
        if( ch[1] ) rsiz += ch[1]->rsiz + ch[1]->isiz ;
    }
}p[1200005] , *tp = p ;

void newNode( SAM_Node *&nd , int len , bool isMain ){
    nd = ++tw ;
    nd->id = ++id_c , nd->len = len ;

    Splay_Node *t = ++tp ;
    t->id = id_c ;
    t->rsiz = t->isMain = isMain ;
}

void decode(){
    int tmp = mask ;
    for( int j = 0 ; j < qlen ; j ++ ){
        tmp = ( tmp * 131 + j ) % qlen ;
        swap( qs[j] , qs[tmp] ) ;
    }
}

bool isRoot( Splay_Node *nd ){
    if( !nd->fa ) return true ;
    return nd->fa->ch[0] != nd && nd->fa->ch[1] != nd ;
}

void Rotate( Splay_Node *nd , short aim ){
    Splay_Node *x = nd->ch[aim] ;
    if( nd->fa ){
        if( nd->fa->ch[0] == nd ) nd->fa->ch[0] = x ;
        else if( nd->fa->ch[1] == nd ) nd->fa->ch[1] = x ;
    } x->fa = nd->fa ;
    if( x->ch[aim^1] ){
        x->ch[aim^1]->fa = nd ;
    } nd->ch[aim] = x->ch[aim^1] ;

    x->ch[aim^1] = nd , nd->fa = x ;
    nd->update() ;
    x->update() ;
}

// int topp ;
// Splay_Node *sta[1200005] ;
void Splay( Splay_Node *nd ){
/*  
    Splay_Node *tmp = nd ;
    for( ; !isRoot( tmp ) ; tmp = tmp->fa ) sta[++topp] = tmp ;
    sta[++topp] = tmp ;
    for( ; topp ; topp -- ) sta[topp]->pushdown() ;
*/
    while( !isRoot( nd ) ){
        Splay_Node *fa = nd->fa , *gdfa = fa->fa ;
        short pn = ( fa->ch[1] == nd ) , pf ;
        if( !isRoot( fa ) ){
            pf = ( gdfa->ch[1] == fa ) ;
            if( pn == pf ) Rotate( gdfa , pf ) , Rotate( fa , pn ) ;
            else           Rotate( fa , pn ) , Rotate( gdfa , pf ) ;
        } else Rotate( fa , pn ) ;
    }
}

void Access( Splay_Node *nd ){
    Splay_Node *las = NULL ;
    while( nd ){
        Splay( nd ) ;
        if( las ) nd->isiz -= las->rsiz + las->isiz ;
        if( nd->ch[1] ) nd->isiz += nd->ch[1]->rsiz + nd->ch[1]->isiz ;
        nd->ch[1] = las ;
        nd->update() ;
        las = nd ; nd = nd->fa ;
    }
}

void Link( Splay_Node *x , Splay_Node *y ){ // Node x's father is Node y 
    Access( y ) ; Splay( y ) ;
    Access( x ) ; Splay( x ) ;
    x->fa = y ;
    y->isiz += x->rsiz + x->isiz ;
}

void Cut( Splay_Node *x , Splay_Node *y ){  // similar to Link
    Access( y ) ; Splay( y ) ;
    Access( x ) ;
    y->ch[1] = x->fa = NULL ;
    y->update() ;
}

void Insert( const char &cc ){
//  printf( "%c start: \n" , cc ) ;
    SAM_Node *nd , *tmp = last ;
    newNode( nd , tmp->len + 1 , true ) ;
//  puts( "newNode ended\n" ) ;
    short id = cc - 'A' ;
    for( ; tmp && !tmp->ch[id] ; tmp = tmp->par )
        tmp->ch[id] = nd ;
    if( !tmp ) nd->par = SAM_root ;
    else {
    //  puts( "trans exist" ) ;
        SAM_Node *B = tmp->ch[id] ;
    //  printf( "B : %p\n" , tmp->ch[id] ) ; 
        if( tmp->len + 1 == B->len ) nd->par = B ;
        else{
        //  puts( "new nB" ) ;
            SAM_Node *nB ; newNode( nB , tmp->len + 1 , false ) ;
            memcpy( nB->ch , B->ch , sizeof( nB->ch ) ) ;

        //  puts( " Link " ) ;
            Link( ( p + nB->id ) , ( p + B->par->id ) ) ; nB->par = B->par ;
        //  puts( " Cut " ) ;
            Cut ( ( p + B->id )  , ( p + B->par->id ) )   ;
        //  puts( " Link " ) ;
            Link( ( p + B->id )  , ( p + nB->id ) ) ; nd->par = B->par = nB ;

            while( tmp && tmp->ch[id] == B ){
                tmp->ch[id] = nB ;
                tmp = tmp->par ;
            }
        }
    }
//  puts( "out Link" ) ;
    Link( ( p + nd->id ) , ( p + nd->par->id ) ) ;
    last = nd ;
//  printf( "%c successfully ended \n\n" , cc ) ;
}

int RUN(){
    SAM_Node *nd = SAM_root ;
    for( int i = 0 ; i < qlen ; i ++ ){
        short id = qs[i] - 'A' ;
        if( !nd->ch[id] ) return 0 ;
        nd = nd->ch[id] ;
    }
    Access( p + nd->id ) ; Splay( p + nd->id ) ; 
    return ( p + nd->id )->isiz + ( p + nd->id )->isMain ;
}
void solve(){
    char opt[10] ;
    for( int i = 1 ; i <= Q ; i ++ ){
        scanf( "%s%s" , opt , qs ) ;
        qlen = strlen( qs ) ; decode() ;
    //  printf( "%s %s\n" , opt , qs ) ;
        if( opt[0] == 'A' ){
            for( int j = 0 ; j < qlen ; j ++ ) Insert( qs[j] ) ;
        } else{
            int ans = RUN() ; mask ^= ans ;
            printf( "%d\n" , ans ) ;
        }
    }
}

int main(){
    newNode( SAM_root , 0 , false ) ; last = SAM_root ;
    scanf( "%d" , &Q ) ;
    scanf( "%s" , ss + 1 ) ; N = strlen( ss + 1 ) ;
    for( int i = 1 ; i <= N ; i ++ ) Insert( ss[i] ) ;
    solve() ;
}