后缀自动机总结

Posted 2022-11-23 thy_asdf

后缀自动机总结

后缀自动机的构造和相关性质及复杂度证明可以看陈老师的ppt

时间复杂度据说可以用均摊分析证明是O(n)的

一开始看直接看陈老师的ppt确实有点难以理解，但是陈老师的ppt确实是讲的最正规的一个

一些定义：right集合：后缀自动机中节点代表的子串的右端点位置构成的集合

　　　　　mins/maxs：节点代表的串的最短长度和最长长度

现在开始进入正题：

spoj1811:后缀自动机入门题，对一个串建自动机，另一个在上面匹配，记录匹配长度最大值即可

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int maxn=500010;
using namespace std;
int n,m,last;char a[maxn],b[maxn];

struct TSam
	int ch[maxn][26],tot,dis[maxn],fa[maxn],root;
	void add(int pos)
		int x=a[pos]-'a',p=last,np=++tot;
		last=np,dis[np]=pos;
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=++tot;
				dis[nq]=dis[p]+1;
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q],fa[np]=fa[q]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
				//printf("nq%d\\n",dis[nq]);
			
		
		//printf("%d\\n",dis[tot]);
	
T;

int main()
	scanf("%s%s",a+1,b+1),last=T.root=++T.tot;
	n=strlen(a+1),m=strlen(b+1);
	for (int i=1;i<=n;i++) T.add(i);
	int ans=0,len=0,p=T.root;
	for (int i=1;i<=m;i++)
		int x=b[i]-'a';
		if (T.ch[p][x]) len++,p=T.ch[p][x];//puts("cas1");
		else
			while (p&&!T.ch[p][x]) p=T.fa[p];
			if (!p) p=T.root,len=0;
			else len=T.dis[p]+1,p=T.ch[p][x];
			//puts("cas2");
		
		ans=max(ans,len);
		//printf("len=%d\\n",len);
	
	printf("%d\\n",ans);
	return 0;

/*
alsdfkjfjkdsal 
fdjskalajfkdsla 
*/

spoj1812&&bzoj2946:对一个串建后缀自动机，其他串在上面匹配，因为是求所有串的公共子串，所以每个点记录每个串最长匹配长度的最小值，最后找到所有点中最长的一个即可

一个注意事项就是，当走到一个点时，还要更新它的parent树上的祖先的匹配长度

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int maxn=500010;
using namespace std;
int n,cnt,sum[maxn],tmp[maxn],ans[maxn],res;char s[maxn];

struct Tsam
	int dis[maxn],ch[maxn][26],fa[maxn],tot,last,root,maxs[maxn];
	void init()last=tot=root=1;
	int newnode(int d)return dis[++tot]=d,tot;
	void add(int pos)
		int x=s[pos]-'a',np=newnode(pos),p=last;
		last=np;
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q];
				fa[q]=fa[np]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
			
		
	
	void build()
		init();
		scanf("%s",s+1),n=strlen(s+1);
		for (int i=1;i<=n;i++) add(i);
		for (int i=1;i<=tot;i++) ans[i]=dis[i];
	
	void Tsort()
		for (int i=1;i<=tot;i++) sum[dis[i]]++;//printf("%d\\n",dis[i]);
		for (int i=1;i<=n;i++) sum[i]+=sum[i-1];
		for (int i=1;i<=tot;i++) tmp[sum[dis[i]]--]=i;
		//for (int i=1;i<=tot;i++) printf("%d %d\\n",tmp[i],dis[tmp[i]]);
	
	void work()
		memset(maxs,0,sizeof(maxs));
		int len=0,p=root;
		for (int i=1;i<=n;i++)
			int x=s[i]-'a';
			if (ch[p][x]) len++,p=ch[p][x];
			else
				for (;p&&!ch[p][x];p=fa[p]);
				if (!p) p=root,len=0;
				else len=dis[p]+1,p=ch[p][x];
			
			maxs[p]=max(maxs[p],len);
		
		
		for (int i=tot;i;i--)
			int x=tmp[i];
			ans[x]=min(ans[x],maxs[x]);
			if (maxs[x]&&fa[x]) maxs[fa[x]]=dis[fa[x]];
			//printf("x=%d ans=%d\\n",x,ans[x]);
			//要记得更新祖先，因为我们可能到这个点而没有经过祖先，如果这个点可以到达，那么祖先一定是可以到dis[fa[x]]的
			//类似AC自动机里的fail树,我们能到fail树的儿子所代表的串，就一定能走到fail树祖先所代表的串
			//这里的pre指针构成的树也是类似
			//fa[x]所带表的一些串的right集合比x的大，且包含right[x],maxs[fa[x]]也比x要短
			//所以fa[x]的串其实是x的串的子串，x能到,fa[x]当然也能到
		
	
T;

int main()
	/*//freopen("test.in","r",stdin);
	T.build(),T.Tsort();
	while (scanf("%s",s+1)!=EOF) n=strlen(s+1),T.work();*/
	scanf("%d",&cnt);
	T.build(),T.Tsort();
	for (int i=1;i<cnt;i++) scanf("%s",s+1),n=strlen(s+1),T.work();
	for (int i=1;i<=T.tot;i++) res=max(res,ans[i]);
	printf("%d\\n",res);
	return 0;

spoj8222:构建字符串的自动机，对于每个节点，right集合大小就是出现次数，maxs就是它代表的最长长度，那么我们用|right(x)|去更新f[maxs[x]]的值，最后从大到小用f[i]去更新f[i-1]的值即可

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int maxn=500010;
using namespace std;
int n,f[maxn],sum[maxn],tmp[maxn];char s[maxn];

struct Tsam
	int dis[maxn],ch[maxn][26],fa[maxn],r[maxn],tot,last,root;
	void init()last=tot=root=1;
	int newnode(int d)return dis[++tot]=d,tot;
	void add(int pos)
		int x=s[pos]-'a',p=last,np=newnode(pos);
		last=np;
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q],fa[np]=fa[q]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
			
		
	
	void work()
		init();
		for (int i=1;i<=n;i++) add(i);
		for (int i=1,p=root;i<=n;i++)
			p=ch[p][s[i]-'a'],r[p]=1;
		for (int i=1;i<=tot;i++) sum[dis[i]]++;
		for (int i=1;i<=n;i++) sum[i]+=sum[i-1];
		for (int i=1;i<=tot;i++) tmp[sum[dis[i]]--]=i;
		for (int i=tot;i;i--) r[fa[tmp[i]]]+=r[tmp[i]];
		for (int i=1;i<=tot;i++) f[dis[i]]=max(f[dis[i]],r[i]);
		for (int i=n;i;i--) f[i]=max(f[i],f[i+1]);
		for (int i=1;i<=n;i++) printf("%d\\n",f[i]);
	
T;

int main()
	scanf("%s",s+1),n=strlen(s+1);
	T.work();
	return 0;

bzoj2882:用后缀自动机实现最小表示法。把串复制一遍，构建后缀自动机，每次选择最小的边转移即可

因为字符集很大，所以转移边用map来存即可

#include<map>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define it map<int,int>::iterator
const int maxn=1200010;
using namespace std;
int n,s[maxn];

void read(int &x)
	char ch;
	for (ch=getchar();!isdigit(ch);ch=getchar());
	for (x=0;isdigit(ch);ch=getchar()) x=x*10+ch-'0';


struct Tsam
	map<int,int> ch[maxn];
	int dis[maxn],fa[maxn],root,last,tot;
	int newnode(int v)dis[++tot]=v;return tot;
	void init()last=root=++tot;
	void add(int x)
		int p=last,np=newnode(dis[p]+1);
		last=np;
		for (;p&&!ch[p].count(x);p=fa[p]) ch[p][x]=np;//printf("char=%d %d\\n",x,p);
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=newnode(dis[p]+1);
				ch[nq]=ch[q];
				fa[nq]=fa[q];
				fa[np]=fa[q]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;//printf("qp: char=%d %d %d\\n",x,p,fa[p]);
			
		
	
	void build()
		init();
		for (int i=1;i<=n;i++) add(s[i]);
		for (int i=1;i<=n;i++) add(s[i]);
	
	void getmin()
		for (int i=1;i<=tot;i++)
			it iter=ch[i].begin();
			//printf("id=%d char=%d minson=%d\\n",i,iter->first,iter->second);
		
		for (int i=1,p=root;i<=n;i++)
			it iter=ch[p].begin();
			printf(i==n?"%d\\n":"%d ",iter->first);
			p=iter->second;
			//printf("p=%d %d\\n",p,ch[p].begin()->second);
		
	
T;

int main()
	//freopen("test.out","w",stdout);
	scanf("%d",&n);
	for (int i=1;i<=n;i++) read(s[i]);
	T.build(),T.getmin();
	return 0;

bzoj3998:

对于T=0的情况，right集合不管多大它也只算出现一次

对于T=1的情况，我们一遍DP需要求出每个点的right集合大小

然后扫一遍求出每个点下面还有多少个串

然后在自动机上走一走即可

另外直接按每个点代表的最长长度排序就可以得到拓扑序了

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int maxn=1000010;
using namespace std;
int n,K,op;char s[maxn];

struct Tsam
	int dis[maxn],ri[maxn],ch[maxn][26],fa[maxn],sum[maxn],last,tot,root;
	int tmp[maxn],su[maxn];
	void init()last=root=tot=1;
	int newnode(int v)dis[++tot]=v;return tot;
	void add(int x)
		int p=last,np=newnode(dis[p]+1);
		ri[np]=1,last=np;
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q];
				fa[q]=fa[np]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
			
		
	
	void prework()
		init();
		for (int i=1;i<=n;i++) add(s[i]-'a');
		for (int i=1;i<=tot;i++) su[dis[i]]++;
		for (int i=1;i<=n;i++) su[i]+=su[i-1];
		for (int i=tot;i;i--) tmp[su[dis[i]]--]=i;
		//for (int i=1;i<=tot;i++) printf("%d ",tmp[i]);puts("");
		for (int i=tot;i;i--)
			int p=tmp[i];
			//printf("%d ",tmp[i]);
			if (op==1) ri[fa[p]]+=ri[p];
			else ri[p]=1;
		//puts("");
		ri[root]=0;
		for (int i=tot;i;i--)
			int p=tmp[i];
			//printf("%d ",tmp[i]);
			sum[p]=ri[p];
			for (int x=0;x<26;x++)
				int son=ch[p][x];
				if (son) sum[p]+=sum[son];//printf("p=%d son=%d sum=%d\\n",p,son,sum[p]);
			
			//printf("p=%d sum=%d\\n",p,sum[p]);
		
		//puts("");
	
	void dfs(int x,int rk)
		//printf("%d %d\\n",x,rk);
		if (rk<=ri[x]) return;
		rk-=ri[x];
		for (int i=0;i<26;i++)
			int son=ch[x][i];
			if (son)
				if (rk<=sum[son])
					putchar(i+'a');
					dfs(son,rk);
					return;
				
				rk-=sum[son];
			
		
	
	void work()
		if (K>sum[root])puts("-1");return;
		dfs(root,K);puts("");
	
T;

int main()
	scanf("%s%d%d",s+1,&op,&K);
	n=strlen(s+1),T.prework();
	T.work();
	return 0;

poj1743:先考虑求一个出现次数>=2的最长子串
出现次数>=2那就只管|right(x)|>=2的点

然后对这些点的代表的子串长度取max即可

加上了不相交的限制，类似后缀数组的做法

我们就记录right集合的最大／最小值，他们的差值就是能不相交的最长长度

拿它和该点的maxs取min即可，然后对所有点的答案取max即可

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int maxn=40010;
using namespace std;
int n,a[maxn],tmp[maxn];
bool cmp(int a,int b);

struct Tsam
	int fa[maxn],dis[maxn],l[maxn],r[maxn],ch[maxn][180],last,tot,root;
	void init()
		last=root=tot=1;
		memset(dis,0,sizeof(dis));
		memset(l,63,sizeof(l));
		memset(r,0,sizeof(r));
		memset(fa,0,sizeof(fa));
		memset(ch,0,sizeof(ch));
	
	int newnode(int v)dis[++tot]=v;return tot;
	void add(int x)
		int p=last,np=newnode(dis[p]+1);
		last=np,l[np]=r[np]=dis[np];
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q];
				fa[np]=fa[q]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
			
		
	
	void work()
		int ans=0;
		for (int i=1;i<=tot;i++) tmp[i]=i;
		sort(tmp+1,tmp+1+tot,cmp);
		for (int i=1;i<=tot;i++)
			l[fa[tmp[i]]]=min(l[fa[tmp[i]]],l[tmp[i]]);
			r[fa[tmp[i]]]=max(r[fa[tmp[i]]],r[tmp[i]]);
		
		for (int i=1;i<=tot;i++)
			ans=max(ans,min(dis[i],r[i]-l[i]));
		printf("%d\\n",ans<4?0:ans+1);
	
T;

bool cmp(int a,int b)return T.dis[a]>T.dis[b];

int main()
	for (scanf("%d",&n);n;scanf("%d",&n))
		for (int i=1;i<=n;i++) scanf("%d",&a[i]);
		for (int i=1;i<n;i++) a[i]=a[i+1]-a[i]+88;
		T.init(),n--;
		for (int i=1;i<=n;i++) T.add(a[i]);
		T.work();
	
	return 0;

bzoj4566

对一个串A建自动机

另一个串B在上面匹配

考虑怎么统计答案

对于当前匹配到的点，那么它parent树中的祖先代表的串现在肯定也出现了

对于每个出现的点，它代表了maxs[x]-mins[x]+1个串（mins[x]=maxs[fa[x]]+1）

这些串出现了|right(x)|次，贡献就是|right(x)|*(maxs[x]-maxs[fa[x]])

因为要统计祖先的，所以把祖先的也累加到这个节点即可

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int maxn=400010;
typedef long long ll;
using namespace std;
int n1,n2;char s1[maxn],s2[maxn];

struct Tsam
	int dis[maxn],fa[maxn],ri[maxn],ch[maxn][26],last,tot,root;
	int tmp[maxn],v[maxn];
	ll sum[maxn];
	void init()last=root=tot=1;
	int newnode(int v)dis[++tot]=v;return tot;
	void add(int x)
		int p=last,np=newnode(dis[p]+1);
		ri[np]=1,last=np;
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q];
				fa[q]=fa[np]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
			
		
		//printf("tot=%d\\n",tot);
	
	void prework()
		init();
		for (int i=1;i<=n1;i++) add(s1[i]-'a');
	
	void Tsort()
		for (int i=1;i<=tot;i++) v[dis[i]]++;
		for (int i=1;i<=n1;i++) v[i]+=v[i-1];
		for (int i=tot;i;i--) tmp[v[dis[i]]--]=i;
	
	void DP()
		Tsort();
		for (int i=tot;i;i--)
			ri[fa[tmp[i]]]+=ri[tmp[i]];
		//for (int i=1;i<=tot;i++) printf("fa=%d ri=%d\\n",fa[i],ri[i]);
		for (int i=1;i<=tot;i++)
			int x=tmp[i];
			sum[x]=sum[fa[x]]+1ll*ri[x]*(dis[x]-dis[fa[x]]);//printf("sum=%lld\\n",sum[x]);
		
	
	void work()
		ll ans=0,len=0;
		for (int i=1,p=root;i<=n2;i++)
			int x=s2[i]-'a';
			if (ch[p][x]) p=ch[p][x],len++;
			else
				for (;p&&!ch[p][x];p=fa[p]);
				if (!p) p=root,len=0;
				else len=dis[p]+1,p=ch[p][x];
			
			if (p!=root) ans=ans+sum[fa[p]]+1ll*ri[p]*(len-dis[fa[p]]);
			//printf("p=%d\\n",p);
		
		printf("%lld\\n",ans);
	
T;

int main()
	scanf("%s%s",s1+1,s2+1);
	n1=strlen(s1+1),n2=strlen(s2+1);
	T.prework(),T.DP(),T.work();
	return 0;

/*
asaaasaasasasasasasaasaaaasasas
asasasaaasassssasasasasasasas 
1285
*/

bzoj3238:

反串的parent树是原串的后缀树
然后lcp就是他们的lca的深度，然后树形DP一下就好了

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
typedef long long ll;
const int maxn=1000010;
using namespace std;
int n;char s[maxn];ll ans;

struct Tsam
	int dis[maxn],fa[maxn],ch[maxn][26],ri[maxn],sum[maxn],last,root,tot;
	int su[maxn],tmp[maxn];
	void init()last=root=tot=1;
	int newnode(int v)dis[++tot]=v;return tot;
	void add(int x)
		int p=last,np=newnode(dis[p]+1);
		ri[np]=sum[np]=1,last=np;
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q];
				fa[q]=fa[np]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
			
		
	
	void Tsort()
		for (int i=1;i<=tot;i++) su[dis[i]]++;
		for (int i=1;i<=n;i++) su[i]+=su[i-1];
		for (int i=tot;i;i--) tmp[su[dis[i]]--]=i;
	
	void treeDP()
		Tsort();
		for (int i=tot;i;i--)
			int x=tmp[i];
			ri[fa[x]]+=ri[x];
		
		for (int i=tot;i;i--)
			int x=tmp[i];
			ans+=1ll*sum[fa[x]]*ri[x]*dis[fa[x]];
			sum[fa[x]]+=ri[x];
		
	
T;

int main()
	scanf("%s",s+1),n=strlen(s+1),T.init();
	for (int i=n;i;i--) T.add(s[i]-'a');
	T.treeDP();
	printf("%lld\\n",1ll*(n+1)*n/2*(n-1)-ans*2);
	return 0;

bzoj2806:

显然答案L具有可二分性

先在后缀自动机上匹配

求出mat[i]表示以待检查的作文的每个位置i为结尾最长能匹配多长

设f[i]表示前i个字符熟悉的部分最多有多长

那么f[i]=max(f[i-1],f[j]+i-j)

其中j要满足i-j>=L&&i-j+1<=mat[i]

整理得i-mat[i]<=j<=i-L

因为mat[i]+1<=mat[i+1]

所以i+1-mat[i+1]>=i+1-(mat[i]+1)=i-mat[i]

所以i-mat[i]单调不减，于是就可以用单调队列优化了

#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int maxn=1200010*2,inf=0x3f3f3f3f;
using namespace std;
int n,n1,n2,f[maxn],mat[maxn];char s[maxn];

struct Tsam
	int dis[maxn],ch[maxn][3],fa[maxn],last,root,tot;
	void init()last=root=tot=1;
	int newnode(int v)dis[++tot]=v;return tot;
	void add(int x)
		int p=last,np=newnode(dis[p]+1);
		last=np;
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q];
				fa[q]=fa[np]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
			
		
	
	void match()
		mat[0]=0;
		for (int i=1,p=root;i<=n;i++)
			int x=s[i]-'0';
			if (ch[p][x]) mat[i]=mat[i-1]+1,p=ch[p][x];
			else
				for (;p&&!ch[p][x];p=fa[p]);
				if (!p) p=root,f[i]=0;
				else mat[i]=dis[p]+1,p=ch[p][x];
			
		
		//for (int i=1;i<=n;i++) printf("%d ",mat[i]);
	
T;

struct Tque
	int v[maxn],p[maxn],head,tail;
	void init()head=1,tail=0;
	void push(int val,int pos)
		while (head<=tail&&val>v[tail]) tail--;
		v[++tail]=val,p[tail]=pos;
	
	void pop(int lim)
		while (head<=tail&&p[head]<lim) head++;
	
	int top()return v[head];
q;

bool check(int lim)
	//printf("lim=%d\\n",lim);
	memset(f,0,sizeof(int)*(n+5));
	q.init();
	for (int i=1;i<=n;i++)
		f[i]=f[i-1];
		if (i-lim>=0) q.push(f[i-lim]-(i-lim),i-lim);
		q.pop(i-mat[i]);
		//printf("left=%d right=%d\\n",i-mat[i],i-lim);
		if (q.head<=q.tail) f[i]=max(f[i],q.top()+i);//printf("%d %d\\n",i,q.top());
	
	//for (int i=1;i<=n;i++) printf("%d ",f[i]);puts("");
	//for (int i=1;i<=n;i++) printf("%d ",mat[i]);puts("");
	return f[n]>=n*0.9-1e-8;


void work()
	T.match();
	//check(5);for (;;);
	int l=1,r=n,mid=(l+r)>>1,ans=0;
	while (l<=r)
		if (check(mid)) l=mid+1,ans=mid;
		else r=mid-1;
		mid=(l+r)>>1;
	
	printf("%d\\n",ans);


int main()
	scanf("%d%d",&n1,&n2);T.init();
	for (int i=1;i<=n2;i++)
		scanf("%s",s+1),n=strlen(s+1);
		for (int j=1;j<=n;j++) T.add(s[j]-'0');
		T.add(2);
	
	for (int i=1;i<=n1;i++)
		scanf("%s",s+1),n=strlen(s+1);
		work();
	
	return 0;

bzoj2555:

一个点right集合就是它子树中所有点的right的并集

所以动态构建后缀自动机时，增加一个点，就把它的祖先的right集合都＋１

因为parent树的形态会改变，所以用暴力动态树维护一下

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int maxn=1200010;
using namespace std;
int Q,n,mask,lastans=0;char s[maxn],op[maxn],ch[maxn];
void decode(int mask)
	memcpy(s,ch,sizeof(char)*(n+5));
	for (int j=0;j<n;j++)
		mask=(mask*131+j)%n;
		char t=s[j];
		s[j]=s[mask];
		s[mask]=t;
	


struct Tlct
	#define ls ch[x][0]
	#define rs ch[x][1]
	int val[maxn],ch[maxn][2],fa[maxn],add[maxn];
	inline int which(int x)return ch[fa[x]][1]==x;
	inline int isroot(int x)return ch[fa[x]][0]!=x&&ch[fa[x]][1]!=x;
	inline void add_tag(int x,int v)add[x]+=v,val[x]+=v;
	inline void down(int x)
		if (add[x]!=0)
			if (ls) add_tag(ls,add[x]);
			if (rs) add_tag(rs,add[x]);
			add[x]=0;
		
	
	void relax(int x)if (!isroot(x)) relax(fa[x]);down(x);
	void rotate(int x)
		int y=fa[x],z=fa[y],nx=which(x),ny=which(y),isrt=isroot(y);
		fa[ch[x][!nx]]=y,ch[y][nx]=ch[x][!nx];
		fa[x]=z;if (!isrt) ch[z][ny]=x;
		fa[y]=x,ch[x][!nx]=y;
	
	void splay(int x)
		relax(x);
		while (!isroot(x))
			int y=fa[x];
			if (isroot(y)) rotate(x);
			else if (which(x)==which(y)) rotate(y),rotate(x);
			else rotate(x),rotate(x);
		
	
	void access(int x)
		for (int p=0;x;x=fa[x])
			splay(x),rs=p,p=x;
	
	void link(int x,int f)
		fa[x]=f,access(f),splay(f),add_tag(f,val[x]);
	
	void cut(int x)
		access(x),splay(x),add_tag(ls,-val[x]);
		fa[ls]=0,ls=0;
	
	#undef ls
	#undef rs
T;

struct Tsam
	int fa[maxn],ch[maxn][26],dis[maxn],last,root,tot;
	int newnode(int v)return dis[++tot]=v,tot;
	void link(int p,int f)fa[p]=f,T.link(p,f);
	void add(int x)
		int p=last,np=newnode(dis[p]+1);
		T.val[np]=1,last=np;
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) link(np,root);
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) link(np,q);
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				link(nq,fa[q]),T.cut(q);
				link(q,nq),link(np,nq);
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
				
		
		
	
	void init()
		last=root=tot=1;
		scanf("%s",s),n=strlen(s);
		for (int i=0;i<n;i++) add(s[i]-'A');
	
	void insert()for (int i=0;i<n;i++) add(s[i]-'A');
	int query()
		int p=root;
		for (int i=0;i<n;i++)
			int x=s[i]-'A';
			if (!ch[p][x]) return lastans=0;
			p=ch[p][x];
		
		T.splay(p);lastans=T.val[p];
		return lastans;
	
sam;

int main()
	scanf("%d",&Q),sam.init();
	while (Q--)
		scanf("%s%s",op,ch);
		n=strlen(ch),decode(mask);
		if (op[0]=='A') sam.insert();
		else printf("%d\\n",sam.query()),mask=mask^lastans;
	
	return 0;

bzoj3926:

叶子数很少，所以我们可以枚举哪个叶子为根，这样就有了20个trie，对这20个trie建广义后缀自动机

然后统计有多少个不同的子串即可,不同子串个数就是Σ(dis[x]-dis[fa[x]])

<span style="font-size:14px;">#include<cstdio>
#include<cstring>
#include<cassert>
#include<iostream>
#include<algorithm>
const int maxn=100010,maxm=200010,maxt=2000010;
using namespace std;
int n,C,col[maxn],pre[maxm],now[maxm],son[maxm],deg[maxn],tot,last;
void add(int a,int b)pre[++tot]=now[a],now[a]=tot,son[tot]=b,deg[b]++;

void read(int &x)
	char ch;
	for (ch=getchar();!isdigit(ch);ch=getchar());
	for (x=0;isdigit(ch);ch=getchar()) x=x*10+ch-'0';


struct Tsam
	int ch[maxt][11],fa[maxt],dis[maxt],root,tot;
	void init()root=tot=1;
	int newnode(int v)return dis[++tot]=v,tot;
	void add(int x)
		int p=last,q=ch[p][x];
		if (q)
			if (dis[q]==dis[p]+1) last=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q];
				fa[q]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
				last=nq;
			
		
		else
			int np=newnode(dis[p]+1);
			for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
			if (!p) fa[np]=root;
			else
				int q=ch[p][x];
				if (dis[q]==dis[p]+1) fa[np]=q;
				else
					int nq=newnode(dis[p]+1);
					memcpy(ch[nq],ch[q],sizeof(ch[q]));
					fa[nq]=fa[q];
					fa[np]=fa[q]=nq;
					for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
				
			
			last=np;
		
	
	void work()
		long long ans=0;
		for (int i=1;i<=tot;i++)
			ans+=dis[i]-dis[fa[i]];
		printf("%lld\\n",ans);
	
T;

void dfs(int x,int f,int p)
	T.add(col[x]);
	int t=last;
	for (int y=now[x];y;y=pre[y])
		if (son[y]!=f)
			dfs(son[y],x,last),last=t;


int main()
	scanf("%d%d",&n,&C),T.init();
	for (int i=1;i<=n;i++) read(col[i]);
	for (int i=1,x,y;i<n;i++) read(x),read(y),add(x,y),add(y,x);
	for (int i=1;i<=n;i++) if (deg[i]==1) dfs(i,0,last=T.root);
	T.work();
	return 0;
</span>

bzoj3879

对要询问的点建出虚树，然后就和AHOI差异那题基本一样了

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
typedef long long ll;
const int maxn=500010*2,maxm=maxn*2;
using namespace std;
int n,m,a[maxn],stk[maxn],top,id[maxn],dfn[maxn],dep[maxn],tim,pw[25];
ll ans;char s[maxn];bool bo[maxn];
bool cmp(int a,int b)return dfn[a]<dfn[b];

void read(int &x)
	char ch;
	for (ch=getchar();!isdigit(ch);ch=getchar());
	for (x=0;isdigit(ch);ch=getchar()) x=x*10+ch-'0';


struct Tgra
	int pre[maxm],now[maxn],son[maxm],tot,fa[maxn][22];
	void add(int a,int b)pre[++tot]=now[a],now[a]=tot,son[tot]=b;//printf("%d %d\\n",a,b);
	void dfs(int x)
		dfn[x]=++tim;
		for (int i=1;i<=20;i++) fa[x][i]=fa[fa[x][i-1]][i-1];
		for (int y=now[x];y;y=pre[y])
			dep[son[y]]=dep[x]+1,fa[son[y]][0]=x,dfs(son[y]);
	
	int lca(int x,int y)
		if (dep[x]<dep[y]) swap(x,y);
		for (int h=dep[x]-dep[y],i=20;h;i--) if (h&pw[i]) h-=pw[i],x=fa[x][i];
		if (x==y) return x;
		for (int i=20;i>=0;i--)
			if (fa[x][i]!=fa[y][i])
				x=fa[x][i],y=fa[y][i];
		return fa[x][0];
	
ori;

struct Tsam
	int ch[maxn][26],fa[maxn],dis[maxn],cnt,last,root,tot;
	void init()last=root=tot=1;
	int newnode(int v)return dis[++tot]=v,tot;
	int add(int x)
		int p=last,np=newnode(dis[p]+1);
		last=np;
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q];
				fa[q]=fa[np]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
			
		
		return np;
	
T;

struct Tgraph
	int pre[maxm],now[maxn],son[maxm],tot,sum[maxn];
	void add(int a,int b)pre[++tot]=now[a],now[a]=tot,son[tot]=b;//printf("connect: %d %d\\n",a,b);
	void dfs(int x)
		//printf("x=%d\\n",x);
		sum[x]=bo[x];
		for (int y=now[x];y;y=pre[y])
			dfs(son[y]);
			ans+=1ll*sum[son[y]]*sum[x]*T.dis[x];
			sum[x]+=sum[son[y]];
		
		now[x]=0;
	
g;

void init()
	pw[0]=1;for (int i=1;i<=20;i++) pw[i]=pw[i-1]<<1;
	scanf("%d%d%s",&n,&m,s+1),T.init();
	//puts("%p");
	for (int i=n;i;i--) id[i]=T.add(s[i]-'a');
	for (int i=1;i<=T.tot;i++) ori.add(T.fa[i],i);
	ori.dfs(1);
	/*int qqq;
	scanf("%d",&qqq);
	for (int i=1,x,y;i<=qqq;i++) scanf("%d%d",&x,&y),printf("%d\\n",ori.lca(x,y));*/
	//for (int i=1;i<=n;i++) printf("i=%d id=%d\\n",i,id[i]);


void work()
	//puts("%p");
	int cnt;read(cnt);
	for (int i=1;i<=cnt;i++) read(a[i]),a[i]=id[a[i]];
	sort(a+1,a+1+cnt,cmp),cnt=unique(a+1,a+1+cnt)-a-1;
	//for (int i=1;i<=cnt;i++) printf("keypoint: %d\\n",a[i]);
	for (int i=1;i<=cnt;i++) bo[a[i]]=1;
	
	for (int i=1;i<=cnt;i++)
		if (!top)stk[++top]=a[i];continue;
		int u=ori.lca(a[i],stk[top]);
		while (top&&dep[u]<dep[stk[top]])
			if (dep[u]>=dep[stk[top-1]])
				g.add(u,stk[top]);
				if (stk[--top]!=u) stk[++top]=u;
				break;
			
			--top,g.add(stk[top],stk[top+1]);
		
		stk[++top]=a[i];
	
	while (--top) g.add(stk[top],stk[top+1]);
	
	ans=0,g.dfs(stk[1]),printf("%lld\\n",ans);
	for (int i=1;i<=n;i++) bo[a[i]]=0;g.tot=0;


int main()
	init();
	for (int i=1;i<=m;i++) work();
	return 0;

bzoj2780

先建出广义后缀自动机，建的时候对每个节点染色，表示它是属于哪个串

然后对每个询问串在自动机上匹配，匹配到的点即其parent树子树中的节点就可以包含这个串

于是问题就转化为给定一个颜色序列，每次询问一段区间内的颜色个数

这个就是bzoj1878HH的项链

离线，把询问按右端点排序，从左往右做，每次在树状数组中给当前位置＋１，当前位置颜色的上一次出现位置－１，然后处理右端点在此的询问即可

本题一个点可能有多种颜色，所以挂个链表就好了

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int maxn=200010,maxm=200010;
using namespace std;
int n1,n,Q,dfn[maxn],last[maxn],tim,seq[maxn],p[maxn],ans[maxn];char s[360010];
struct queint l,r,id;q[maxn];
bool cmp(que a,que b)return a.r<b.r;

struct Tgraph
	int pre[maxm],now[maxn],son[maxm],tot;
	void add(int a,int b)pre[++tot]=now[a],now[a]=tot,son[tot]=b;//,printf("a=%d b=%d\\n",a,b)
	void dfs(int x)
		dfn[x]=++tim,seq[tim]=x;
		for (int y=now[x];y;y=pre[y]) dfs(son[y]);
		last[x]=tim;
	
g,chain;

struct Tsam
	int ch[maxn][26],fa[maxn],dis[maxn],last,root,tot;
	void init()last=root=tot=1;
	int newnode(int v)return dis[++tot]=v,tot;
	void add(int x,int id)
		int p=last,q=ch[p][x];
		if (q)
			if (dis[q]==dis[p]+1) last=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q];
				fa[q]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
				last=nq;
			
		
		else
			int np=newnode(dis[p]+1);
			for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
			if (!p) fa[np]=root;
			else
				int q=ch[p][x];
				if (dis[q]==dis[p]+1) fa[np]=q;
				else
					int nq=newnode(dis[p]+1);
					memcpy(ch[nq],ch[q],sizeof(ch[q]));
					fa[nq]=fa[q];
					fa[q]=fa[np]=nq;
					for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
				
			
			last=np;
		
		//printf("chain: ");
		chain.add(last,id);
		//printf("%d\\n",tot);
		
T;

struct BIT
	int val[maxn];
	void add(int x,int v)
		if (!x) return;
		for (;x<=T.tot;x+=x&(-x)) val[x]+=v;
	
	int query(int x)
		int res=0;
		for (;x;x-=x&(-x)) res+=val[x];
		return res;
	
	int query(int l,int r)
		//int tmp=query(r)-query(l-1);
		//printf("tmp=%d\\n",tmp);
		return query(r)-query(l-1);
	
bit;

void match(int id)
	//printf("id=%d\\n",id);
	int p=T.root;
	for (int i=1;i<=n;i++)
		int x=s[i]-'a';//printf("x=%d p=%d\\n",x,p);
		if (T.ch[p][x]) p=T.ch[p][x];
		elsep=0;break;
	
	//printf("p=%d dfn=%d last=%d\\n",p,dfn[p],last[p]);
	q[id]=(que)dfn[p],last[p],id;


int main()
	scanf("%d%d",&n1,&Q),T.init();
	for (int i=1;i<=n1;i++)
		scanf("%s",s+1),n=strlen(s+1),T.last=1;
		for (int j=1;j<=n;j++) T.add(s[j]-'a',i);
	
	for (int i=1;i<=T.tot;i++)/* printf("g: "),*/g.add(T.fa[i],i);
	g.dfs(1);
	//for (int i=1;i<=T.tot;i++) printf("id=%d dfn=%d\\n",i,dfn[i]);
	for (int i=1;i<=Q;i++)
		scanf("%s",s+1),n=strlen(s+1),match(i);
	sort(q+1,q+1+Q,cmp);
	int st;
	for (st=1;st<=Q&&!q[st].l;st++);
	//printf("st=%d\\n",st);
	for (int j=1;j<=T.tot;j++)
		int x=seq[j];
		//printf("id=%d x=%d\\n",j,x);
		for (int y=chain.now[x];y;y=chain.pre[y])
			int col=chain.son[y];
			bit.add(j,1);
			//printf("pre=%d col=%d\\n",p[col],col);
			if (p[col]) bit.add(p[col],-1);
			p[col]=j;
		
		for (;q[st].r==j;st++)
			ans[q[st].id]=bit.query(q[st].l,q[st].r);
			//printf("ans=%d %d %d\\n",ans[q[st].id],q[st].l,q[st].r);
		
	
	for (int i=1;i<=Q;i++) printf("%d\\n",ans[i]);
	return 0;

bzoj3756:

可以得到的串就是这个trie所表示的所有串的所有子串

把这个trie建广义后缀自动机，然后就类似bzoj4566的做法，在parent树上求出一些值，然后匹配一遍，求出答案就好了

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
typedef long long ll;
const int maxn=1600010,maxm=maxn;
using namespace std;
int n;char s[8000010];ll ans;

struct Tsam
	int ch[maxn][4],fa[maxn],dis[maxn],tot,last,root,v[maxn],tmp[maxn],ri[maxn];
	ll sum[maxn];
	void init()last=root=tot=1;
	int newnode(int v)return dis[++tot]=v,tot;
	void add(int x)
		int p=last,np=newnode(dis[p]+1);
		ri[np]=sum[np]=1,last=np;
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q];
				fa[q]=fa[np]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
			
		
	
	void Tsort()
		for (int i=1;i<=tot;i++) v[dis[i]]++;
		for (int i=1;i<=tot;i++) v[i]+=v[i-1];
		for (int i=tot;i;i--) tmp[v[dis[i]]--]=i;
	
	void work()
		Tsort();
		for (int i=tot;i;i--)
			int x=tmp[i];
			if (fa[x]) ri[fa[x]]+=ri[x];
		
		for (int i=1;i<=tot;i++)
			int x=tmp[i];
			sum[x]=sum[fa[x]]+1ll*ri[x]*(dis[x]-dis[fa[x]]);
		
	
	void match()
		ans=0;int len=0;
		for (int p=root,i=1;i<=n;i++)
			int x=s[i]-'a';
			if (ch[p][x]) len++,p=ch[p][x];
			else
				for (;p&&!ch[p][x];p=fa[p]);
				if (!p) p=root,len=0;
				else len=dis[p]+1,p=ch[p][x];
			
			if (fa[p]) ans+=1ll*(len-dis[fa[p]])*ri[p]+sum[fa[p]];
		
		printf("%lld\\n",ans);
	
T;

struct Tgraph
	int pre[maxm],now[maxn],son[maxm],tot,val[maxn],last[maxn],q[maxn+10],head,tail;
	void add(int a,int b,int c)pre[++tot]=now[a],now[a]=tot,son[tot]=b,val[tot]=c;
	void bfs()
		q[tail=1]=1,head=0,last[1]=T.root;
		while (head!=tail)
			int x=q[++head];
			for (int y=now[x];y;y=pre[y])
				q[++tail]=son[y],T.last=last[x];
				T.add(val[y]),last[son[y]]=T.last;
			
		
	
g;

int main()
	//freopen("test.in","r",stdin);freopen("test.out","w",stdout);
	scanf("%d",&n),T.init();
	for (int i=2,x;i<=n;i++)
		scanf("%d%s",&x,s+1),g.add(x,i,s[1]-'a');
	g.bfs(),scanf("%s",s+1),T.work();
	n=strlen(s+1),T.match();
	return 0;

bzoj1396&&2865

首先只有|right(x)|=1的点才可以更新答案，设[l,r]是该点的最短的识别子串,l=maxs[x]-maxs[fa[x]],r=maxs[x]

然后我们可以发现它可以更新的区间有两段，[1,l-1]段可以用r-i+1来更新它的答案，因为我们要经过i这个位置

[l,r]段我们可以用r-l+1更新

于是我们可以开两个线段树来表示应用这两种区间覆盖，最后取min即可

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int maxn=1000010,maxt=maxn<<1,inf=1e9+7,pp=200000;
using namespace std;
int n;char s[maxn];

struct Tsegment
	#define ls (p<<1)
	#define rs (p<<1|1)
	#define mid ((l+r)>>1)
	int mins[maxt],cov[maxt];
	void update(int p)mins[p]=min(mins[ls],mins[rs]);
	void cover(int p,int v)mins[p]=min(mins[p],v),cov[p]=min(cov[p],v);
	void down(int p)
		if (cov[p]!=inf)
			cover(ls,cov[p]),cover(rs,cov[p]),cov[p]=inf;
	
	void build(int p,int l,int r)
		cov[p]=mins[p]=inf;
		if (l==r) return;
		build(ls,l,mid),build(rs,mid+1,r);
	
	void modify(int p,int l,int r,int a,int b,int v)
		if (l==a&&r==b)cover(p,v);return;
		down(p);
		if (b<=mid) modify(ls,l,mid,a,b,v);
		else if (a>mid) modify(rs,mid+1,r,a,b,v);
		else modify(ls,l,mid,a,mid,v),modify(rs,mid+1,r,mid+1,b,v);
		update(p);
	
	int query(int p,int l,int r,int x)
		if (l==x&&r==x) return mins[p];
		down(p);
		if (x<=mid) return query(ls,l,mid,x);
		else return query(rs,mid+1,r,x);
	
	void modify(int l,int r,int v)modify(1,1,n,l,r,v);//printf("l=%d r=%d v=%d\\n",l,r,v);
	int query(int x)return query(1,1,n,x);
t1,t2;

struct Tsam
	int fa[maxn-pp],ch[maxn-pp][26],ri[maxn-pp],dis[maxn-pp],last,root,tot;
	void init()last=root=tot=1;
	int newnode(int v)return dis[++tot]=v,tot;
	void add(int x)
		int p=last,np=newnode(dis[p]+1);
		ri[np]=1,last=np;
		for (;p&&!ch[p][x];p=fa[p]) ch[p][x]=np;
		if (!p) fa[np]=root;
		else
			int q=ch[p][x];
			if (dis[q]==dis[p]+1) fa[np]=q;
			else
				int nq=newnode(dis[p]+1);
				memcpy(ch[nq],ch[q],sizeof(ch[q]));
				fa[nq]=fa[q];
				fa[q]=fa[np]=nq;
				for (;ch[p][x]==q;p=fa[p]) ch[p][x]=nq;
			
		
	
	void work()
		for (int i=1;i<=tot;i++)
			if (fa[i]) ri[fa[i]]=0;
		for (int i=1;i<=tot;i++)
			if (ri[i]==1)
				int l=dis[i]-dis[fa[i]],r=dis[i];
				//printf("%d %d %d %d\\n",i,l,r,r-l+1);
				t1.modify(l,r,r-l+1);
				if (l>1) t2.modify(1,l-1,r);
			
		for (int i=1;i<=n;i++) printf("%d\\n",min(t1.query(i),t2.query(i)-i+1));
	
T;

int main()
	scanf("%s",s+1),n=strlen(s+1),T.init();
	for (int i=1;i<=n;i++) T.add(s[i]-'a');
	t1.build(1,1,n),t2.build(1,1,n);
	T.work();
	return 0;