文章目錄

• 后綴自動機
• 算法實現過程
• 模板
• 習題
• • 洛谷后綴自動機模板題
  • 品酒大會
  • [HEOI2015]最短不公共子串
  • 字符串

蒟蒻寫這篇$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$表示后綴自動機的最后一個節點
  
  Ⅱ 將${}^{\prime }{a}^{\prime }$扔進去，新建一個節點$cnt=2$，$len=len[last]+1=1$
  從$last$開始跳，發現$1$沒有${}^{\prime }{a}^{\prime }$邊
  則建立一條${}^{\prime }{a}^{\prime }$邊，并指向新點$2$
  此時跳到了初始源點，$2$的后綴鏈接只能指向$1$，$last$變為$2$
  
  Ⅲ 將${}^{\prime }{b}^{\prime }$扔進去，新建一個節點$cnt=3,len=len[last]+1=2$
  從$last$開始跳后綴鏈接
  $2$沒有${}^{\prime }{b}^{\prime }$邊，新建一條并指向$3$，跳后綴鏈接到$1$
  $1$沒有${}^{\prime }{b}^{\prime }$邊，新建一條并指向$3$
  此時已經到了根節點，$3$的后綴鏈接只能指向$1$，$last=3$
  
  Ⅳ 將${}^{\prime }{c}^{\prime }$扔進去，新建一個節點$cnt=4,len=3$
  從$last$開始跳后綴鏈接
  $3$沒有${}^{\prime }{c}^{\prime }$邊，新建一條并指向$4$，跳后綴鏈接到$1$
  $1$沒有${}^{\prime }{c}^{\prime }$邊，新建一條并指向$4$
  此時已經到了根節點，$4$的后綴鏈接只能指向$1$，$last=4$
  Ⅴ 將${}^{\prime }{d}^{\prime }$扔進去，新建一個節點$cnt=5,len=4$
  從$last$開始跳后綴鏈接
  $4$沒有${}^{\prime }{c}^{\prime }$邊，新建一條并指向$5$，跳后綴鏈接到$1$
  $1$沒有${}^{\prime }{c}^{\prime }$邊，新建一條并指向$5$
  此時已經到了根節點，$5$的后綴鏈接只能指向$1$，$last=5$
  
  最簡單的一種后綴自動機就完成了
  接下來就嘗試一下進階版

---

• $e.g.2$，構建$ababe$的后綴自動機
  Ⅰ先搭建空源點，$last=1$
  
  Ⅱ 加入${}^{\prime }{a}^{\prime }$，新建一個節點$cnt=2,len[2]=len[last]+1=1$
  $1$沒有${}^{\prime }{c}^{\prime }$邊，新建一條并指向$2$，
  此時已經到了根節點，$2$的后綴鏈接只能指向$1$，$last=2$
  
  Ⅲ 加入${}^{\prime }{b}^{\prime }$，新建一個節點$cnt=3,len[3]=len[last]+1=2$
  從$last$開始跳后綴鏈接
  $2$沒有${}^{\prime }{b}^{\prime }$邊，新建一條并指向$3$，跳后綴鏈接到$1$
  $1$沒有${}^{\prime }{b}^{\prime }$邊，新建一條并指向$3$
  此時已經到了根節點，$3$的后綴鏈接只能指向$1$，$last=3$
  
  Ⅳ 再加入${}^{\prime }{a}^{\prime }$，新建一個節點$cnt=4,len[4]=len[last]+1=3$
  從$last$開始跳后綴鏈接
  $3$沒有${}^{\prime }{a}^{\prime }$邊，新建一條并指向$4$，跳后綴鏈接到$1$
  $1$有一條指向$2$的${}^{\prime }{a}^{\prime }$邊，滿足$len[2]=len[1]+1$，則直接將$4$后綴鏈接指向$2$
  結束，$last=4$
  
  Ⅴ 再加入${}^{\prime }{b}^{\prime }$，新建一個節點$cnt=5,len[5]=len[last]+1=4$
  從$last$開始跳后綴鏈接
  $4$沒有${}^{\prime }{b}^{\prime }$邊，新建一條并指向$5$，跳后綴鏈接到$2$
  $2$有一條指向$3$的${}^{\prime }{b}^{\prime }$邊，滿足$len[3]=len[2]+1$，直接將$5$后綴鏈接指向$3$
  結束，$last=5$
  
  Ⅵ 加入新${}^{\prime }{c}^{\prime }$，新建一個節點$cnt=6,len[6]=len[last]+1=5$
  從$last$開始跳后綴鏈接
  $5$沒有${}^{\prime }{c}^{\prime }$邊，新建一條并指向$6$，跳后綴鏈接到$3$
  $3$沒有${}^{\prime }{c}^{\prime }$邊，新建一條并指向$6$，跳后綴鏈接到$1$
  $1$沒有${}^{\prime }{c}^{\prime }$邊，新建一條并指向$6$
  此時已到根節點，$6$只能鏈接$1$，$last=6$結束
  這就是進階版了，沒有涉及到最終版的點復制
  最后讓我們一起攜手走進最終版的后綴自動機構造

---

• $e.g.3$，構建$cabab$的后綴自動機
  Ⅰ 創造新源點，$last=1,cnt=1$
  
  Ⅱ 加入${}^{\prime }{c}^{\prime }$，新建一個節點$cnt=2,len[2]=len[last]+1=1$
  從$last$開始跳后綴鏈接
  $1$沒有${}^{\prime }{c}^{\prime }$邊，新建一條并指向$2$
  此時已到根節點，$2$只能鏈接$1,last=2$
  
  Ⅲ 加入${}^{\prime }{a}^{\prime }$，新建一個節點$cnt=3,len[3]=len[last]+1=2$
  從$last$開始跳后綴鏈接
  $2$沒有${}^{\prime }{a}^{\prime }$邊，新建一條并指向$3$，跳后綴鏈接到$1$
  $1$沒有${}^{\prime }{a}^{\prime }$邊，新建一條并指向$3$
  此時已到根節點，$3$只能鏈接$1,last=3$
  
  Ⅳ 加入${}^{\prime }{b}^{\prime }$，新建一個節點$cnt=4,len[4]=len[last]+1=3$
  從$last$開始跳后綴鏈接
  $3$沒有${}^{\prime }{b}^{\prime }$邊，新建一條并指向$4$，跳后綴鏈接到$1$
  $1$沒有${}^{\prime }{a}^{\prime }$邊，新建一條并指向$4$
  此時已到根節點，$4$只能鏈接$1,last=4$
  
  Ⅴ 加入${}^{\prime }{a}^{\prime }$，新建一個節點$cnt=5,len[5]=len[last]+1=4$
  從$last$開始跳后綴鏈接
  $4$沒有${}^{\prime }{a}^{\prime }$邊，新建一條并指向$5$，跳后綴鏈接到$1$
  $1$有${}^{\prime }{a}^{\prime }$邊，指向$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$
  
  Ⅵ 加入${}^{\prime }{b}^{\prime }$，新建節點$cnt=7$
  從$last$開始跳后綴鏈接
  $5$沒有${}^{\prime }{b}^{\prime }$邊，新建一條指向$7$，跳后綴鏈接到$6$
  $6$有一條${}^{\prime }{b}^{\prime }$邊，指向$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+1t[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$的最長公共后綴$=parenttree$上前綴$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$的子串之間如何一一對應修改
這個時候如果將其放到$parenttree$上考慮的話，就簡單了

其實可以猜想一下，剛開始我就想到了虛樹的性質，即相鄰兩兩配對
不難證明，的確應該相鄰兩個不同屬類的子串配對

前綴$i,j$的最長公共后綴$=parenttree$上前綴$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; }

總結

以上是生活随笔為你收集整理的后缀自动机（SAM）构造实现过程演示+习题集锦的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。