后缀自动机题解

最新推荐文章于 2021-01-17 16:14:17 发布
最新推荐文章于 2021-01-17 16:14:17 发布
阅读量395 收藏 1
点赞数
分类专栏： 后缀自动机 文章标签： 后缀自动机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linjiayang2016/article/details/82756528
版权

前言

后缀自动机(SAM)是一种优秀的数据结构，它作为一种自动机，不仅能接受一个字符串所有的后缀，还可以接受所有子串。然而这里并不打算写它的原理，这里仅提供题表和题解。
有关教程，固然，网上有很多详解，但都没有CLJ的正规，尽管CLJ的论文有些难懂，因此在学完网上的内容后，千万不要忘记回去看CLJ的论文。
进阶:Links

约定

  1. 状态：SAM上的点。
  2. 转移：SAM上的边。
  3. l o n g e s t longest longest：状态 i i i 的 l o n g e s t longest longest 表示从初始状态转移到状态 i i i 的最多步数。
  4. s h o r t e s t shortest shortest：同 l o n g e s t longest longest，只是变成了最少步数。
  5. r i g h t right right 集合：节点 i i i 的 r i g h t right right 集合表示初始状态转移到节点 i i i 所表示的字符串在原串中出现的右端点集合。
    如果你说初始状态转移到节点 i i i 可能有多条路径，那说明你还没有弄懂SAM，至少“相同 r i g h t right right 集合的状态被合并到一个状态”这一点你是不知道的。
  6. f a i l fail fail 指针：某个状态代表的是若干个 r i g h t right right 集合相同的串，那么随着后缀长度的减小，从某一个后缀开始，就可能出现在了更多的位置
    而且这个后缀以及比它更短的后缀的 r i g h t right right 集合一定会变大，因此就不得不分离到另一个节点上，成为那个节点的 l o n g e s t longest longest，而当前状态的 f a i l fail fail 指针就会指向那个状态。
  7. f a i l fail fail 树：把SAN上的 f a i l fail fail 指针变成一条无向边，得到的就是 f a i l fail fail 树。

题表

题号（网站）名称（题解）题意提示
Spoj1811Longest Common Substring最长公共子串匹配
Spoj1812/bzoj2946Longest Common Substring II多个串最长公共子串取最小匹配
Spoj705/Spoj694Distinct Substrings子串个数DAG 上的 DP
Luogu P3804后缀自动机统计字符串fail 树上 DP
Spoj 8222Substrings统计字符串right 集合大小
Luogu P1368工艺最小表示法可以不用 SAM 或 SA
Spoj7258Lexicographical Substring Search第k小子串SAM 分治
Luogu P3763[TJOI2017]DNA允许3个例外的匹配fail 树上DFS

模板

初始化

last=1,tot=1,ans=0;
memset(ch,0,sizeof ch);
memset(len,0,sizeof len);
memset(fails,0,sizeof fails);

构建函数 Θ ( n k ) \Theta(nk) Θ(nk)

void ins(int n){
	int p=last,np=++tot;
	last=np,len[np]=len[p]+1;
	for(; p&&!ch[p][x];p=fail[p])
		ch[p][x]=np;
	if(p==0)
		fail[np]=1;
	else{
		int q=ch[p][x];
		if(len[q]==len[p]+1)
			fail[np]=q;
		else{
			int nq=++tot;
			len[nq]=len[p]+1;
			memcpy(ch[nq],ch[q],sizeof ch[q]);
			fail[nq]=fail[q];
			fail[q]=fail[np]=nq;
			for(;ch[p][x]==q;p=fail[p])
				ch[p][x]=nq;
		}
	}
}

SAM拓扑序 Θ ( n ) \Theta(n) Θ(n)

int in[maxn],t[maxn];
void tsort(){
	int st=1,ed=1;
	for(int i=1;i<=tot;i++)
		for(int k=0;k<26;k++)
			++in[ch[i][k]];
	for(int i=1;i<=tot;i++)
		if(!in[i])
			t[ed++]=i;
	while(st!=ed){
		int &x=t[st++];
		for(int k=0;k<26;k++)
			if(ch[x][k]&&!--in[ch[x][k]])
				t[ed++]=ch[x][k];
	}
}

Fail树拓扑序 Θ ( n + k ) \Theta(n+k) Θ(n+k)

int ft[maxn],rs[maxn];
void build(){
	const int n=strlen(s);
	for(int i=1;i<=tot;i++)
		rs[len[i]]++;
	for(int i=n;i>=0;i--)
		rs[i]+=rs[i+1];
	for(int i=1;i<=tot;i++)
		ft[rs[len[i]]--]=i;
}

题解

Spoj1811 Longest Common Substring

题意　求两个字符串的最长公共子串的长度。
题解　对第一个串建立后缀自动机，然后让第二个在上面跑即可。
代码如下：

#include<bits/stdc++.h>
using namespace std;
#define maxn 1000000	//2n-1
int root=1,tot=1;
char s[maxn];
int fails[maxn],ch[maxn][30];
int last=1,len[maxn];
void ins(int x) {
	int p=last,np=++tot;
	last=np,len[np]=len[p]+1;
	for(; p&&!ch[p][x]; p=fails[p])
		ch[p][x]=np;
	if(p==0)
		fails[np]=1;
	else {
		int q=ch[p][x];
		if(len[q]==len[p]+1)
			fails[np]=q;
		else {
			int nq=++tot;
			len[nq]=len[p]+1;
			memcpy(ch[nq],ch[q],sizeof(ch[q]));
			fails[nq]=fails[q];
			fails[q]=fails[np]=nq;
			for(;ch[p][x]==q; p=fails[p])
				ch[p][x]=nq;
		}
	}
}
int runs(const char *s){
	int cur=1,lens=0,ret=0;
	for(int i=0;s[i];i++){
		int x=s[i]-'a';
		if(ch[cur][x]){
			++lens;
			cur=ch[cur][x];
		}else{
			while(cur&&!ch[cur][x])
				cur=fails[cur];
			if(!cur){
				cur=1,lens=0;
			}else{
				lens=len[cur]+1;
				cur=ch[cur][x];
			}
		}
		ret=max(ret,lens);
	}
	return ret;
}
int main(void)
{
	scanf("%s",s);
	for(int i=0;s[i];i++)
		ins(s[i]-'a');
	scanf("%s",s);
	printf("%d\n",runs(s));
	return 0;
}

Spoj1812/bzoj2946 Longest Common Substring II

题意　求多个字符串最长公共子串的长度。
题解　对第一个字符串建立SAM，然后把每个串在上面跑，其中，答案记录在SAM的节点上，取所有匹配的最短匹配（公共），答案则为所有节点的最大匹配（最长）。
其实这样有个小小的问题，当到达了状态’aba’时，我们可能没有更新状态’ba’和状态’a’的答案。因此在每次加入一个串之后需要重新更新其fail树上的所有祖先的答案。
代码如下：

#include<bits/stdc++.h>
using namespace std;
const int maxn=500010;
int len[maxn],ch[maxn][26],fails[maxn];
int tot=1,last=1,maxs[maxn],ans[maxn];
void ins(int x) {
	int p=last,np=++tot;
	last=np,len[np]=len[p]+1;
	for(; p&&!ch[p][x]; p=fails[p])
		ch[p][x]=np;
	if(p==0)
		fails[np]=1;
	else {
		int q=ch[p][x];
		if(len[q]==len[p]+1)
			fails[np]=q;
		else {
			int nq=++tot;
			len[nq]=len[p]+1;
			memcpy(ch[nq],ch[q],sizeof(ch[q]));
			fails[nq]=fails[q];
			fails[q]=fails[np]=nq;
			for(;ch[p][x]==q; p=fails[p])
				ch[p][x]=nq;
		}
	}
}
int sum[maxn],tmp[maxn];
void Tsort(int n){//基数排序计算拓扑序 
	memset(sum,0,sizeof sum);
	for(int i=1;i<=tot;i++)
		sum[len[i]]++;
	for(int i=1;i<=n;i++)
		sum[i]+=sum[i-1];
	for(int i=1;i<=tot;i++)
		tmp[sum[len[i]]--]=i;
}
void work(const char *s){//匹配 
	memset(maxs,0,sizeof(maxs));
	int lens=0,p=1;
	for(int i=0;s[i];i++){
		int x=s[i]-'a';
		if(ch[p][x])//匹配成功 
			lens++,p=ch[p][x];//往下走 
		else{
			for(;p&&!ch[p][x];p=fails[p]);//失配跳转 
			if(!p)
				p=1,lens=0;
			else
				lens=len[p]+1,p=ch[p][x];
		}
		maxs[p]=max(maxs[p],lens);
	}
	for(int i=tot;i;i--){//更新fail树 
		int x=tmp[i];
		ans[x]=min(ans[x],maxs[x]);
		if(maxs[x]&&fails[x])
			maxs[fails[x]]=len[fails[x]];
	}
}
char s[maxn];
int main(){
	scanf("%s",s);
	for(int i=0;s[i];i++)
		ins(s[i]-'a');
	memset(ans,63,sizeof ans);
	Tsort(strlen(s));
	while(~scanf("%s",s))
		work(s);
	int res=0;
	for(int i=1;i<=tot;i++)
		res=max(res,ans[i]);
	printf("%d\n",res);
	return 0;
}

Spoj694/Spoj705 Distinct Substrings

题意　求一个字符串的不同的子串个数。
题解　对该字符串建立SAM。DP当然可以，但这里有一种更简单的方法。
既然每个状态表示的是若干个 r i g h t right right 相等的字符串，那么不难得出一点，对于一堆 r i g h t right right 集合相同的子串，它们一定互为后缀，并且他们长度连续。因此只需要考虑每个节点对答案的贡献即可，即不同的子串的个数为： l o n g e s t − s h o r t e s t + 1 = l o n g e s t − f a i l . l o n g e s t longest-shortest+1=longest-fail.longest longest−shortest+1=longest−fail.longest
注意两道题目其中一道是大写字母，另一道是小写字母。
代码如下：

#include<bits/stdc++.h>
using namespace std;
const int maxn=500010;
int len[maxn],ch[maxn][26],fails[maxn];
int tot,last,ans;
void ins(int x) {
	int p=last,np=++tot;
	last=np,len[np]=len[p]+1;
	for(; p&&!ch[p][x]; p=fails[p])
		ch[p][x]=np;
	if(p==0)
		fails[np]=1;
	else {
		int q=ch[p][x];
		if(len[q]==len[p]+1)
			fails[np]=q;
		else {
			int nq=++tot;
			len[nq]=len[p]+1;
			memcpy(ch[nq],ch[q],sizeof(ch[q]));
			fails[nq]=fails[q];
			fails[q]=fails[np]=nq;
			for(;ch[p][x]==q; p=fails[p])
				ch[p][x]=nq;
		}
	}
}
char s[maxn];
int main(){
	int n;
	scanf("%d",&n);
	while(n--&&~scanf("%s",s)){
		last=1,tot=1,ans=0;
		memset(ch,0,sizeof ch);
		memset(len,0,sizeof len);
		memset(fails,0,sizeof fails);
		for(int i=0;s[i];i++)
			ins(s[i]-'A');//705要变成 ins(s[i]-'a')
		for(int i=1;i<=tot;i++)
			ans+=len[i]-len[fails[i]];//直接统计答案
		printf("%d\n",ans);
	}
	return 0;
}

Luogu P3804 后缀自动机

题意　求出字符串 S S S 的所有在 S S S 中出现次数不为 1 1 1 的子串的出现次数乘上该子串长度的最大值。
题解　构建出 S A M SAM SAM 后，可以发现每个字符串的出现次数就是对应状态的 r i g h t right right 集合大小。可以发现，在 f a i l fail fail 树上，某个状态所表示的字符串一定是其儿子所表示的字符串的后缀，因此某个状态所表示的 r i g h t right right 一定是其所有儿子的 r i g h t right right 集合的并集。
　　又因为子串可以表示成某个后缀的前缀，因此只需要把原字符串的所有前缀的次数标记出来，然后在 f a i l fail fail 树上合并即可，即：
s i z e u = ∑ v ∈ s o n ( u ) s i z e v size_u=\sum _{v\in son(u)}size_v sizeu​=v∈son(u)∑​sizev​　　代码如下：

#include<bits/stdc++.h>
using namespace std;
#define maxn 2000010
char s[maxn];
int last=1,tot=1;
int len[maxn],ch[maxn][30],fails[maxn];
int size[maxn];
void ins(int x) {
	int p=last,np=++tot;
	last=np,len[np]=len[p]+1;
	for(; p&&!ch[p][x]; p=fails[p])
		ch[p][x]=np;
	if(p==0)
		fails[np]=1;
	else {
		int q=ch[p][x];
		if(len[q]==len[p]+1)
			fails[np]=q;
		else {
			int nq=++tot;
			len[nq]=len[p]+1;
			memcpy(ch[nq],ch[q],sizeof(ch[q]));
			fails[nq]=fails[q];
			fails[q]=fails[np]=nq;
			for(;ch[p][x]==q; p=fails[p])
				ch[p][x]=nq;
		}
	}
}
struct edge{
	int v,next;
}edges[maxn];
int head[maxn];
void ins(int u,int v){
	static int len=0;
	edges[++len]=(edge){v,head[u]};
	head[u]=len;
}
long long ans=0;
void dfs(int x){
	for(int i=head[x];i;i=edges[i].next)
		dfs(edges[i].v);
	size[fails[x]]+=size[x];
	if(size[x]>1)
		ans=max(ans,(long long)size[x]*len[x]);
}
int main(void){
	scanf("%s",s);
	for(int i=0;s[i];i++)
		ins(s[i]-'a');
	for(int i=1;i<=tot;i++)
		ins(fails[i],i);
	for(int i=1,p=1;s[i];i++)
		p=ch[p][s[i]-'a'],size[p]=1;
	dfs(1);
	printf("%lld\n",ans);
	return 0;
}

    　这份代码只是幸运地在Linux系统下通过了而已，因为仔细想想可能会爆栈。于是我们可能需要一遍拓扑排序。其实不需要拓扑排序。
　　我们知道节点 v v v 的 r i g h t right right 集合一定是 v v v 的父亲 f a fa fa 的 r i g h t right right 集合的子集，因此 v . l o n g e s t v.longest v.longest 必然大于 f a . l o n g e s t fa.longest fa.longest。因此一个状态的 l o n g e s t longest longest 越长，它一定是更底层的状态。因此只需要对每个节点按照 l o n g e s t longest longest 排序即可，为了不提高时间复杂度，这里采用了基数排序（可参考后缀数组的倍增算法），和构建SAM的时间复杂度一致。
　　代码如下：

#include<bits/stdc++.h>
using namespace std;
#define maxn 2000010
char s[maxn];
int last=1,tot=1;
int len[maxn],ch[maxn][30],fails[maxn];
int size[maxn];
void ins(int x) {
	int p=last,np=++tot;
	last=np,len[np]=len[p]+1;
	for(; p&&!ch[p][x]; p=fails[p])
		ch[p][x]=np;
	if(p==0)
		fails[np]=1;
	else {
		int q=ch[p][x];
		if(len[q]==len[p]+1)
			fails[np]=q;
		else {
			int nq=++tot;
			len[nq]=len[p]+1;
			memcpy(ch[nq],ch[q],sizeof(ch[q]));
			fails[nq]=fails[q];
			fails[q]=fails[np]=nq;
			for(;ch[p][x]==q; p=fails[p])
				ch[p][x]=nq;
		}
	}
}
int t[maxn],rs[maxn];
void build(){
	const int n=strlen(s);
	for(int i=0;i<n;i++)
		ins(s[i]-'a');
	for(int i=1;i<=tot;i++)
		rs[len[i]]++;
	for(int i=n;i>=0;i--)
		rs[i]+=rs[i+1];
	for(int i=1;i<=tot;i++)
		t[rs[len[i]]--]=i;
}
long long ans=0;
void solve(){
	for(int i=1,p=1;s[i];i++)
		p=ch[p][s[i]-'a'],size[p]=1;
	for(int i=1;i<=tot;i++){
		int now=t[i];
		size[fails[now]]+=size[now];
		if(size[now]>1)
			ans=max(ans,(long long)size[now]*len[now]);
	}
}
int main(void){
	scanf("%s",s);
	build();
	solve();
	printf("%lld\n",ans);
	return 0;
}

Spoj 8222 Substrings

题意　定义 f i f_i fi​ 为字符串 S S S 的所有长度为 i i i 的子串的出现次数的最大值。求 f 1 ⋯ f l e n g t h ( S ) f_{1}\cdots f_{length(S)} f1​⋯flength(S)​ 值。
题解　有了上一题的基础，这一题应该不难解决。先对 S S S 建立SAM，对于节点 v v v，可以发现，其对 f v . s h o r t e s t , ⋯   , f v . l o n g e s t f_{v.shortest},\cdots,f_{v.longest} fv.shortest​,⋯,fv.longest​均有贡献，如果这样维护那时间复杂度就是 O ( n 2 ) O(n^2) O(n2) 的了。
　　其实可以发现，长度为 i i i 的子串一定是长度为 i + 1 i+1 i+1 的子串的子串。
　　也就是说，我们可以只考虑 f v . l o n g e s t f_{v.longest} fv.longest​ ，然后用 f i = m a x ( f i + 1 , f i ) f_i=max(f_{i+1},f_i) fi​=max(fi+1​,fi​) 来更新更短的子串。
代码如下：

#include<bits/stdc++.h>
using namespace std;
#define maxn 2000010
char s[maxn];
int last=1,tot=1;
int len[maxn],ch[maxn][30],fails[maxn];
int size[maxn];
int t[maxn],rs[maxn];
void ins(int x) {
	int p=last,np=++tot;
	last=np,len[np]=len[p]+1;
	for(; p&&!ch[p][x]; p=fails[p])
		ch[p][x]=np;
	if(p==0)
		fails[np]=1;
	else {
		int q=ch[p][x];
		if(len[q]==len[p]+1)
			fails[np]=q;
		else {
			int nq=++tot;
			len[nq]=len[p]+1;
			memcpy(ch[nq],ch[q],sizeof(ch[q]));
			fails[nq]=fails[q];
			fails[q]=fails[np]=nq;
			for(;ch[p][x]==q; p=fails[p])
				ch[p][x]=nq;
		}
	}
}
void build(){
	const int n=strlen(s);
	for(int i=0;i<n;i++)
		ins(s[i]-'a');
	for(int i=1;i<=tot;i++)
		rs[len[i]]++;
	for(int i=n;i>=0;i--)
		rs[i]+=rs[i+1];
	for(int i=1;i<=tot;i++)
		t[rs[len[i]]--]=i;
}
long long f[maxn];
int main(void){
	scanf("%s",s);
	build();
	const int n=strlen(s);
	for(int i=0,p=1;s[i];i++)
		p=ch[p][s[i]-'a'],size[p]=1;
	for(int i=1;i<=tot;i++)
		size[fails[t[i]]]+=size[t[i]];
	for(int i=1;i<=tot;i++)
		f[len[i]]=max(f[len[i]],(long long)size[i]);
	for(int i=n;i;i--)//似乎数据水，不加也能过 
		f[i]=max(f[i],f[i+1]);
	for(int i=1;i<=n;i++)
		printf("%lld\n",f[i]);
	return 0;
}

Luogu P1368 工艺

题意　给定一个循环序列，从某处断开，输出所有可能得到的序列中，字典序最小的那一个。
题解　对于循环类的问题，先把序列复制一遍，然后构建SAM，这里有个小问题，不知道每个元素的大小，导致 c h ch ch 数组不好开，这里其实可以用 m a p map map。
建立好SAM之后，可以直接从初始状态出发，贪心地沿着最小的边（ch[p].begin()）走，走 n n n 步即可。
　　代码如下：

#include<bits/stdc++.h>
using namespace std;
#define maxn 1000010
char s[maxn];
int last=1,tot=1;
int len[maxn],fails[maxn];
map<int,int> ch[maxn];
int size[maxn];
void ins(int x){
	int p=last,np=++tot;
	last=np;len[np]=len[p]+1;
	for(;p&&!ch[p].count(x);p=fails[p])
		ch[p][x]=np;
	if(!p)
		fails[np]=1;
	else{
		int q=ch[p][x];
		if(len[q]==len[p]+1)
			fails[np]=q;
		else{
			int nq=++tot;
			len[nq]=len[p]+1;
			ch[nq]=ch[q];
			fails[nq]=fails[q];
			fails[q]=fails[np]=nq;
			for(;ch[p][x]==q;p=fails[p])
				ch[p][x]=nq;
		}
	}
}
int n,tt[maxn];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&tt[i]);
		ins(tt[i]);
	}
	for(int i=1;i<=n;i++)
		ins(tt[i]);
	for(int p=1,i=1;i<=n;i++){
		map<int,int>::iterator pos=ch[p].begin();
		printf("%d ",pos->first);
		p=pos->second;
	}
	printf("\n");
	return 0;
}

又及　这道题还可以用后缀数组(SA)解决，方法类似，倍长后第一个长度大于等于 n n n 的后缀即为答案，时间复杂度比SAM略高。可这不是重点，重点是这题有绝对的 Θ ( n ) \Theta(n) Θ(n) 的时间复杂度。算法名称：最小表示法。

Spoj7258 Lexicographical Substring Search

题意　给出一个字符串，若相同子串算一次，且排名相同，询问其字典序第 k k k 小的子串。
题解　由SAM的性质得，所有 r i g h t right right 集合相同的子串会被合并到一个状态中，那完全相同的子串就更加会被合并到一个状态中了。定义 f u f_u fu​ 表示从状态 u u u 出发，能到达的的串的个数(且这些串一定是原字符串的子串)，则有：
f u = 1 + ∑ v ∈ s o n ( u ) f v f_u=1+\sum_{v\in son(u)}f_v fu​=1+v∈son(u)∑​fv​　　注意这个方程需要的计算顺序。按照SAM的拓扑序固然可以，但其实也可以按照fail树的拓扑序。为什么？其实本来是不可以的，但是因为我们做fail树的拓扑排序是根据其len的大小排序的，因而更长的串一定先被处理了。
　　得到 f f f 后就很容易了，从初始状态 s s s 出发，带上 k k k，扫一遍 s s s 的儿子，设当前访问到的儿子为 v v v，若 f v > k f_v>k fv​>k，则答案必然不在 v v v 子树中，令 k = k − f v k=k-f_v k=k−fv​，然后继续遍历。若 f v < = k f_v<=k fv​<=k，则令 s = v s=v s=v 进入该子树找。
　　代码如下：

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+5;
int ch[maxn][26],fail[maxn],len[maxn],sum[maxn];
int n,last=1,tot=1;
char s[maxn];
void extend(int x){
	int p=last,np=++tot;
	last=np;len[np]=len[p]+1;
	for(;p&&!ch[p][x];p=fail[p])
		ch[p][x]=np;
	if (p==0)
		fail[np]=1;
	else{
		int q=ch[p][x];
		if(len[q]==len[p]+1)
			fail[np]=q;
		else{
			int nq=++tot;
			len[nq]=len[p]+1;
			memcpy(ch[nq],ch[q],sizeof(ch[nq]));
			fail[nq]=fail[q];
			fail[q]=fail[np]=nq;
			for(;p&&ch[p][x]==q;p=fail[p])
				ch[p][x]=nq;
		}
	}
}
int ft[maxn],rs[maxn];
void build(){
	const int n=strlen(s);
	for(int i=1;i<=tot;i++)
		rs[len[i]]++;
	for(int i=n;i>=0;i--)
		rs[i]+=rs[i+1];
	for(int i=1;i<=tot;i++)
		ft[rs[len[i]]--]=i;
}
void solve(int k){
	int p=1;
	while(k>0){
		for(int j=0;j<26;++j){
			if(!ch[p][j])
				continue;
			if(sum[ch[p][j]]>=k){
				putchar(j+'a');
				--k;
				p=ch[p][j];
				break;
			}else
				k-=sum[ch[p][j]];
		}
	}
	putchar('\n');
}
int main(){
	scanf("%s",s);
	for(int i=0;s[i];++i)
		extend(s[i]-'a');
	build();//同样可以用拓扑排序tsort
	for(int i=1;i<=tot;i++){
		sum[ft[i]]=1;
		for(int j=0;j<26;++j)
			sum[ft[i]]+=sum[ch[ft[i]][j]];
	}
	int Q,k;
	scanf("%d",&Q);
	while (Q--&&~scanf("%d",&k))
		solve(k);
	return 0;
}

Luogu P3763 [TJOI2017]DNA

题意　给定两个 DNA 序列 S S S 和 T T T，求允许 3 个例外字符的情况下， T T T 在 S S S 中出现的次数。
题解　考虑生物：DNA 序列中只包含 A , T , C , G A,T,C,G A,T,C,G 四种字符，否则会浪费很多空间。对 S S S 建立后缀自动机，求出每个节点的 r i g h t right right 集合大小，然后直接在 SAM 上暴力搜索即可。
代码如下：

#include<bits/stdc++.h>
using namespace std;
#define maxn 200010
#define N 100010
int root,tot,ans;
char s[N];
int fails[maxn],ch[maxn][5],cnt[maxn];
int last,len[maxn];
inline void init() {
	root=last=tot=1,ans=0;
	memset(ch,0,sizeof ch);
	memset(len,0,sizeof len);
	memset(fails,0,sizeof fails);
	memset(cnt,0,sizeof cnt);
}
inline void ins(int x) {
	int p=last,np=++tot;
	last=np,len[np]=len[p]+1;
	for(; p&&!ch[p][x]; p=fails[p])
		ch[p][x]=np;
	if(p==0)
		fails[np]=1;
	else {
		int q=ch[p][x];
		if(len[q]==len[p]+1)
			fails[np]=q;
		else {
			int nq=++tot;
			len[nq]=len[p]+1;
			memcpy(ch[nq],ch[q],sizeof ch[q]);
			fails[nq]=fails[q];
			fails[q]=fails[np]=nq;
			for(; ch[p][x]==q; p=fails[p])
				ch[p][x]=nq;
		}
	}
}
int ft[maxn],rs[N];
inline void build() {
	const int n=strlen(s)+10;
	for(register int i=1; i<=tot; ++i)
		rs[len[i]]++;
	for(register int i=n; i>=0; i--)
		rs[i]+=rs[i+1];
	for(register int i=1; i<=tot; ++i)
		ft[rs[len[i]]--]=i;
	for(register int i=n; i>=0; --i)
		rs[i]=0;
}
int Ts[127];
inline void right() {
	for(register int i=0,p=1; s[i]; i++)
		p=ch[p][(int)s[i]],cnt[p]=1;
	for(register int i=1; i<=tot; i++)
		cnt[fails[ft[i]]]+=cnt[ft[i]];
}
char str[N];int m;
void dfs(int p,int len,int dec){
	if(len>=m){
		ans+=cnt[p];
		return;
	}
	for(register int i=1;i<=4;++i){
		if(!ch[p][i]) continue;
		if(i==str[len])
			dfs(ch[p][i],len+1,dec);
		else if(dec<3)
			dfs(ch[p][i],len+1,dec+1);
	}
}
int main(void) {
	int T;
	Ts['A'-'A']=1;Ts['T'-'A']=2;Ts['C'-'A']=3;Ts['G'-'A']=4;
	scanf("%d",&T);
	while(T--){
		init();
		scanf("%s%s",s,str);
		for(register int i=0;s[i];++i)
			ins(s[i]=Ts[s[i]-'A']);
		for(m=0;str[m];m++)
			str[m]=Ts[str[m]-'A'];
		build();right();
		dfs(1,0,0);
		printf("%d\n",ans);
	}
	return 0;
}

又及　本题的最优解为哈希，但并非完美算法，同样也可以用SA求出LCP后暴力，这里想说明的是，由于这道题的特殊性，还可以使用快速傅里叶变换解决，前提是你是个十分注意算法常数的人。

linjiayang2016
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
北大 acm 经典题解
08-18
4. **字符串处理**：模式匹配（如KMP、Boyer-Moore算法）、字符串匹配、后缀数组、后缀自动机等，这些都是解决字符串相关问题的常用工具。 5. **计算几何**：点、线、面的性质，平面几何变换，距离计算，最近点对...
哈工大 acm 题解（900 多 道）经典
04-12
4. **字符串处理**：KMP算法、Boyer-Moore算法、Rabin-Karp滚动哈希等用于字符串匹配，以及字符串操作（如前缀函数、后缀自动机）在文本处理中的应用。 5. **计算几何**：点、线、面之间的关系，如最近点对问题、...
后缀自动机经典模板题集合
kangdi的博客
10-26 1074
花了很久总结出来的基本操作 一次性全丢这里了 1：存在性查询 查询一个字符串是否是另一个字符串的子串 #include<bits/stdc++.h> using namespace std; const int maxn=5e4+5; char s[maxn]; int n; struct Suffix_Automation { int next[maxn*2][26]...
后缀自动机的一些简单题目
ctlchild的博客
09-20 621
对于后缀自动机的论文很多，这里记录一些比较简单的题目便于熟悉后缀自动机的基本应用 只有四道题目有一点少，今后会好好填坑 BZOJ4032: [HEOI2015]最短不公共子串 一句话题意：给两个串 A 和 B，求 A 最短子串且不是 B 的子串，A 最短子串且不是B的子序列，A 最短子序列且不是 B 的子串，A 最短子序列且不是 B 的子序列 做法：建出后缀自动机和序列自动机，自动机上每一条路径
后缀自动机题目整理
EM LGH
02-13 224
后缀自动机题目整理 1. 洛谷P1368 (工艺) 求最小表示 2. 洛谷P3804 (模板) 统计单词出现次数，right集合大小 3. SPOJ8222 (NSUBSTR-Substrings) 简单动态规划 4. APIO2014  (回文串) 后缀树，倍增 5. SPOJ1812 (LCS2) 最长公共子串 6. TJOI2015   (弦...
专题训练2 后缀自动机题目清单
qq_39898877的博客
09-16 735
模板 void ins(int ch){ int p=last,np=++cnt;mx[np]=mx[p]+1;last=np;size[np]=1; while(p &amp;&amp; !son[p][ch]) son[p][ch]=np,p=fa[p]; if(!p) fa[np]=root; else{ int q=son[p][ch];...
[后缀自动机 模板题] SPOJ 8222 Substrings
雯舞
01-28 697
题目大意：求某个长度的所有子串中出现次数最多的次数每个状态对应一段长度区间的子串 right集合的大小就是出现次数 那么我们用|right(x)|去更新f[maxs[x]]的值，最后从大到小用f[i]去更新f[i-1]的值即可#include<cstdio> #include<cstdlib> #include<algorithm> using namespace std;inline char
Editorials:算法题解＆教程
03-19
题解＆教程 不定期更新，有想让我写的算法或翻译请开问题。 请star以示支持，谢谢。 写作计划 Tarjan SCC / BCC AC自动机 背包全集 红黑树 后缀自动机 后缀曲面 快速傅立叶变换 图匹配 最小圆覆盖
浙江大学ACM题解JU_ACM_All_Anwer
09-21
5. **字符串处理**：KMP算法、后缀数组、AC自动机等，对于处理文本和字符串问题至关重要。 6. **几何算法**：二维和三维几何问题，如线段交点计算、凸包问题、最近点对问题等。 7. **编码技巧**：如位操作、贪心...
2021“MINIEYE杯”中国大学生算法设计超级联赛（4）-题解1
最新发布
08-03
后缀数组可以直观地获取所有子串，而后缀自动机/后缀树则能高效地查找特定模式的子串，时间复杂度为O(n log n)。 5. **Didn't I Say to Make My Abilities Average in the Next Life?! 题解**：这是一道区间最值...
后缀自动机刷题计划
diaopinshuo4087的博客
06-19 110
后缀自动机刷题计划 codevs3160: 最长公共子串 bzoj3998: [TJOI2015]弦论 bzoj2946: [Poi2000]公共串 bzoj3926: [Zjoi2015]诸神眷顾的幻想乡 bzoj2555: SubString bzoj4566: [Haoi2016]找相同字符 bzoj3238: [Ahoi2013]差异 bzoj2806: ...
后缀自动机应用及题目
AcTarjan的博客
09-26 411
1、最长公共子串问题（LCS问题） 题目：SPOJ-LCS     SPOJ-LCS2 2、最长不公共子串问题 题目：4032 3、最小表示法问题 题目：落谷P1368 4、第k小子串问题 题目：bzoj-3998 5、后缀自动机+dp 题目：SPOJ-Substring      落谷P3804       4516      4566 6、后缀自动机+维护 题目：2555...
【后缀自动机】
weixin_33749131的博客
08-25 101
后缀自动机也是解决字符串问题的常用工具，犀利在O(N)的空间复杂度下存在给定串的后缀以及子串，而且支持在线的操作。 POJ-1509 Glass Beads 题意：求一个字符串的最小表示的开始下标。 分析：其实有一个O(N)的算法专门来解决这个问题，并且实现非常简单，不过后缀自动机同样能够解决这个问题。首先把这个串重复两次，然后从前往后一一将字符加入到后缀自动机中，最后从根开始向下遍历串的长...
[洛谷] (P3804)【模板】后缀自动机 ---- SAM（模板题）
WangMeow --- ᶘ ᵒᴥᵒᶅ ฅ^•ﻌ•^ฅ
10-18 257
题目传送门 做法： 考察SAM的基本概念，即各个状态的endpos集合的大小怎么求？ 我们从parent树上自底向上跑，类似树的遍历（即回溯过程），去统计集合的大小即可。 AC代码： #include&lt;bits/stdc++.h&gt; #define IO ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0) #def...
后缀数组&后缀自动机题目泛做
BlueSky
01-01 367
这几天想学后缀自动机的，结果发现后缀数组的坑还空着，索性填填吧。。 POJ2774 题目链接：http://poj.org/problem?id=2774 题解： 两个字符串之间加一个分隔符，求一发sa[i]sa[i]sa[i]分别位于两个字符串中的lcplcplcp即可，注意细节：数组两倍大、字符集大小等 代码： // by Balloons #include &amp;amp;amp;lt;cstdio&amp;amp;amp;gt; #i...
后缀自动机基础应用
myjs999的博客
07-26 696
本博客讲解后缀自动机基础应用，而不说明定义、构建等内容。 构建代码如下：（跑得飞慢） struct node { node* ch[26], *f; int len, siz; // siz即Right集合大小 }; node* _nd = (node*)malloc(SIZE_OF_SAM); int noden; node* root, *last; inline no...
后缀自动机模板题hdu_后缀自动机习题合集
weixin_30230059的博客
01-17 153
constmaxn=400000;varson:array[0..maxn,0..25]oflongint;pre,step:array[0..maxn]oflongint;last,tot:longint;functionaddpoint:longint;vari:longint;begininc(tot);//pre[tot]:=-1;// for i:=0 to 25 do son[tot,...
后缀自动机总结
萍水相逢，尽是他乡之客
03-13 945
后缀自动机总结很长时间没写过博客了，该写写了。最近一直在学习和联系后缀自动机，总体的感觉还不错。
后缀自动机概述
lvmaooi的博客
09-12 3888
如果对后缀自动机有一定了解，这几篇文章对你可能会有些许帮助： 后缀自动机学习指南 loj上的后缀自动机讲解 一些题目 听说对拆点讲解很详细 以题目为主，当然也有一些讲解。下面说一下我对后缀自动机的理解。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值