[BZOJ 2555] SubString

Substring

题意

题面

给定一个初始字符串, 要求支持在这个字符串后添加字符串/查询某个字符串作为子串的出现次数.

强制在线.

长度 \(\le600000\)，询问次数 \(\le10000\),询问总长度 \(\le3000000\).

题解

看上去好像可以KMP增量构造的样子

实际上不行 (每次询问都得遍历一遍原串)

考虑用另一个可以支持快速扩展的维护字符串的算法: SAM.

但是SAM增量构造的时候某个状态对应的 right 集合大小(也就是对应子串的出现次数)是 prt 树上的子树和的形式. 而且这个树的形态会产生改变(又是烦人的nq结点搞的事情).

注意到这里求子树和的时候不会换根, 于是我们可以在每次 link 的时候都把当前点对所有祖先的贡献都通过一次链上操作累加上去. 于是就可以比较容易地用LCT维护了.

然而写假了好几次

一开始写假是因为 Decode 出了锅调了很久...因为我一直以为 mask 在 Decode 的时候也会变...

后来写假是因为 link/cut 的时候没有把整个子树的贡献都累加上去 (这数据比较生草...这么大的错误只挂了一个点...)

参考代码

#include <bits/stdc++.h>

const int MAXN=2e6+10;
int size[MAXN];

#define lch chd[0]
#define rch chd[1]
#define kch chd[k]
#define xch chd[k^1]

struct LinkCutTree{
	struct Node{
		int val;
		int add;
		bool rev;
		Node* prt;
		Node* pprt;
		Node* chd[2];
		Node(int x):val(x),add(0),rev(false),prt(NULL),pprt(NULL){
			this->lch=this->rch=NULL;
		}
		void Flip(){
			if(this!=NULL){
				this->rev=!this->rev;
				std::swap(this->lch,this->rch);
			}
		}
		void Add(int x){
			if(this!=NULL){
				this->val+=x;
				this->add+=x;
			}
		}
		void PushDown(){
			if(this->add!=0){
				this->lch->Add(this->add);
				this->rch->Add(this->add);
				this->add=0;
			}
			if(this->rev){
				this->lch->Flip();
				this->rch->Flip();
				this->rev=false;
			}
		}
	};
	std::vector<Node*> N;
	LinkCutTree():N(1){}
	void Rotate(Node* root,int k){
		Node* tmp=root->xch;
		root->PushDown();
		tmp->PushDown();
		tmp->prt=root->prt;
		if(root->prt==NULL){
			tmp->pprt=root->pprt;
			root->pprt=NULL;
		}
		else if(root->prt->lch==root)
			root->prt->lch=tmp;
		else
			root->prt->rch=tmp;
		root->xch=tmp->kch;
		if(root->xch!=NULL)
			root->xch->prt=root;
		tmp->kch=root;
		root->prt=tmp;
	}
	void Splay(Node* root){
		while(root->prt!=NULL){
			int k=root->prt->lch==root;
			if(root->prt->prt==NULL)
				Rotate(root->prt,k);
			else{
				int d=root->prt->prt->lch==root->prt;
				Rotate(k==d?root->prt->prt:root->prt,k);
				Rotate(root->prt,d);
			}
		}
	}
	void Expose(Node* root){
		Splay(root);
		root->PushDown();
		if(root->rch!=NULL){
			root->rch->prt=NULL;
			root->rch->pprt=root;
			root->rch=NULL;
		}
	}
	bool Splice(Node* root){
		Splay(root);
		if(root->pprt==NULL)
			return false;
		Expose(root->pprt);
		root->pprt->rch=root;
		root->prt=root->pprt;
		root->pprt=NULL;
		return true;
	}
	void Access(Node* root){
		Expose(root);
		while(Splice(root));
		assert(root->pprt==0&&root->prt==0);
	}
	void Evert(Node* root){
		Access(root);
		root->Flip();
	}
	void Add(int y,int d){
		Evert(N[1]);
		Access(N[y]);
		N[y]->Add(d);
	}
	void Link(int prt,int son){
		Evert(N[son]);
		N[son]->pprt=N[prt];
		Evert(N[1]);
		Access(N[prt]);
		N[prt]->Add(N[son]->val);
	}
	void Cut(int prt,int son){
		Evert(N[1]);
		Access(N[son]);
		Access(N[prt]);
		N[prt]->Add(-N[son]->val);
		Access(N[son]);
		N[son]->PushDown();
		N[son]->lch->prt=NULL;
		N[son]->lch=NULL;
	}
	int Query(int x){
		Access(N[x]);
		return N[x]->val;
	}
	void MakeTree(int x){
		N.push_back(new Node(x));
	}
}*T=new LinkCutTree();

int q;
int cnt=1;
int root=1;
int last=1;
char s[MAXN];
int prt[MAXN];
int len[MAXN];
std::map<char,int> chd[MAXN];

int Query(char*);
void Extend(char);
void Extend(char*);
void Decode(char*,int);

int main(){
	scanf("%d",&q);
	scanf("%s",s);
	T->MakeTree(0);
	Extend(s);
	int mask=0;
	while(q--){
		scanf("%s",s);
		if(*s=='A'){
			scanf("%s",s);
			Decode(s,mask);
			Extend(s);
		}
		else{
			scanf("%s",s);
			Decode(s,mask);
			int x=Query(s);
			mask^=x;
			printf("%d\n",x);
		}
	}
	return 0;
}

int Query(char* s){
	int cur=root;
	while(*s!='\0'){
		if(!chd[cur].count(*s))
			return 0;
		else
			cur=chd[cur][*s];
		++s;
	}
	return T->Query(cur);
}

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

void Extend(char* s){
	while(*s!='\0')
		Extend(*(s++));
}

void Extend(char x){
	int p=last;
	int np=++cnt;
	T->MakeTree(1);
	size[last=np]=1;
	len[np]=len[p]+1;
	while(p&&!chd[p].count(x))
		chd[p][x]=np,p=prt[p];
	if(p==0)
		prt[np]=root;
	else{
		int q=chd[p][x];
		if(len[q]==len[p]+1)
			prt[np]=q;
		else{
			int nq=++cnt;
			T->MakeTree(0);
			chd[nq]=chd[q];
			prt[nq]=prt[q];
			T->Cut(prt[q],q);
			T->Link(prt[nq],nq);
			prt[q]=nq;
			T->Link(nq,q);
			prt[np]=nq;
			len[nq]=len[p]+1;
			while(p&&chd[p][x]==q)
				chd[p][x]=nq,p=prt[p];
		}
	}
	T->Link(prt[np],np);
}