BZOJ2555 Substring 题解（SAM+LCT）

题目：BZOJ2555.
题目大意：给定一个串$S$，现在要求支持两个操作：
1.在$S$的末位加入一个串$T_i$.
2.查询$T_i$在$S$中的出现次数.
任何时刻$1\le |S|\le 6\ast 10^5$，操作$2$次数$\le 10^4$，$\sum T_i\le 3\ast 10^6$.
强制在线.

首先考虑查询操作，本质上就是把$T_i$放到$S$上跑，跑到的那个状态的Right集合大小即为答案.

考虑在末位加入字符，发现这个操作若不需要维护Right大小会非常容易，但是维护Right集合大小就会非常麻烦.

回忆Right集合大小的求法，所有实点都会有一个点权为$1$，虚点为$0$，一个状态的Right集合大小是它在Parent树上整棵子树的点权和，所以我们要维护Parent树.

考虑在末位加字符会如何修改Parent树，会发现有加点和改父亲两种操作，然后又要维护子树和，容易想到用LCT来维护，维护子树和的部分转化为链加就好了.

所以SAM+LCT就可以解决这个问题啦，时间复杂度$O(|S|(\Sigma +\log |S|)+\sum |T_i|)$.

代码如下（感觉写崩了跑得贼慢）：

#include<bits/stdc++.h> 
  using namespace std;
 
#define Abigail inline void
typedef long long LL;

const int N=600000,C=26;

struct link_cut_tree{
  struct tree{
    int x,s[2],tag,fa;
  }tr[N*2+9];
  int tmp[N*2+9],tt;
  
  bool Isroot(int x){return tr[tr[x].fa].s[0]^x&&tr[tr[x].fa].s[1]^x;}
  void Update_add(int x,int v){tr[x].tag+=v;tr[x].x+=v;}
  void Pushdown(int x){if (!tr[x].tag) return;Update_add(tr[x].s[0],tr[x].tag);Update_add(tr[x].s[1],tr[x].tag);tr[x].tag=0;}
  
  void Rotate(int x){
    int y=tr[x].fa,z=tr[y].fa,k=tr[y].s[1]==x;
    if (!Isroot(y)) tr[z].s[tr[z].s[1]==y]=x;tr[x].fa=z;
    tr[y].s[k]=tr[x].s[k^1];if (tr[x].s[k^1]) tr[tr[x].s[k^1]].fa=y;
    tr[x].s[k^1]=y;tr[y].fa=x;
  }
  
  void Splay(int x){
    tmp[tt=1]=x;
    for (int i=x;!Isroot(i);i=tr[i].fa) tmp[++tt]=tr[i].fa;
    for (;tt;--tt) Pushdown(tmp[tt]);
    int y,z;
    while (!Isroot(x)){
   	  y=tr[x].fa,z=tr[y].fa;
  	  if (!Isroot(y)) tr[z].s[0]==y^tr[y].s[0]==x?Rotate(x):Rotate(y);
      Rotate(x);
    }
  }
  
  void Access(int x){for (int t=0;x;t=x,x=tr[x].fa) Splay(x),tr[x].s[1]=t;}
  void New_node(int x,int v){tr[x].x=v;}
  void Change_add(int x,int v){Access(x);Splay(x);Update_add(x,v);}
  void Link(int x,int fa){tr[x].fa=fa;Access(x);Change_add(fa,tr[x].x);}
  void Cut(int x,int fa){Access(x);tr[fa].s[1]=tr[x].fa=0;Change_add(fa,-tr[x].x);}
  int Query(int x){if (x==0) return 0;Access(x);Splay(x);return tr[x].x;}
}lct;

struct automaton{
  int s[C],len,par;
}tr[N*2+9];
int cn,last;

void Build_sam(){cn=last=1;}

void extend(int x){
  int p=last,np=++cn;
  tr[np].len=tr[p].len+1;lct.New_node(np,1);
  last=np;
  while (p&&!tr[p].s[x]) tr[p].s[x]=np,p=tr[p].par;
  if (!p) tr[np].par=1,lct.Link(np,1);
  else{
  	int q=tr[p].s[x];
  	if (tr[p].len+1==tr[q].len) tr[np].par=q,lct.Link(np,q);
  	else{
	  tr[++cn]=tr[q];tr[cn].len=tr[p].len+1;
	  lct.New_node(cn,0);lct.Link(cn,tr[q].par);
	  tr[np].par=cn;lct.Link(np,cn);
	  lct.Cut(q,tr[q].par);tr[q].par=cn;lct.Link(q,cn);
	  while (p&&tr[p].s[x]==q) tr[p].s[x]=cn,p=tr[p].par;
	}
  }
}

int q,n,mask,l;
char s[N+9];
string chars;

void gets(int mask){
  scanf("%s",s);
  chars=s;l=chars.length();
  for (int j=0;j<l;j++) {
    mask=(mask*131+j)%l;
    char t=chars[j];
    chars[j]=chars[mask];
    chars[mask]=t;
  }
}

Abigail into(){
  scanf("%d",&q);
  scanf("%s",s+1);
  n=strlen(s+1);
}

Abigail work(){
  Build_sam();
  for (int i=1;i<=n;++i)
    extend(s[i]-'A');
}

Abigail getans(){
  int np,ans;
  while (q--){
  	scanf("%s",s);
  	if (s[0]=='A'){
  	  gets(mask);
  	  l=chars.length();
  	  for (int i=0;i<l;++i)
  	    extend(chars[i]-'A');
    }else{
      np=1;gets(mask);
      l=chars.length();
      for (int i=0;i<l;++i)
	    np=tr[np].s[chars[i]-'A'];
	  printf("%d\n",ans=lct.Query(np));
	  mask^=ans;
	}
  }
}

int main(){
  into();
  work();
  getans();
  return 0;
}