bzoj 5408 string 题解

最新推荐文章于 2024-07-30 17:43:09 发布

Hypoc_

最新推荐文章于 2024-07-30 17:43:09 发布

阅读量148

点赞数

分类专栏：题解_杂

本文链接：https://blog.csdn.net/a_forever_dream/article/details/106120468

版权

题解_杂专栏收录该内容

304 篇文章 6 订阅

订阅专栏

题目传送门

题目大意： 给出 $n$ 个字符串和一个 $t y p e$ 表示是否强制在线，然后有 $m$ 个操作，操作1：在第 $x$ 个字符串后面添加字符 $y$ ；操作2：询问第 $y$ 次操作后的第 $x$ 的字符串在现在的第 $z$ 个字符串中的出现次数；操作3：询问 $n$ 个串中有多少个不同的子串；操作4：给出一个字符串，询问该字符串在 $n$ 个字符串中出现次数最多的那个中的出现次数。

题解

显然要造一棵广义SAM来维护 $n$ 个串，考虑在 $S A M$ 的每个状态上维护一个数组 $a$ ， $a_i$ 表示这个状态表示的子串在第 $i$ 个字符串中的出现次数，那么操作 $4$ 的话只需要在 $S A M$ 上找到所给的字符串对应的状态，然后求一下 $\max\{a_i|i\in[1,n]\}$ 即可。

而 $a_i$ 也不难求，可以发现，造出后缀链接树后， $a_i$ 的值就是该状态的子树中有多少个状态包含了第 $i$ 个字符串的前缀。

再考虑操作 $1$ ，会发现，每次添加一个节点后，在后缀链接树上，该节点到根节点的路径上的每个点的 $a_x$ 都要 $+ 1$ ，这个可以用 $l c t$ 来维护。

操作 $2$ 的话记录一下一个 $e d$ 数组， $ed_{t,i}$ 表示在第 $t$ 次操作后第 $i$ 个字符串对应 $S A M$ 上的哪个状态，由于 $n$ 只有 $20$ ，所以 $e d$ 和 $a$ 数组都可以维护。

最后操作 $3$ 是最简单的，每次新增一个节点时，它提供的贡献就是 $l e n (i) - l e n (l i n k (i))$ ，累加起来即可。

由于这题要用两个数据结构搞在一起，所以细节不少，码了两个小时多，建议看一下代码（特别是有注释的部分）：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define maxn 800010
#define ll long long

int n,m,type; char s[maxn];
struct node{//lct的节点，其中a的定义如上所述，lazy用来维护a数组，而lazyr用来记录左右儿子是否要交换
	int a[21],lazy[21],lazyr; node *zuo,*you,*fa;
	node():lazyr(0),zuo(NULL),you(NULL),fa(NULL){for(int i=1;i<=20;i++)a[i]=lazy[i]=0;}
	void pushdown()
	{
		for(int i=1;i<=20;i++)if(lazy[i])
		{
			if(zuo!=NULL)zuo->a[i]+=lazy[i],zuo->lazy[i]+=lazy[i];
			if(you!=NULL)you->a[i]+=lazy[i],you->lazy[i]+=lazy[i];
			lazy[i]=0;
		}
		if(lazyr&&zuo!=NULL)swap(zuo->zuo,zuo->you),zuo->lazyr^=1;
		if(lazyr&&you!=NULL)swap(you->zuo,you->you),you->lazyr^=1;
		lazyr=0;
	}
	void pushr(){swap(zuo,you);lazyr^=1;pushdown();}
	bool notroot(){return fa!=NULL&&(fa->zuo==this||fa->you==this);}
};
node *root[maxn];
void rotate(node *x)
{
	node *fa=x->fa,*gfa=fa->fa;
	if(fa->zuo==x)fa->zuo=x->you,(x->you!=NULL&&(x->you->fa=fa)),x->you=fa;
	else fa->you=x->zuo,(x->zuo!=NULL&&(x->zuo->fa=fa)),x->zuo=fa;
	fa->fa=x;x->fa=gfa;
	if(gfa!=NULL&&gfa->zuo==fa)gfa->zuo=x;
	if(gfa!=NULL&&gfa->you==fa)gfa->you=x;
}
node *zhan[maxn];int t=0;
#define witch(x) (x->fa->zuo==x)
void splay(node *x)
{
	node *now=x;zhan[++t]=now;
	while(now->notroot())zhan[++t]=now=now->fa;
	while(t)zhan[t--]->pushdown();
	while(x->notroot())
	if(x->fa->notroot()&&witch(x)==witch(x->fa))
	rotate(x->fa),rotate(x); else rotate(x);
}
struct state{int len,link,next[10];}st[maxn];
int last,id=0,now,p,q,ed[maxn][21];ll ans=0;
void access(node *x){for(node *y=NULL;x!=NULL;y=x,x=x->fa)splay(x),x->you=y;}
void makeroot(node *x){access(x);splay(x);x->pushr();}
void link(node *x,node *y){makeroot(x);x->fa=y;}
void del(node *x,node *y){makeroot(x);access(y);splay(x);x->you=y->fa=NULL;}
//----------------------------以上为lct板子------------------------------------
void change(int x,int belong)
{
	root[x]=new node();
	link(root[x],root[st[x].link]);
	//将自己到根节点路径上的a[belong]+1
	makeroot(root[0]);access(root[x]);splay(root[x]);
	root[x]->a[belong]++;root[x]->lazy[belong]++;root[x]->pushdown();
}
int extend(int x,int belong)
{
	now=++id;
	st[now].len=st[last].len+1;
	for(p=last;p!=-1&&!st[p].next[x];p=st[p].link)st[p].next[x]=now;
	if(p!=-1)
	{
		q=st[p].next[x];
		if(st[p].len+1==st[q].len)st[now].link=q;
		else
		{
			int clone=++id;root[clone]=new node();splay(root[q]);
			for(int i=1;i<=n;i++)root[clone]->a[i]=root[q]->a[i];
			//新建的这个节点要继承q的a数组，注意要先splay(root[q])，保证释放了所有lazy标记
			
			st[clone]=st[q];st[clone].len=st[p].len+1;
			for(;p!=-1&&st[p].next[x]==q;p=st[p].link)st[p].next[x]=clone;
			del(root[q],root[st[q].link]);link(root[clone],root[st[q].link]);
			//由于q的link改变了，所以要断开和link的边，然后连新边
			st[q].link=st[now].link=clone;
			
			link(root[q],root[clone]);
		}
	}
	ans+=st[now].len-st[st[now].link].len;
	change(now,belong); return last=now;
}

int main()
{
	scanf("%d %d",&n,&type);
	st[0].link=-1;root[0]=new node();
	for(int i=1,length;i<=n;i++)
	{
		scanf("%s",s+1);length=strlen(s+1);last=0;
		for(int j=1;j<=length;j++)ed[0][i]=extend(s[j]-'0',i);//实际上记录的就是最后一位
	}
	scanf("%d",&m);int last_ans=0;
	for(int i=1,Type,x,y,z;i<=m;i++)
	{
		scanf("%d",&Type);
		for(int j=1;j<=n;j++)ed[i][j]=ed[i-1][j];
		switch(Type)
		{
			case 1:
				scanf("%d %d",&x,&y);if(type)y=(y^last_ans)%10;
				last=ed[i][x];ed[i][x]=extend(y,x); break;
				//注意这里last要变成ed[i][x]，这样才是在第x个字符串后面添加字符y
			case 2:
				scanf("%d %d %d",&x,&y,&z);
				now=ed[y][x];while(st[now].len==st[st[now].link].len)now=st[now].link;
		//这里坑了我半天：由于是广义SAM，会出现一些节点他们的len和link的len是一样的
		//比如说先插入了字符串123然后再插入另一个字符串1，此时加入的1就会出现这种情况
		//而这样的节点其实比较多余，他们实际上并不能记录对应子串的所有信息，只有最早出现的才能记录
		//所以我们需要跳到最早出现的那个，那个上面才包含了所有信息，然后还要splay一下释放lazy标记
				splay(root[now]);//千万别忘了这一句，不然会WA
				printf("%d\n",last_ans=root[now]->a[z]); break;
			case 3:
				printf("%lld\n",ans); break;
			case 4:
				scanf("%s",s+1);int length=strlen(s+1);
				now=0;int ma=0;
				for(int j=1;j<=length;j++)
				if(st[now].next[s[j]-'0'])now=st[now].next[s[j]-'0'];
				else {ma=-1;break;}
				if(ma==-1){printf("%d\n",last_ans=0);break;}splay(root[now]);
				for(int j=1;j<=n;j++)ma=max(ma,root[now]->a[j]);
				printf("%d\n",last_ans=ma); break;
		}
	}
}