[模板] 后缀自动机&&后缀树

后缀自动机

后缀自动机是一种确定性有限状态自动机, 它可以接收字符串$s$的所有后缀.

构造, 性质

翻译自毛子俄罗斯神仙的博客, 讲的很好

后缀自动机详解 - DZYO的博客 - CSDN博客

下面是一些note:

定义

对于字符串$s$的子串$t$, $endpos(t)$ (或者 $right(t)$ ) 表示t在s中出现位置的右端点的集合.
- $endpos$互不相交.
- 有相同 $endpos$ 集合的字符串构成一个等价类.
- 对于每个等价类, 包含的字符串长度为$[len(p), maxlen(p)]$ , 是一个连续的区间.
后缀自动机的节点 $p$ 代表一个 $endpos$ 相同的子串的集合.
对于后缀自动机的节点 $p$, $parent(p)$ (或者 $link(p)$ ) 表示p在不同等价类中的最长后缀.
- $parent$ 形成一棵树关系.
- $len(p) = maxlen(parent(p)) +1$

构建 && 状态数/转移数线性证明

上面的blog已经写的很好了, 我就不重写一遍了:P

示意图

字符串 ab:

其中 * 代表终止节点, 虚箭头表示 $fa(p)$.

字符串 abb:

字符串 bba 的后缀树 (见后), 即字符串 abb 的前缀树/后缀自动机的 parent 树:

Code

const int nsz=1e6+50,ndsz=2*nsz,csz=27;

ll n;

char s[nsz];

//sam

//p.l means maxlen(p)

struct tnd{int ch[csz],l,fa,cnt;}sam[ndsz];

#define ch(p,c) sam[p].ch[c]

#define fa(p) sam[p].fa

int ps=1,las=1;

int cnt[ndsz],c[ndsz],seq[ndsz];

void insert(int c){

	int p=las;

	las=++ps,sam[las].l=sam[p].l+1,cnt[las]=1;

	for(;p&&ch(p,c)==0;p=fa(p))ch(p,c)=las;

	if(p==0)fa(las)=1;

	else{

		int q=ch(p,c);

		if(sam[q].l==sam[p].l+1)fa(las)=q;

		else{

			int q1=++ps;

			sam[q1]=sam[q],sam[q1].l=sam[p].l+1,fa(q)=fa(las)=q1;

			for(;p&&ch(p,c)==q;p=fa(p))ch(p,c)=q1;

		}

	}

}

void build(){

	rep(i,1,n)insert(s[i]-'a');

}

struct te{int t,pr;}edge[ndsz];

int hd[ndsz],pe=1;

void adde(int f,int t){edge[++pe]=(te){t,hd[f]};hd[f]=pe;}

void buildtr(){

	rep(i,2,ps)adde(fa(i),i);

}

void gettp(){ //topo sort

	rep(i,1,ps)++c[sam[i].l];

	rep(i,1,ps)c[i]+=c[i-1];

	rep(i,1,ps)seq[c[sam[i].l]--]=i;

}

void match(char *s,int n){

	int cur=1,l=0;

	rep(i,1,n){

		if(ch(cur,s[i])){++l,cur=ch(cur,s[i]);}

		else{

			while(cur&&ch(cur,s[i])==0)cur=fa(cur);

			if(cur==0)l=0,cur=1;

			else l=sam[cur].l+1,cur=ch(cur,s[i]);

		}

	}

}

后缀树

后缀树是对字符串 $S$ 的所有后缀建立的trie树, 同样可以识别 $S$ 的所有后缀.

为了节省空间, 可以利用虚树的思想. 我们把只有一个子节点的节点压缩到它的父亲, 也就是说, 把没有分叉的一条链压缩成一条边.

显然, 这样建成的后缀 trie 只会保留每个后缀的终止节点('\0'), 和他们的lca. 这两者数量都是 $O(n)$ 的, 因此状态总数也为 $O(n)$ .

同时, 字符串 $S$ 后缀自动机的parent树等价于 $S$ 逆序 $S'$ 的后缀树, 可以称作前缀树. 证明见[3].

几个关键问题

在后缀自动机上走路的时间复杂度

23333

就是说对字符串 $S$ 建立后缀自动机, 然后将字符串 $T$ 从起点走转移边, 如果没有转移边则跳parent指针. 这样可以求出 $S$ 与 $T$ 的每一个公共子串.

记当前 $S$ 与 $T$ 的匹配长度为 $l$. 对于每一次转移, $l$ 会加 $1$; 对于跳parent指针, $l$ 会减少, 而 $l$ 总的减少不会超过 $|T|$. 因此总时间复杂度为 $O(|T|)$.

事实上, 对于insert(c)的均摊时间复杂度的分析是类似的.

代码

//l : max len of current matched string

//p : current state

void match(char *s,int n){

	int cur=1,l=0;

	rep(i,1,n){

		if(ch(cur,s[i])){++l,cur=ch(cur,s[i]);}

		else{

			while(cur&&ch(cur,s[i])==0)cur=fa(cur);

			if(cur==0)l=0,cur=1;

			else l=sam[cur].l+1,cur=ch(cur,s[i]);

		}

	}

}

拓扑序

from [2]

SAM 中的 DAWG 满足一个性质，如果有一条转移边 $u \rightarrow v$ ，则一定有 $|\max(u)| < |\max(v)|$。类似的，如果 $\text{next}(v) = u$，也有 $|\max(u)| < |\max(v)|$。所以，按照每个节点记录的 max 长度排序，可以同时得到 DAWG 和前缀树的拓扑序。

使用桶排序, 那么时间复杂度是$O(n)$.

代码

void gettp(){ //topo sort

	rep(i,1,ps)++c[sam[i].l];

	rep(i,1,ps)c[i]+=c[i-1];

	rep(i,1,ps)seq[c[sam[i].l]--]=i;

}

这样我们就可以在SAM上进行动态规划.

每个节点代表字符串个数

由定义可知,

节点 $p$ 代表字符串个数 $ = maxlen(p)-len(p)+1 = maxlen(p)-maxlen(parent(p))$.

同时, 节点 $p$ 代表字符串个数 = 起点到节点 $p$ 路径数.

求endpos集合

记非拷贝而来的节点为实节点, 否则为虚节点.

当实节点为第 $t$ 个字符加入时建立的时, 它的endpos集合中显然有 $t$, 并且它是endpos集合中有 $t$ 的节点中maxlen最大的.

那么它的parent节点显然也包含$t$, 直接跳parent()即可.

这时我们可以O(n)的求出endpos集合的大小:

对于不是拷贝的节点, cnt设为1; 拷贝而来的节点, cnt设为0.
在parent树上dp, $cnt_p+=\sum_{parent(v)=p} cnt_v$.
$cnt_p$ 表示这个节点endpos集合大小, 也就是在字符串中的出现次数.

如果要求endpos集合, 需要可合并数据结构 (线段树/set/堆等). 利用可持久化线段树合并 ([模板] 线段树合并) 可以求出所有点的 endpos 集合.

最小表示法

建立$S+S$的后缀自动机, 从起点开始, 每次走字典序最小的转移, 并记录.

转移 $|S|$ 次之后, 得到的字符串即为 $S$ 的最小表示.

后缀自动机的用法

拓扑序 dp (自动机上/parent树上)
利用 len 函数和 endpos 集合 (dp, 线段树合并等)
利用 parent 树
- 树上的技巧: lca, 倍增, 点分治, 树剖, LCT
- dp(自上向下, 自下向上, 双重, 倍增)
利用自动机的性质 (转移等)

参考资料