后缀自动机总结

最新推荐文章于 2020-12-31 09:55:43 发布
原创 最新推荐文章于 2020-12-31 09:55:43 发布 · 1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

本文分享了作者学习和实践后缀自动机的经验，详细解析了几道典型题目，包括最长公共子串、子串出现次数统计等，展示了如何通过后缀自动机高效解决问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

后缀自动机总结

很长时间没写过博客了，该写写了。

最近一直在学习和练习后缀自动机，总体的感觉还不错。
后缀自动机只有一个关键函数—-就是建树（但是匹配好难想）。
后缀自动机的每一个节点都代表着一个后缀，所有的后缀在后缀自动机上都可以匹配。
后缀自动机中，fa[]与AC自动机的fail指针作用似乎是相同的。
后缀自动机中，很多题目中都用到了基数排序（以maxlen排序相当于拓扑排序）。
至于算法的学习，自己去看博客吧！传送门

总结一下所写的题目：

SPOJ1811

题意:一个串和另一个串中的最长公共子串。

这道题算是入门题

我对于这道题到是没什么想法（可能是初学），写了个模板却不会匹配。。。
其实，还是比较简单，只需将一个串建自动机，一个串进行匹配即可，失配了就回退，直到可以匹配，并修改len值。否则就++len，当ans<len，时更新答案。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#define For(aa,bb,cc) for(int aa=bb;aa<=cc;++aa)
#define Set(aa,bb) memset(aa,bb,sizeof(aa))
using namespace std;
const int maxn=500010;
int lena,lenb,last;
char a[maxn],b[maxn];
int tot,st[maxn][26],dis[maxn],fa[maxn];

void init(){tot=last=1;}

void add(int pos){
    int x=a[pos]-'a',p=last,np=++tot;
    last=np,dis[np]=pos;
    for(;p && !st[p][x];p=fa[p]) st[p][x]=np;
    if(!p) fa[np]=1;
    else{
        int q=st[p][x];
        if(dis[q]==dis[p]+1) fa[np]=q;
        else{
            int nq=++tot;
            dis[nq]=dis[p]+1;
            For(i,0,25) st[nq][i]=st[q][i];
            fa[nq]=fa[q],fa[np]=fa[q]=nq;
            for(;st[p][x]==q;p=fa[p]) st[p][x]=nq;
        }
    }
}

int main(){
    init();
    scanf("%s%s",a+1,b+1);
    lena=strlen(a+1),lenb=strlen(b+1);
    For(i,1,lena) add(i);
    int ans=0,len=0,p=1;
    For(i,1,lenb){
        int x=b[i]-'a';
        if(st[p][x]) ++len,p=st[p][x];
        else{
            while(p && !st[p][x]) p=fa[p];
            if(!p) p=1,len=0;
            else len=dis[p]+1,p=st[p][x];
        }
        if(ans<len) ans=len;
    }
    printf("%d\n",ans);
}

SPOJ8222

题意：
对于一个字符串S，找出长度从1到len(S)的每一个长度的一个子串出现次数最多的次数。

这是我觉的这是让我印象最深的一道题。

主要思路：
    对于后缀自动机而言，有两个DAG，一个是parent树，一个是trans树，trans树是原串的所有后缀，parent树是原串的反串的所有后缀。
    而题目所需要求的，便是对于每一个子串，能够从这个点到root的路径的方案数，所以有以下两种方法。
    1.从trans树中找到对于的right（S）集合的大小。
    2.从parent树中来解决。（当然我是用第二种）--||。
    先将原树中的后缀先标记出来，a[]=1，但是我们并没有将原树中的所有儿子记录下来，所以可以通过一个神奇的性质--儿子节点的len一定大于父亲节点的len，我们就可以用len值进行从大到小排序，然后，用当前点来更新fa。
    3.节点代表的是一个区间的长度，但是长串这个节点出现了，则短串一定会出现，所以就先只考虑最长的长度，然后再用长串更新短串。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<cstdlib>
#define For(aa,bb,cc) for(int aa=bb;aa<=(int)cc;++aa)
#define Set(aa,bb) memset(aa,bb,sizeof(aa))
#define Forr(aa,bb,cc) for(int aa=bb;aa>=(int)cc;--aa)
using namespace std;
const int maxn=500000+10;
char s[maxn];
int last,tot,len,maxlen[maxn],tree[maxn][26],fa[maxn];
int a[maxn],b[maxn],c[maxn],f[maxn];

inline void init(){ last=tot=1; }

void add_char(int pos){
    int np=++tot,p=last,x=s[pos]-'a';
    last=np;maxlen[np]=pos;
    for(;p && !tree[p][x];p=fa[p]) tree[p][x]=np;
    if(!p) fa[np]=1;
    else{
        int q=tree[p][x];
        if(maxlen[q]==maxlen[p]+1) fa[np]=q;
        else{
            int nq=++tot;
            maxlen[nq]=maxlen[p]+1;
            For(i,0,25) tree[nq][i]=tree[q][i];
            fa[nq]=fa[q];fa[q]=fa[np]=nq;
            for(;tree[p][x]==q;p=fa[p]) tree[p][x]=nq;
        }
    }
}

void sort_s(){
    For(i,1,tot) ++b[maxlen[i]];
    For(i,1,len) b[i]+=b[i-1];
    For(i,1,tot) c[b[maxlen[i]]--]=i;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
#endif
    init();
    scanf("%s",s+1);
    len=strlen(s+1);
    For(i,1,len) add_char(i);
    int p=1;
    For(i,1,len) p=tree[p][s[i]-'a'],++a[p];
    sort_s();
    Forr(i,tot,1) a[fa[c[i]]]+=a[c[i]];
    For(i,1,tot) f[maxlen[i]]=max(f[maxlen[i]],a[i]);
    Forr(i,len,1) f[i]=max(f[i],f[i+1]);
    For(i,1,len) printf("%d\n",f[i]);
    return 0;
}

POJ1509

题意：
    一个字符串，求以它的哪一个位置开始的字典序最小。

这一题比较简单。

1.最小表示法，裸题。不做说明。

2.后缀自动机：

    将字符串复制1次，加到后面，以此时的len建立自动机。它的巧妙之处便是这个。然后贪心的选取长度为原串的子串，此时就可以得到答案。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define For(aa,bb,cc) for(int aa=bb;aa<=(int)cc;++aa)
#define Forr(aa,bb,cc) for(int aa=bb;aa>=(int)cc;--aa)
#define Set(aa,bb) memset(aa,bb,sizeof(aa))
using namespace std;
const int maxn=50010;
int n;
char s[maxn];
int st[maxn][26],fa[maxn],maxlen[maxn],last,tot;

void init(){
    last=tot=1;Set(st,0),Set(maxlen,0),Set(fa,0);
}

void add_char(int pos){
    int x=s[pos]-'a',p=last,np=++tot;
    last=np;maxlen[np]=pos;
    for(;p && !st[p][x];p=fa[p]) st[p][x]=np;
    if(!p) fa[np]=1;
    else{
        int q=st[p][x];
        if(maxlen[q]==maxlen[p]+1) fa[np]=q;
        else{
            int nq=++tot;
            maxlen[nq]=maxlen[p]+1;
            For(i,0,25) st[nq][i]=st[q][i];
            fa[nq]=fa[q],fa[q]=fa[np]=nq;
            for(;st[p][x]==q;p=fa[p]) st[p][x]=nq;
        }
    }
}

int main(){
    int _;
    scanf("%d",&_);
    while(_--){
        init();
        scanf("%s",s+1);
        int len=strlen(s+1);
        For(i,1,len) s[i+len]=s[i];
        For(i,1,2*len) add_char(i);
        int u=1;
        For(i,1,len)
            For(j,0,25) 
                if(st[u][j]){ u=st[u][j];break; }
        printf("%d\n",maxlen[u]-len+1);
    }
    return 0;
}

hdu4436
题意：求一串数字的所有子串和。
感悟：
本题是后缀自动机的一个经典题型，它主要的思路是利用每一个节点与父亲节点的差距就是在后边增加了一个字符。所以，对于本题而言，这个的大小是父亲节点*10+这个节点的值，利用这个性质，可以得到一个巧妙的计算方法。从这个节点开始的儿子的个数，即路径的条数cnt,将父亲的权值*10*cnt加上所有新加的点的权值和。统计所有的，即为答案。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#define For(aa,bb,cc) for(int aa=(bb);aa<=(int)(cc);++aa)
#define Set(aa,bb) memset(aa,bb,sizeof(aa))
using namespace std;
const int maxn=4e5+10,mod=2012;
int n,len,last,tot;
int maxlen[maxn],tree[maxn][11],fa[maxn];
char s[maxn];
int sum[maxn],id[maxn];
int road[maxn],tmp[maxn];

inline void init(){ last=tot=1,len=0; }

void add_char(int pos,int x){
    int p=last,np=++tot;last=np;
    maxlen[np]=pos;
    for(;p && !tree[p][x];p=fa[p]) tree[p][x]=np;
    if(!p) fa[np]=1;
    else{
        int q=tree[p][x];
        if(maxlen[q]==maxlen[p]+1) fa[np]=q;
        else{
            int nq=++tot;
            maxlen[nq]=maxlen[p]+1;
            For(i,0,10) tree[nq][i]=tree[q][i];
            fa[nq]=fa[q],fa[q]=fa[np]=nq;
            for(;tree[p][x]==q;p=fa[p]) tree[p][x]=nq;
        }
    }
}

int main(){
    while(~scanf("%d",&n)){
        init();
        while(n--){
            scanf("%s",s+1);
            for(int i=1;s[i];++i) add_char(++len,s[i]-'0');
            add_char(++len,10);
        }
        Set(sum,0);
        For(i,1,tot) ++sum[maxlen[i]];
        For(i,1,len) sum[i]+=sum[i-1];
        For(i,1,tot) id[sum[maxlen[i]]--]=i;
        road[1]=1,tmp[1]=0;
        int ans=0;
        For(i,1,tot){
            int p=id[i],q;
            For(j,0,9){
                if(i==1 && j==0) continue;
                if(tree[p][j]){
                    q=tree[p][j];
                    road[q]=(road[q]+road[p])%mod;
                    tmp[q]=(tmp[q]+tmp[p]*10+road[p]*j)%mod;
                }
            }
            ans=(ans+tmp[p])%mod;
        }
        printf("%d\n",ans);
        For(i,1,tot) road[i]=tmp[i]=maxlen[i]=id[i]=fa[i]=0,Set(tree[i],0);
    }
    return 0;
}

SPOJ1812
题意：n个字符串的LCS。
感悟：
这道题，是我学习基数排序的开始，将每一个节点在的拓扑序给记录了下来，可以通过每个节点的含义，来进行一些操作。对于一个串，建立后缀自动机，然后拿其他的串在上面进行匹配，需要记录当前的串匹配的最长长度和前面所有串匹配的最长长度的最短长度。更新时倒过来，从长度大的更新到长度小的，因为它的后缀出现的次数一定大于等于它的出现次数，并且它的拓扑排序后，深度大的节点，编号大。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define For(aa,bb,cc) for(int aa=bb;aa<=(int)cc;++aa)
#define Forr(aa,bb,cc) for(int aa=bb;aa>=(int)cc;--aa)
using namespace std;
const int maxn=2e5+10,inf=0x3f3f3f3f;
int tot,last,len,tree[maxn][26],fa[maxn],maxlen[maxn];
char s[maxn],ss[maxn];
int ans[maxn],tmp[maxn],id[maxn],sum[maxn];

inline void init(){
    tot=last=1;
    For(i,0,25) tree[0][i]=1;
    maxlen[0]=-1;
}

void add_char(int pos){
    int np=++tot,p=last,x=s[pos]-'a';
    maxlen[np]=pos;
    for(;p && !tree[p][x];p=fa[p]) tree[p][x]=np;
    if(!p) fa[np]=1;
    else{
        int q=tree[p][x];
        if(maxlen[q]==maxlen[p]+1) fa[np]=q;
        else{
            int nq=++tot;
            maxlen[nq]=maxlen[p]+1;
            For(i,0,25) tree[nq][i]=tree[q][i];
            fa[nq]=fa[q],fa[q]=fa[np]=nq;
            for(;tree[p][x]==q;p=fa[p]) tree[p][x]=nq;
        }
    }
    last=np;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
#endif
    init();
    scanf("%s",s+1);
    len=strlen(s+1);
    For(i,1,len) add_char(i);
    For(i,1,tot) ++sum[maxlen[i]];
    For(i,1,len) sum[i]+=sum[i-1];
    For(i,1,tot) id[sum[maxlen[i]]--]=i;
    For(i,1,tot) ans[i]=inf;
    while(scanf("%s",ss+1)!=EOF){
        len=strlen(ss+1);
        int p=1,now=0;
        For(i,1,len){
            int x=ss[i]-'a';
            for(;!tree[p][x];p=fa[p]) now=maxlen[fa[p]];
            p=tree[p][x];
            tmp[p]=max(tmp[p],++now);
        }
        Forr(i,tot,1){
            int x=id[i];
            ans[x]=min(ans[x],tmp[x]);
            if(tmp[x]) tmp[fa[x]]=maxlen[fa[x]];
            tmp[x]=0;
        }
        For(i,1,tot) tmp[i]=0;
    }
    int final_ans=0;
    For(i,1,tot) final_ans=max(final_ans,ans[i]);
    printf("%d\n",final_ans);
    return 0;
}

spoj7258
题意：找第k大的子串。
感悟：
主席树的搜索方式。
先预处理出来每个点的儿子的个数，主席树的方式查询即可。
预处理从儿子，递推到root。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#define For(aa,bb,cc) for(int aa=(bb);aa<=(int)(cc);++aa)
#define Forr(aa,bb,cc) for(int aa=(bb);aa>=(int)(cc);--aa)
using namespace std;
const int maxn=180010;
char s[maxn];
int tree[maxn][26],fa[maxn],maxlen[maxn],last,tot,len;
int id[maxn],sum[maxn],f[maxn];

inline void init(){
    last=tot=1;
}

void add_char(int pos){
    int np=++tot,p=last,x=s[pos]-'a';
    last=np;maxlen[np]=pos;
    for(;p && !tree[p][x];p=fa[p]) tree[p][x]=np;
    if(!p) fa[np]=1;
    else{
        int q=tree[p][x];
        if(maxlen[q]==maxlen[p]+1) fa[np]=q;
        else{
            int nq=++tot;
            maxlen[nq]=maxlen[p]+1;
            For(i,0,25) tree[nq][i]=tree[q][i];
            fa[nq]=fa[q];fa[q]=fa[np]=nq;
            for(;p && tree[p][x]==q;p=fa[p]) tree[p][x]=nq;
        }
    }
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
#endif
    init();
    scanf("%s",s+1);
    len=strlen(s+1);
    For(i,1,len) add_char(i);
    For(i,1,tot) ++sum[maxlen[i]];
    For(i,1,len) sum[i]+=sum[i-1];
    For(i,1,tot) id[sum[maxlen[i]]--]=i;
    Forr(i,tot,1){
        int x=id[i];
        f[x]=1;
        For(j,0,25) f[x]+=f[tree[x][j]];
    }
    int m,k;
    scanf("%d",&m);
    while(m--){
        scanf("%d",&k);
        int p=1;
        while(k)
            For(i,0,25){
                if(tree[p][i]){
                    if(f[tree[p][i]]>=k){
                        p=tree[p][i];
                        putchar('a'+i);
                        --k;
                        break;
                    }
                    else k-=f[tree[p][i]];
                }
            }
        puts("");
    }
    return 0;
}
算法——后缀自动机
oopxiajun博客专栏
02-26 949
后缀自动机作为一种强大而高效的数据结构，在字符串处理领域展现出了独特的魅力和卓越的性能。它通过巧妙的状态压缩和转移机制，能够以线性的时空复杂度处理各种复杂的字符串问题，为我们解决实际问题提供了有力的工具。从原理上看，后缀自动机基于字符串的后缀信息和 endpos 等价类的概念，构建了一个紧凑而高效的有向无环图结构。这种结构不仅能够完整地表示字符串的所有子串，还通过后缀链接等特性，为各种字符串操作提供了便捷的途径。
SAM(后缀自动机)的题型总结
weixin_52624555的博客
10-17 462
sam
后缀自动机
03-16
后缀自动机 陈立杰
后缀自动机的妙用
Freopen的博客
01-07 413
1.当串的长度较小的时候（<10000） 而询问某子串在另一串出现次数的较多，可以考虑遍历全部子串（离线只需O(n^2)），优于询问一个一个子串（O(q*len)） 2.当串的长度较长时，而询问某子串在另一串出现次数的较少，可以考虑将串的每个前缀在另一串的right集合记录下来，因为子串一定是原串一个前缀的后缀，那么问题就转化为查询len(原串长度)个子串中的后缀，对于后缀自动机，如果查的...
后缀自动机_陈立杰.pptx
09-14
总结来说，后缀自动机是一种强大的字符串处理工具，它能够在处理字符串问题时提供高效的解决方案，特别是对于那些需要处理大量字符串后缀和子串的情况。通过构建最简状态后缀自动机，我们可以确保在时间和空间效率上...
后缀自动机的详解
10-25
### 后缀自动机详解 #### 一、后缀自动机基本概念 **后缀自动机**（Suffix Automaton, SAM）是一种特殊的自动机，它主要用于处理字符串问题，特别是涉及字符串匹配的问题。对于一个给定的字符串 \(S\)，能够识别 \...
从最长公共子串到后缀自动机（LCS->SAM)
菜的抠脚弟弟的专栏
01-05 4215
Longest Common Substring—Suffix Automaton本文将从最长公共子串开始说起，循序渐进的讲解后缀自动机，希望通过自己的理解帮助到大家，文章目录如下： 最长公共子串问题 后缀自动机历史 后缀自动机简介 后缀自动机相关理论基础 如何构造后缀自动机 后缀自动机的应用 总结 最长公共子串问题首先来看一到经典的例题题目：给出N个长度不超过100000的字符串，求他们的最长公共
模板 后缀自动机
weixin_30364325的博客
11-24 129
后缀自动机不是Trie树上的，蒟蒻的我才知道。 那个树叫parent。 代码（增量构造）： namespace SAM{ sant s[3000000]; int siz; int fin; lnt ans; void Insert(int c) { int nwp,lsp,nwq,lsq; ...
后缀自动机模板
Anoyer的博客
10-03 3114
#include&amp;lt;stdio.h&amp;gt; #include&amp;lt;bits/stdc++.h&amp;gt; #define maxc 28 using namespace std; const int maxn = 1e6 + 5; const int mod = 1e9 + 7; typedef long long ll; int len[maxn * 2], //最长子串的长度(该节点字串数量...
【字符串新武器】后缀自动机
热门推荐
huyuncong的专栏
05-19 1万+
发链：http://neroysq.blogcn.com/articles/%E5%90%8E%E7%BC%80%E8%87%AA%E5%8A%A8%E6%9C%BA%E5%88%9D%E6%8E%A2.html http://blog.sina.com.cn/s/blog_7812e98601012cim.html 详细构造见上述链接，此处介绍性质与理解 后缀自动机具有两大性质，考虑转
[字符串]后缀自动机
wulalalawu的博客
12-31 226
不是我写的 //后缀自动机 #include<iostream> #include<cstdio> #include<cstdlib> #include<cstring> #define ll long long using namespace std; const int N=2010000; char s[N]; int fa[N],ch[N][26],len[N],siz[N]; int lst=1,node=1,l,t[N],A[N]; ll ans;
后缀自动机专题
Qianyri的博客
10-03 446
https://www.cnblogs.com/--560/p/5457023.html SPOJ Longest Common Substring 求两串的最长公共子串 #include&lt;bits/stdc++.h&gt; using namespace std; const int MAX=2e6; const int INF=0x3f3f3f3f; struct Tire ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值