后缀自动机（SAM）构造实现过程演示+习题集锦
蒟蒻写这篇\(blog\)主要是存一下，后缀自动机的详细搭建过程，方便以后复习
具体的某些证明，为什么这么做，正确性劈里啪啦一大堆就不赘述了讲解指路☞
后缀自动机
后缀自动机上每一条到\(i\)的路径对应一个子串，整个自动机包含了字符串的所有子串
很多时候可以和后缀数组等价使用
\(endpos\)：一个子串\(i\)在整个字符串中出现的位置 最后一个字符的下标 构成的集合
举个栗子 \(abcbcdeabc\)，(从\(0\)开始标号)
子串\(abc\)对应的\(endpos\)为\(\{2,9\}\)，子串\(bc\)的\(endpos\)为\(\{2,4,9\}\)
后缀自动机的编号对应的就是\(endpos\)完全相同的所有子串
依旧是上面的粒子\(abcbcdeabc\)
子串\(bc\)的\(endpos\)为\(\{2,4,9\}\)，子串\(c\)的\(endpos\)也为\(\{2,4,9\}\)
那么后缀自动机上对应的\(id\)编号既表示\(bc\)子串，也表示\(c\)子串
算法实现过程
- \(e.g.1\)，构建\(abcd\)的后缀自动机
Ⅰ最初始状态，仅有一个空根，\(last=1\)，\(last\)表示后缀自动机的最后一个节点
Ⅱ 将\('a'\)扔进去，新建一个节点\(cnt=2\)，\(len=len[last]+1=1\)
从\(last\)开始跳，发现\(1\)没有\('a'\)边
则建立一条\('a'\)边，并指向新点\(2\)
此时跳到了初始源点，\(2\)的后缀链接只能指向\(1\)，\(last\)变为\(2\)
Ⅲ 将\('b'\)扔进去，新建一个节点\(cnt=3,len=len[last]+1=2\)
从\(last\)开始跳后缀链接
\(2\)没有\('b'\)边，新建一条并指向\(3\)，跳后缀链接到\(1\)
\(1\)没有\('b'\)边，新建一条并指向\(3\)
此时已经到了根节点，\(3\)的后缀链接只能指向\(1\)，\(last=3\)
Ⅳ 将\('c'\)扔进去，新建一个节点\(cnt=4,len=3\)
从\(last\)开始跳后缀链接
\(3\)没有\('c'\)边，新建一条并指向\(4\)，跳后缀链接到\(1\)
\(1\)没有\('c'\)边，新建一条并指向\(4\)
此时已经到了根节点，\(4\)的后缀链接只能指向\(1\)，\(last=4\)
Ⅴ 将\('d'\)扔进去，新建一个节点\(cnt=5,len=4\)
从\(last\)开始跳后缀链接
\(4\)没有\('c'\)边，新建一条并指向\(5\)，跳后缀链接到\(1\)
\(1\)没有\('c'\)边，新建一条并指向\(5\)
此时已经到了根节点，\(5\)的后缀链接只能指向\(1\)，\(last=5\)
最简单的一种后缀自动机就完成了
接下来就尝试一下进阶版
- \(e.g.2\)，构建\(ababe\)的后缀自动机
Ⅰ先搭建空源点，\(last=1\)
Ⅱ 加入\('a'\)，新建一个节点\(cnt=2,len[2]=len[last]+1=1\)
\(1\)没有\('c'\)边，新建一条并指向\(2\)，
此时已经到了根节点，\(2\)的后缀链接只能指向\(1\)，\(last=2\)
Ⅲ 加入\('b'\)，新建一个节点\(cnt=3,len[3]=len[last]+1=2\)
从\(last\)开始跳后缀链接
\(2\)没有\('b'\)边，新建一条并指向\(3\)，跳后缀链接到\(1\)
\(1\)没有\('b'\)边，新建一条并指向\(3\)
此时已经到了根节点，\(3\)的后缀链接只能指向\(1\)，\(last=3\)
Ⅳ 再加入\('a'\)，新建一个节点\(cnt=4,len[4]=len[last]+1=3\)
从\(last\)开始跳后缀链接
\(3\)没有\('a'\)边，新建一条并指向\(4\)，跳后缀链接到\(1\)
\(1\)有一条指向\(2\)的\('a'\)边，满足\(len[2]=len[1]+1\)，则直接将\(4\)后缀链接指向\(2\)
结束，\(last=4\)
Ⅴ 再加入\('b'\)，新建一个节点\(cnt=5,len[5]=len[last]+1=4\)
从\(last\)开始跳后缀链接
\(4\)没有\('b'\)边，新建一条并指向\(5\)，跳后缀链接到\(2\)
\(2\)有一条指向\(3\)的\('b'\)边，满足\(len[3]=len[2]+1\)，直接将\(5\)后缀链接指向\(3\)
结束，\(last=5\)
Ⅵ 加入新\('c'\)，新建一个节点\(cnt=6,len[6]=len[last]+1=5\)
从\(last\)开始跳后缀链接
\(5\)没有\('c'\)边，新建一条并指向\(6\)，跳后缀链接到\(3\)
\(3\)没有\('c'\)边，新建一条并指向\(6\)，跳后缀链接到\(1\)
\(1\)没有\('c'\)边，新建一条并指向\(6\)
此时已到根节点，\(6\)只能链接\(1\)，\(last=6\)结束
这就是进阶版了，没有涉及到最终版的点复制
最后让我们一起携手走进最终版的后缀自动机构造
- \(e.g.3\)，构建\(cabab\)的后缀自动机
Ⅰ 创造新源点，\(last=1,cnt=1\)
Ⅱ 加入\('c'\)，新建一个节点\(cnt=2,len[2]=len[last]+1=1\)
从\(last\)开始跳后缀链接
\(1\)没有\('c'\)边，新建一条并指向\(2\)
此时已到根节点，\(2\)只能链接\(1,last=2\)
Ⅲ 加入\('a'\)，新建一个节点\(cnt=3,len[3]=len[last]+1=2\)
从\(last\)开始跳后缀链接
\(2\)没有\('a'\)边，新建一条并指向\(3\)，跳后缀链接到\(1\)
\(1\)没有\('a'\)边，新建一条并指向\(3\)
此时已到根节点，\(3\)只能链接\(1,last=3\)
Ⅳ 加入\('b'\)，新建一个节点\(cnt=4,len[4]=len[last]+1=3\)
从\(last\)开始跳后缀链接
\(3\)没有\('b'\)边，新建一条并指向\(4\)，跳后缀链接到\(1\)
\(1\)没有\('a'\)边，新建一条并指向\(4\)
此时已到根节点，\(4\)只能链接\(1,last=4\)
Ⅴ 加入\('a'\)，新建一个节点\(cnt=5,len[5]=len[last]+1=4\)
从\(last\)开始跳后缀链接
\(4\)没有\('a'\)边，新建一条并指向\(5\)，跳后缀链接到\(1\)
\(1\)有\('a'\)边，指向\(3\)，但是！！！\(len[3]≠len[1]+1\)，不能像进阶版直接链接，这里必须要点复制
新建一个\(3\)的分身节点\(cnt=6\)
\(3\)的所有信息（出入边）除了原字符串间的边（图中黑色边）全部修改为分点\(6\)的边，直接覆盖
并且\(6\)成为\(3\)的直接后缀链接，替代\(1\)
\(len[6]=len[1]+1=1\)
相当于\(6\)做了\(1,3\)后缀链之间的承接点，保证了每一条边上\(len\)只会带来\(+1\)的影响
\(5\)直接链接\(6\)后结束，\(last=5\)
Ⅵ 加入\('b'\)，新建节点\(cnt=7\)
从\(last\)开始跳后缀链接
\(5\)没有\('b'\)边，新建一条指向\(7\)，跳后缀链接到\(6\)
\(6\)有一条\('b'\)边，指向\(4\)，判断\(len[4]≠len[6]+1\)
再次执行复制操作
新建一个\(4\)的分身节点\(cnt=8\)
\(4\)的所有信息（出入边）除了原字符串间的边（图中黑色边）全部修改为分点\(8\)的边，直接进行覆盖
\(8\)成为\(4\)的直接后缀链接，\(len[8]=len[6]+1=2\)
\(7\)直接链接\(8\)后结束，\(last=7\)
⚡
\(len[x]\)复制点的\(len\)不等于被复制点的原后缀链接的\(len+1\)，而是谁触发的\(len+1\)
模板
struct node {
int len; //长度
int fa; //后缀链接
int son[maxc]; //字符集大小
}t[maxn];
模拟从主链的前一个开始跳后缀链接，并对于链接上的没有该字符边的每一个点都连出一条新字符边
while( pre && ! t[pre].son[c] ) t[pre].son[c] = now, pre = t[pre].fa;
跳到根，代表这是首个出现的字符，他只能链接最初的根节点了
if( ! pre ) t[now].fa = 1;
否则，如果路上找到了，满足\(len\)的关系，直接后缀链接指过去即可
int u = t[pre].son[c];
if( t[u].len == t[pre].len + 1 ) t[now].fa = u;
复制该点，并进行有关该点的所有信息重改
①原点连出的点，新点也要连出
②连入原点的点，变成连入新点
③原点和新点间也需建立联系，新点是原点的后缀链接
else {
int v = ++ tot;
t[v] = t[u];//利用结构体巧妙将原点连出的点进行复制
t[v].len = t[pre].len + 1;//由谁触发 len就是触发点len+1
t[u].fa = t[now].fa = v;//原点与复制点与新建点的关系
while( pre && t[pre].son[c] == u ) t[pre].son[c] = v, pre = t[pre].fa;//暴力复制修改连入原点的点
}
习题
洛谷后缀自动机模板题
- code
#include <cstdio>
#include <vector>
#include <cstring>
using namespace std;
#define maxn 2000005
vector < int > G[maxn];
struct node {
int fa, len;
int son[30];
}t[maxn];
char s[maxn];
int last = 1, tot = 1;
long long ans;
int siz[maxn];
void insert( int c ) {
int pre = last, now = last = ++ tot;
siz[tot] = 1;
t[now].len = t[pre].len + 1;
while( pre && ! t[pre].son[c] ) t[pre].son[c] = now, pre = t[pre].fa;
if( ! pre ) t[now].fa = 1;
else {
int u = t[pre].son[c];
if( t[u].len == t[pre].len + 1 ) t[now].fa = u;
else {
int v = ++ tot;
t[v] = t[u];
t[v].len = t[pre].len + 1;
t[u].fa = t[now].fa = v;
while( pre && t[pre].son[c] == u ) t[pre].son[c] = v, pre = t[pre].fa;
}
}
}
void dfs( int u ) {
for( int i = 0;i < G[u].size();i ++ ) {
int v = G[u][i];
dfs( v );
siz[u] += siz[v];
}
if( siz[u] != 1 ) ans = max( ans, 1ll * siz[u] * t[u].len );
}
int main() {
scanf( "%s", s );
int len = strlen( s );
for( int i = 0;i < len;i ++ ) insert( s[i] - 'a' );
for( int i = 2;i <= tot;i ++ ) G[t[i].fa].push_back( i );
dfs( 1 );
printf( "%lld", ans );
return 0;
}
品酒大会
- solution
有一个\(SAM\)常用结论：前缀\(i,j\)的最长公共后缀\(=parent\ tree\)上前缀\(i,j\)分别指向的点\(u,v\)的\(lca\)反映在后缀自动机上的节点代表的最长子串
将本题的字符串倒过来建后缀自动机，在自动机上进行树上\(dp\)，最后从后往前进行更新即可 - code
#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
using namespace std;
#define inf 0x7f7f7f7f
#define int long long
#define maxn 600005
struct node {
int len, fa;
int son[30];
}t[maxn];
vector < int > G[maxn];
int last = 1, cnt = 1, n;
char s[maxn];
int a[maxn], f[maxn], tot[maxn], siz[maxn], maxx[maxn], minn[maxn];
void insert( int x, int w ) {
int pre = last, now = last = ++ cnt;
siz[now] = 1, t[now].len = t[pre].len + 1;
maxx[now] = minn[now] = w;
while( pre && ! t[pre].son[x] ) t[pre].son[x] = now, pre = t[pre].fa;
if( ! pre ) t[now].fa = 1;
else {
int u = t[pre].son[x];
if( t[u].len == t[pre].len + 1 ) t[now].fa = u;
else {
int v = ++ cnt;
maxx[v] = -inf, minn[v] = inf;
t[v] = t[u];
t[v].len = t[pre].len + 1;
t[u].fa = t[now].fa = v;
while( pre && t[pre].son[x] == u ) t[pre].son[x] = v, pre = t[pre].fa;
}
}
}
bool check( int u ) {
return maxx[u] != -inf && minn[u] != inf;
}
void dfs( int u ) {
for( int i = 0;i < G[u].size();i ++ ) {
int v = G[u][i];
dfs( v );
tot[t[u].len] += siz[u] * siz[v];
siz[u] += siz[v];
if( check( u ) )
f[t[u].len] = max( f[t[u].len], max( maxx[u] * maxx[v], minn[u] * minn[v] ) );
maxx[u] = max( maxx[u], maxx[v] );
minn[u] = min( minn[u], minn[v] );
}
}
signed main() {
memset( f, -0x7f, sizeof( f ) );
scanf( "%d %s", &n, s + 1 );
for( int i = 1;i <= n;i ++ )
scanf( "%lld", &a[i] );
for( int i = n;i;i -- ) insert( s[i] - 'a', a[i] );
for( int i = 2;i <= cnt;i ++ ) G[t[i].fa].push_back( i );
dfs( 1 );
for( int i = n - 1;~ i;i -- ) tot[i] += tot[i + 1], f[i] = max( f[i], f[i + 1] );
for( int i = 0;i < n;i ++ )
printf( "%lld %lld\n", tot[i], ( tot[i] ? f[i] : 0 ) );
return 0;
}
[HEOI2015]最短不公共子串
- solution
做此题需要了解序列自动机
然后就是很无脑的四个\(bfs\)跑
子串就是跑后缀自动机
子序列就是跑序列自动机 - code
#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 5000
char a[maxn], b[maxn];
struct SAM {
struct node {
int len, fa;
int son[30];
}t[maxn];
int last, cnt;
SAM() {
last = cnt = 1;
}
void insert( int x ) {
int pre = last, now = last = ++ cnt;
t[now].len = t[pre].len + 1;
while( pre && ! t[pre].son[x] ) t[pre].son[x] = now, pre = t[pre].fa;
if( ! pre ) t[now].fa = 1;
else {
int u = t[pre].son[x];
if( t[u].len == t[pre].len + 1 ) t[now].fa = u;
else {
int v = ++ cnt;
t[v] = t[u];
t[v].len = t[pre].len + 1;
t[u].fa = t[now].fa = v;
while( pre && t[pre].son[x] == u ) t[pre].son[x] = v, pre = t[pre].fa;
}
}
}
}SamA, SamB;
struct SEQ {
int nxt[maxn][30], last[30];
SEQ() {
memset( nxt, 0, sizeof( nxt ) );
memset( last, 0, sizeof( last ) );
}
void build( int n, char *s ) {
for( int i = n;~ i;i -- ) {
for( int j = 0;j < 26;j ++ )
if( last[j] ) nxt[i + 1][j] = last[j];
if( i ) last[s[i] - 'a'] = i + 1;
}
}
}SeqA, SeqB;
struct node {
int x, y, dep;
node(){}
node( int X, int Y, int Dep ) {
x = X, y = Y, dep = Dep;
}
};
queue < node > q;
bool vis[maxn][maxn];
void init() {
memset( vis, 0, sizeof( vis ) );
while( ! q.empty() ) q.pop();
vis[1][1] = 1, q.push( node( 1, 1, 0 ) );
}
int bfs1() {
init();
while( ! q.empty() ) {
node now = q.front(); q.pop();
for( int i = 0;i < 26;i ++ ) {
int sonA = SamA.t[now.x].son[i];
int sonB = SamB.t[now.y].son[i];
if( vis[sonA][sonB] ) continue;
else if( sonA && ! sonB ) return now.dep + 1;
else if( sonA && sonB ) {
vis[sonA][sonB] = 1;
q.push( node( sonA, sonB, now.dep + 1 ) );
}
}
}
return -1;
}
int bfs2() {
init();
while( ! q.empty() ) {
node now = q.front(); q.pop();
for( int i = 0;i < 26;i ++ ) {
int sonA = SamA.t[now.x].son[i];
int sonB = SeqB.nxt[now.y][i];
if( vis[sonA][sonB] ) continue;
else if( sonA && ! sonB ) return now.dep + 1;
else if( sonA && sonB ) {
vis[sonA][sonB] = 1;
q.push( node( sonA, sonB, now.dep + 1 ) );
}
}
}
return -1;
}
int bfs3() {
init();
while( ! q.empty() ) {
node now = q.front(); q.pop();
for( int i = 0;i < 26;i ++ ) {
int sonA = SeqA.nxt[now.x][i];
int sonB = SamB.t[now.y].son[i];
if( vis[sonA][sonB] ) continue;
else if( sonA && ! sonB ) return now.dep + 1;
else if( sonA && sonB ) {
vis[sonA][sonB] = 1;
q.push( node( sonA, sonB, now.dep + 1 ) );
}
}
}
return -1;
}
int bfs4() {
init();
while( ! q.empty() ) {
node now = q.front(); q.pop();
for( int i = 0;i < 26;i ++ ) {
int sonA = SeqA.nxt[now.x][i];
int sonB = SeqB.nxt[now.y][i];
if( vis[sonA][sonB] ) continue;
else if( sonA && ! sonB ) return now.dep + 1;
else if( sonA && sonB ) {
vis[sonA][sonB] = 1;
q.push( node( sonA, sonB, now.dep + 1 ) );
}
}
}
return -1;
}
int main() {
scanf( "%s %s", a + 1, b + 1 );
int lena = strlen( a + 1 ), lenb = strlen( b + 1 );
for( int i = 1;i <= lena;i ++ )
SamA.insert( a[i] - 'a' );
for( int i = 1;i <= lenb;i ++ )
SamB.insert( b[i] - 'a' );
SeqA.build( lena, a );
SeqB.build( lenb, b );
printf( "%d\n%d\n%d\n%d\n", bfs1(), bfs2(), bfs3(), bfs4() );
return 0;
}
字符串
- solution
这题运用的思想主要是广义后缀自动机，即将多个字符串建在一个后缀自动机上
其实并没有什么新颖之处，只需在扩展的时候带一个这个字符属于哪个字符串的编号即可
假设已经建好了自动机，接下来考虑两个长度为\(k\)的子串之间如何一一对应修改
这个时候如果将其放到\(parent\ tree\)上考虑的话，就简单了
其实可以猜想一下，刚开始我就想到了虚树的性质，即相邻两两配对
不难证明，的确应该相邻两个不同属类的子串配对
前缀\(i,j\)的最长公共后缀\(=parent\ tree\)上前缀\(i,j\)分别指向的点\(u,v\)的\(lca\)反映在后缀自动机上的节点代表的最长子串
也就是最后变成深搜一棵树的模样，记得特判可能\(lca\)代表的最长子串长度\(\ge k\)
此时是不需要代价的
- code
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
#define maxn 600005
struct node {
int len, fa;
int son[30];
}t[maxn];
vector < int > G[maxn];
int n, k, last = 1, cnt = 1;
long long ans;
char a[maxn], b[maxn];
int type[maxn];
int tot[maxn][3];
void insert( int x, int s, int pos ) {
int pre = last, now = last = ++ cnt;
t[now].len = t[pre].len + 1;
while( pre && ! t[pre].son[x] ) t[pre].son[x] = now, pre = t[pre].fa;
if( ! pre ) t[now].fa = 1;
else {
int u = t[pre].son[x];
if( t[u].len == t[pre].len + 1 ) t[now].fa = u;
else {
int v = ++ cnt;
t[v] = t[u];
t[v].len = t[pre].len + 1;
t[u].fa = t[now].fa = v;
while( pre && t[pre].son[x] == u ) t[pre].son[x] = v, pre = t[pre].fa;
}
}
if( pos >= k ) type[now] = s;
}
void dfs( int u ) {
tot[u][type[u]] ++;
for( int i = 0;i < G[u].size();i ++ ) {
int v = G[u][i];
dfs( v );
tot[u][1] += tot[v][1];
tot[u][2] += tot[v][2];
}
if( tot[u][1] >= tot[u][2] ) {
int x = max( 0, k - t[u].len );
ans += 1ll * x * tot[u][2];
tot[u][1] -= tot[u][2];
tot[u][2] = 0;
}
else {
int x = max( 0, k - t[u].len );
ans += 1ll * x * tot[u][1];
tot[u][2] -= tot[u][1];
tot[u][1] = 0;
}
}
int main() {
scanf( "%d %d %s %s", &n, &k, a + 1, b + 1 );
reverse( a + 1, a + n + 1 );
reverse( b + 1, b + n + 1 );
for( int i = 1;i <= n;i ++ ) insert( a[i] - 'a', 1, i );
for( int i = 1;i <= n;i ++ ) insert( b[i] - 'a', 2, i );
for( int i = 2;i <= cnt;i ++ ) G[t[i].fa].push_back( i );
dfs( 1 );
printf( "%lld", ans );
return 0;
}
