BZOJ 2555: SubString 后缀自动机 LCT

2555: SubString

Time Limit: 30 Sec  Memory Limit: 512 MB
Submit: 3214  Solved: 961

[Submit][Status][Discuss]

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

一个子串S的出现次数

|Right(ST(S))|

即ST(S)在parent tree中其子树的叶子节点个数

用lct维护parent tree就好 （听说暴力比正解快三倍

parent tree作为一个有根树 维护超方便

比较珂怕的是 BJ调了1h...太菜了...

记录一下BJ翻的shabi错误

让BJ来对比对比access 泪 才几天没写啊 泪

void access(int x)
{int t=0;while(!isroot(x)){splay(x);ch[x][1]=t;x=fa[x];}}

void access(int x)
{int t=0;while(x){splay(x);ch[x][1]=t;t=x;x=fa[x];}}

AC code

#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<string>
#include<bitset>
#include<queue>
#include<set>
#include<map>
using namespace std;

typedef long long ll;

inline int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch<='9'&&ch>='0'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
void print(int x)
{if(x<0)putchar('-'),x=-x;if(x>=10)print(x/10);putchar(x%10+'0');}

const int N=1200100,bas=131;

struct LCT
{
int ch
[2],fa
,V
,tag
;

inline void pushdown(int x)
{
if(tag[x])
{
tag[ch[x][0]]+=tag[x];tag[ch[x][1]]+=tag[x];
V[ch[x][0]]+=tag[x];V[ch[x][1]]+=tag[x];
tag[x]=0;
}
}

inline bool isroot(int x)
{return ch[fa[x]][0]!=x && ch[fa[x]][1]!=x;}

void getdown(int x)
{if(!isroot(x)) getdown(fa[x]);pushdown(x);}

void rotate(int x)
{
int y=fa[x],z=fa[y],l,r;
l=(ch[y][1]==x);r=l^1;
if(!isroot(y)) ch[z][ch[z][1]==y]=x;
fa[x]=z;fa[y]=x;fa[ch[x][r]]=y;
ch[y][l]=ch[x][r];ch[x][r]=y;
}

void splay(int x)
{
getdown(x);
int y,z;
while(!isroot(x))
{
y=fa[x],z=fa[y];
if(!isroot(y))
{
if((ch[z][0]==y)^(ch[y][0]==x)) rotate(x);
else rotate(y);
}
rotate(x);
}
}

void access(int x)
{int t=0;while(x){splay(x);ch[x][1]=t;t=x;x=fa[x];}}

void rever(int x)
{access(x);splay(x);}

void link(int u,int v)
{fa[v]=u;rever(u);V[u]+=V[v];tag[u]+=V[v];}

void cut(int v)
{rever(v);V[ch[v][0]]-=V[v];tag[ch[v][0]]-=V[v];fa[ch[v][0]]=0;ch[v][0]=0;}

int query(int x)
{splay(x);return V[x];}
};

struct SAM
{
LCT lct;
int trans
[26],par
,mx
;
int sz,root,suff;

SAM(){sz=root=suff=1;}

void insert(int x)
{
int p=suff,np=++sz;
lct.V[np]=1;
mx[np]=mx[p]+1;
while(p && !trans[p][x])
trans[p][x]=np,p=par[p];
if(!p) par[np]=root,lct.link(root,np);
else
{
int q=trans[p][x];
if(mx[q]==mx[p]+1) par[np]=q,lct.link(q,np);
else
{
int nq=++sz;
mx[nq]=mx[p]+1;
memcpy(trans[nq],trans[q],sizeof(trans[q]));
lct.cut(q);
lct.link(par[q],nq);
lct.link(nq,q);lct.link(nq,np);
par[nq]=par[q];
par[q]=par[np]=nq;
while(p && trans[p][x]==q)
trans[p][x]=nq,p=par[p];
}
}
suff=np;
}

void add(char *s)
{for(int i=0;s[i];++i) insert(s[i]-'A');}

int getans(char *s)
{
int now=root;
for(int i=0;s[i];++i)
if(!(now=trans[now][s[i]-'A'])) return 0;
return lct.query(now);
}
}sam;

inline void decode(char *s,int mask)
{
int len=strlen(s);
for(int i=0;i<len;++i)
{
mask=(mask*bas+i)%len;
swap(s[mask],s[i]);
}
}

char opt[10],s[N>>1];

int main()
{
int Q=read();
scanf("%s",s);
sam.add(s);
int mask=0,ans;
while(Q--)
{
scanf("%s%s",opt,s);
decode(s,mask);
switch(opt[0])
{
case 'A':
sam.add(s);
break;
case 'Q':
ans=sam.getans(s);
print(ans);putchar('\n');
mask^=ans;
break;
}
}
return 0;
}