后缀自动机的一些应用

未学习后缀自动机的话，可以去这里看一下

由于字符串变化多端，这里介绍一些 $SAM$ 的简单应用，以增加一些理解；

后缀自动机的应用

本质不同子串的个数

我们有 $SA$ 数组的做法，在 $SAM$ 上也一样可做；

发现其实 $SAM$ 上是没有重复子串的，我们只需要统计出 $SAM$ 上所有的子串就可以了；

即 $ans=\sum maxlen[i]-minlen[i]+1$

统计子串出现次数

求出 $SAM$ 上每个每个字串的出现次数；

其实就是求每个状态的 $endpos$ 集合大小，怎么求呢?

首先每次新加的一个状态 $endpos$ 至少有一;

另外的，对于一个状态，每一个 $link$ 入边，都会对此状态产生贡献；

即 $num[i]+=\sum_{link[j]=i}num[j]$

这样就可以在 $link$ 所构成的 $DAG$ 上跑拓扑；

两个串的最长公共子串

$eg.$ SP1811

$SA$ 过不了的那种，可以先在第一个串上建 $SAM$ ，因为所有子串都会在 $SAM$ 上体现，我们可以考虑将第二个串在这个 $SAM$ 进行匹配；

算法流程：

当前状态 $p$ （初始为 $1$ ），待匹配的字符是 $S[i]$ ，已匹配的长度为 $len$

如果 $trans[p][S[i]]!=0$ ，意味着有这个子串，将 $len++$ ，转移到下一个状态；
否则沿着 $link$ 向前寻找：
- 如果能找到一个状态 $p$ ，满足 $trans[p][S[i]]!=0$ ，则可以将 $len=maxlen[p]+1$ ，转移到 $trans[p][S[i]]$ ；
- 否则 $len=0,p=1$ ；
更新答案；

时间复杂度是 $O(n)$ ， $n$ 是两个字符串的总长；

部分代码

void search(int n)
{
    int p=1;
    for(int i=1;i<=n;i++)
	{
		int c=s[i]-'a';
		if(trans[p][c]) len++,p=trans[p][c];
		else
		{
			for(;p&&!trans[p][c];p=link[p]);
			if(p) len=maxlen[p]+1,p=trans[p][c];
			else len=0,p=1;
		}
    	ans=max(ans,len);
    }
}

多个串的最长公共子串

$eg.$ SP1812

假设有 $k$ 个长度为 $n$ 的字符串；

介绍两种方法

1 O(nk^2)

类似于统计子串出现次数，对于加进去的第 $i$ 个字符串，对每个状态的第 $i$ 维打上标记，即 $num[x][i]=1$ ;

再用拓扑或深搜统计出每个状态在每个字符串里出现的次数；

如果存在一个状态 $x$ ，它的每一位都有值（即在每个字符串中都出现过），可以用它更新答案；

时间复杂度是 $O(nk^2)$ ，过不了那个例题，但很好理解；

深搜时的代码

inline void dfs(int x)
{
	for(int i=head[x];i;i=a[i].nxt)
	{
		dfs(a[i].to);
		for(int j=0;j<t;j++)//t是个数
			T.num[x][j]+=T.num[a[i].to][j];
	}
	bool fl=0;
	for(int j=0;j<t;j++)
		if(!T.num[x][j])
		{
			fl=1;
			break;
		}
		
	if(!fl) ans=max(ans,T.ml[x]);
}

2 O(nk)

另一种

由求两个串的情况拓展而来；

考虑在第一个串上建 $SAM$ ，把剩余的每个串都拿到 $SAM$ 上去匹配一下；

每次匹配时，得到当前匹配，每个状态的最长匹配成功长度；

按照理想的情况，最后在每次匹配的最长长度中找一个最小值，就是某一状态的所有匹配的最长公共匹配成功长度；

但是会存在一个问题，如果状态 $x$ 匹配成功了，其 $link[x]$ 也一定存在 $x$ 的匹配，我们没有到达过 $link[x]$ ，这一部分值就无从存在了，所以我们必须要更新 $link[x]$ ；

但由于 $link[x]$ 自身长度的限制，我们应当把 $maxn[link[x]]=max(maxn[link[x]],min(maxn[x],maxlen[link[x]]))$ ；

( $maxn[x]$ 就是状态 $x$ 的当前匹配的最长匹配成功长度)

为了保证这个过程更新完全，我们需要按拓扑序来更新，即先更新了 $x$ 后才能更新 $link[x]$ ；

我们发现 $maxlen[x]>maxlen[link[x]]$ ，所以按照 $maxlen$ 的排名更新就可以了，可以省去一次拓扑排序；

这样时间是 $O(nk)$

有关代码

//这都在SAM结构体中
void topu()
{
	for(int i=1;i<=sz;i++) tub[ml[i]]++;
	for(int i=1;i<=sz;i++) tub[i]+=tub[i-1];
	for(int i=sz;i>=1;i--) b[tub[ml[i]]--]=i;
}
//类似于后缀数组，用一次基数排序得到拓扑序
void work()
{
	int l=0,p=1;
	for(int i=1;i<=n;i++)
	{
		int x=c[i]-'a';
		if(trans[p][x]) l++,p=trans[p][x];
		else
		{
			for(;p&&!trans[p][x];p=link[p]);
			if(p) l=ml[p]+1,p=trans[p][x];
			else l=0,p=1;
		}
		mas[p]=max(mas[p],l);
	}
	for(int i=sz;i>=1;i--)
	{
		int x=b[i],li=link[x];
		mas[li]=max(mas[li],min(mas[x],ml[li]));
		mis[x]=min(mis[x],mas[x]);
		mas[x]=0;
	}
}

字典序第k大子串

$eg.$ P3675

有两种情况

当不合并本质相同的串时：

还是基于一个思想， $SAM$ 上的路径对应了一个一个的子串；

求第 $k$ 大子串就是求第 $k$ 大路径；

类似于二叉查找树的方法，如果我们能知道每个状态后连接了多少条路径的话，我们就可以把这个问题当成多叉查找树来做；

另外还需要考虑一个问题；

每个状态有多个 $endpos$ ，这相当与一个状态的副本数；

我们仍然记 $|endpos[i]|$ 为 $num[i]$ ；

将第 $i$ 个状态的路径总数，扩展为经过这个状态的子串数，记为 $sum[i]$ ；

因为，状态自身就存在 $num[i]$ 个子串，且排在后面继续匹配的得到的子串的前面；

可以得到

s u m [i] = n u m [i] + \sum_{t r a n s [i] [j] = x} s u m [j]

$sum[i]=num[i]+\sum_{trans[i][j]=x}sum[j]$

另一种情况：

合并本质相同的串；

其实就是把每个状态（除了起始状态）的 $num$ 都置为 $1$ ；

$code$

#include<bits/stdc++.h>
#define ll long long 
#define mp make_pair
using namespace std;
const int N=500010;
char c[N];
int n,ty,k;

struct SAM
{
	int sz,last;
	int tub[N<<1],b[N<<1];
	int num[N<<1],sum[N<<1];
	int link[N<<1],trans[N<<1][26],ml[N<<1];
	SAM(){sz=last=1;}
	
	void add(int id)
	{
		int x=++sz,p;
		ml[x]=ml[last]+1;
		num[x]=1;
		for(p=last;p&&!trans[p][id];p=link[p]) trans[p][id]=x;
		if(!p) link[x]=1;
		else
		{
			int q=trans[p][id];
			if(ml[q]==ml[p]+1) link[x]=q;
			else
			{
				int y=++sz;
				ml[y]=ml[p]+1;
				memcpy(trans[y],trans[q],sizeof trans[y]);
				link[y]=link[q];
				for(;p&&trans[p][id]==q;p=link[p]) trans[p][id]=y;
				link[x]=link[q]=y;
			}
		} 
		last=x;
	}
	
	void topu()
	{
		for(int i=1;i<=sz;i++) tub[ml[i]]++;
		for(int i=1;i<=sz;i++) tub[i]+=tub[i-1];
		for(int i=sz;i>=1;i--) b[tub[ml[i]]--]=i;
	}
	
	void getsz()
	{
		for(int i=sz;i>=1;i--)
		{
			int x=b[i];
			sum[x]+=num[x];
			num[link[x]]+=num[x];
		}
		if(ty==0) for(int i=1;i<=sz;i++) sum[i]=num[i]=1;
	}
	
	void getsum()
	{
		num[1]=sum[1]=0;
		for(int i=sz;i>=1;i--)
		{
			int x=b[i];
			for(int j=0;j<26;j++)
				if(trans[x][j]) sum[x]+=sum[trans[x][j]];
		}
	}
	
}T;

inline void sol(int x,int k)
{
	if(k<=T.num[x]) return ;
	k-=T.num[x];
	for(int i=0;i<26;i++)
	{
		int y=T.trans[x][i];
		if(!y) continue;
		if(k>T.sum[y])
		{
			k-=T.sum[y];
		}
		else
		{
			printf("%c",'a'+i);
			sol(y,k);
			break;
		}
	}
}

int main()
{
	scanf("%s",c+1);
	scanf("%d%d",&ty,&k);
	n=strlen(c+1);
	for(int i=1;i<=n;i++)
		T.add(c[i]-'a');
	T.topu();
	T.getsz();
	T.getsum();
	if(T.sum[1]<k) printf("-1");
	else sol(1,k);
	
	return 0;
}

长度为k的子串的最大出现次数

$eg.$ SP8222

如果只有一组询问，可以直接遍历 $SAM$ ，如果一个状态的 $maxlen>=k>=minlen$ ，就可以用这个状态的 $|endpos|$ 更新；

如果有多组询问，可以将每个状态的 $|endpos|$ ，来对应更新 $ans[maxlen[i]]$ ；

再用 $ans[i]=max(ans[i],ans[i+1])$ 来补全答案；

因为 $maxlen$ 的后缀的出现次数一定大于 $maxlen$ 的出现次数；

所有前缀的最长公共后缀和

$eg.$ P4248

先说求所有前缀的公共后缀：

先把我们得到的 $link$ 建成一棵树；

两个前缀所在的状态在这棵树上的 $lca$ 的 $maxlen$ 就是这两个前缀的最长公共后缀；（因为这两个前缀共有同样的后缀连接，它们后缀“断掉”的情况是相同的）；

如何求所有呢？是不是求每两个前缀的最长公共后缀再乘上，它们出现次数的积就可以了呢？

不只是这样的，对于那些从初始状态出发，不是前缀的状态（一定是分裂出的状态），它们的出现次数是从它们被 $link$ 的前缀得来的，也就是说，它们的出现也伴随着前缀的出现，它们的最长公共后缀就等于它们所对应的前缀的最长公共后缀；

对于这部分的状态，也应该像上面那样处理；

所以我们必须求出

\sum_{i = 1}^{s z} \sum_{j = 1}^{i - 1} m a x l e n [l c a (i, j)] * n u m [i] * n u m [j]

$\sum\limits_{i=1}^{sz}\sum\limits_{j=1}^{i-1}maxlen[lca(i,j)]*num[i]*num[j]$

$num$ 就是一个状态的 $|endpos|$ ；

这样时间复杂度是 $O(n^2)$

我们考虑算每个状态的贡献，计算它是多少点对的 $lca$ ；

拓扑之后

可以得到这样的代码

	ll sol()
	{
		ll res=0;
		for(int i=sz;i>=1;i--)
		{
			int x=b[i];//拓扑序对应的节点
			res+=(ll)num[link[x]]*num[x]*ml[link[x]];
			num[link[x]]+=num[x];
		}
		return res;
	}

循环中的 $num[link[x]]$ 是未加入 $num[x]$ 的值，相当不包含当前子树的其他子树的大小，可以与当前子树中节点一一构成一个节点对；

这样就可以 $O(n)$ 得到答案；

但例题中好像要求所有后缀的最长公共前缀；

其实把最初的字符串翻转，这两者就是相等的了；

拓展：广义后缀自动机简介

上面有些题目是对一组字符串进行处理；

我们有的是对一个串建机，其他跑匹配，有的用特殊字符隔开在复合串上建机；

但这都有局限性；

而广义 $SAM$ 是专门来解决多字符串的；

这个 $SAM$ 上有所有字符串的子串，同样不重复；

构造的代码如下

void add(int id)
	{
		if(trans[last][id]&&ml[trans[last][id]]==ml[last]+1)//changed
		{
			last=trans[last][id];
			return ;
		}
		int x=++sz,p,y;
		bool fl=0;
		ml[x]=ml[last]+1;
		for(p=last;p&&!trans[p][id];p=link[p]) trans[p][id]=x;
		if(!p) link[x]=1;
		else
		{
			int q=trans[p][id];
			if(ml[q]==ml[p]+1) link[x]=q;
			else
			{
				if(ml[p]+1==ml[x]) fl=1;//changed
 				y=++sz;
				ml[y]=ml[p]+1;
				memcpy(trans[y],trans[q],sizeof trans[y]);
				link[y]=link[q];
				for(;p&&trans[p][id]==q;p=link[p]) trans[p][id]=y;
				link[x]=link[q]=y;
			}
		}
		
		if(fl==1) last=y;
		else last=x;
	}

需要注意的是，每次新加进一个串时，要把 $last=1$ ；

与普通 $SAM$ 只多了两个特判；

两个地方都是为了不构建一些不用的节点，第一个地方是利用已经建好了的点，第二个地方是跳过了空节点 $x$

posted @ 2019-12-12 21:17 YudeS楪阅读(626) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 对象命名为何需要避免'-er'和'-or'后缀
· JDK 24 发布，新特性解读！
· C# 中比较实用的关键字，基础高频面试题！
· .NET 10 Preview 2 增强了 Blazor 和.NET MAUI
· SQL Server如何跟踪自动统计信息更新?

公告

昵称： YudeS楪
园龄： 5年3个月
粉丝： 4
关注： 3

+加关注

2025年3月

日

一

二

三

四

五

六

YudeS楪

创造1024

后缀自动机的一些应用

后缀自动机的应用

本质不同子串的个数

统计子串出现次数

两个串的最长公共子串

多个串的最长公共子串

1 O(nk^2)

2 O(nk)

字典序第k大子串

长度为k的子串的最大出现次数

所有前缀的最长公共后缀和

拓展：广义后缀自动机简介

公告

搜索

常用链接

我的标签

积分与排名

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论