后缀自动机的一些简单题目

最新推荐文章于 2022-07-28 19:08:55 发布
最新推荐文章于 2022-07-28 19:08:55 发布
阅读量625 收藏 2
点赞数
分类专栏： 算法 文章标签： 算法 后缀自动机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ctlchild/article/details/78045751
版权 
对于后缀自动机的论文很多，这里记录一些比较简单的题目便于熟悉后缀自动机的基本应用
只有四道题目有一点少，今后会好好填坑

BZOJ4032: [HEOI2015]最短不公共子串

  • 一句话题意：给两个串 A 和 B，求 A 最短子串且不是 B 的子串，A 最短子串且不是B的子序列，A 最短子序列且不是 B 的子串，A 最短子序列且不是 B 的子序列

  • 做法：建出后缀自动机和序列自动机，自动机上每一条路径都相当于一个子串（子序列），从根节点 bfs 一遍，找到第一个 A 有的而 B 没有的点，就是字典序最小的

#include<cstring>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#define rep(i,l,r) for (int i=l;i<=r;i++)
#define down(i,l,r) for (int i=l;i>=r;i--)
#define clr(x,y) memset(x,y,sizeof(x))
#define maxn 4005
#define ll long long
#define inf int(1e9)
using namespace std;
char sa[maxn],sb[maxn];
int f[maxn][maxn];
int n,m;
int read(){
    int x=0,f=1; char ch=getchar();
    while (!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while (isdigit(ch)) {x=x*10+ch-'0'; ch=getchar();}
    return x*f;
}
struct data{
    struct sam{int l,fa,ch[30];} sam[maxn];
    int tot,root,last,head[30];
    void init(){
        clr(sam,0); tot=1; clr(head,0);
    }
    void extend(int c){
        int p,np,q,nq;
        p=last,np=++tot; last=np;
        sam[np].l=sam[p].l+1;
        for (;p&&!sam[p].ch[c];p=sam[p].fa) sam[p].ch[c]=np;
        if (!p) sam[np].fa=1;
        else {
            q=sam[p].ch[c];
            if (sam[p].l+1==sam[q].l) sam[np].fa=q;
            else {
                nq=++tot; sam[nq].l=sam[p].l+1;
                memcpy(sam[nq].ch,sam[q].ch,sizeof(sam[q].ch));
                sam[nq].fa=sam[q].fa;
                sam[np].fa=sam[q].fa=nq;
                for (;sam[p].ch[c]==q;p=sam[p].fa) sam[p].ch[c]=nq;
            }
        }
    }
    void sambuild(int n,char s[]){
        init();
        tot=last=1; 
        rep(i,1,n) extend(s[i]-'a');
    }
    void quebuild(int n,char s[]){
        int o,p,c;
        init();
        rep(i,0,25) head[i]=1;
        rep(i,1,n){
            o=++tot; c=s[i]-'a';
            rep(j,0,25) for (p=head[j];p&&!sam[p].ch[c];p=sam[p].fa) sam[p].ch[c]=o;    
            sam[o].fa=head[c];  head[c]=o;
        }
    }
} A,B;
struct node{int x,y;};
int solve(){
    queue<node> q; clr(f,0);
    q.push((node){1,1}); f[1][1]=0;
    while (!q.empty()){
        int ux=q.front().x,uy=q.front().y; q.pop();
        rep(i,0,25){
            if (!A.sam[ux].ch[i]) continue;
            if (!B.sam[uy].ch[i]) return f[ux][uy]+1;
            int vx=A.sam[ux].ch[i],vy=B.sam[uy].ch[i];
            if (!f[vx][vy]) q.push((node){vx,vy}),f[vx][vy]=f[ux][uy]+1;
        }
    }
    return -1;
}
int main(){
    scanf("%s",sa+1); scanf("%s",sb+1);
    n=strlen(sa+1); m=strlen(sb+1);
    A.sambuild(n,sa); B.sambuild(m,sb);
    printf("%d\n",solve());
    B.quebuild(m,sb);
    printf("%d\n",solve());
    A.quebuild(n,sa); B.sambuild(m,sb);
    printf("%d\n",solve());
    B.quebuild(m,sb);
    printf("%d\n",solve());
    return 0;
}

【弱省胡策】Round #0 Luv Letter

  • 一句话题意：给串 A 和 B ，求是 A 的子串（子序列）且不是 B 的子串（子序列）的数目

  • 做法：对 A B 都建出自动机后 dfs 一遍将节点的贡献加在其父亲上就可以知道每个点的子树大小，这样只要扫一遍找出 A 有的而 B 没有的节点，将其子树大小加到答案中就可以了

#include<cstring>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#define rep(i,l,r) for (int i=l;i<=r;i++)
#define down(i,l,r) for (int i=l;i>=r;i--)
#define clr(x,y) memset(x,y,sizeof(x))
#define maxn 4005
#define ll long long
#define inf int(1e9)
#define mm 1000000007
using namespace std;
char sa[maxn],sb[maxn];
ll f[maxn][maxn];
int vis[maxn][maxn];
int n,m;
int read(){
    int x=0,f=1; char ch=getchar();
    while (!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while (isdigit(ch)) {x=x*10+ch-'0'; ch=getchar();}
    return x*f;
}
struct data{
    struct sam{int l,fa,ch[30];ll sz;} sam[maxn];
    int tot,root,last,head[30];
    void init(){
        clr(sam,0); tot=1; clr(head,0);
    }
    void extend(int c){
        int p,np,q,nq;
        p=last,np=++tot; last=np;
        sam[np].l=sam[p].l+1;
        for (;p&&!sam[p].ch[c];p=sam[p].fa) sam[p].ch[c]=np;
        if (!p) sam[np].fa=1;
        else {
            q=sam[p].ch[c];
            if (sam[p].l+1==sam[q].l) sam[np].fa=q;
            else {
                nq=++tot; sam[nq].l=sam[p].l+1;
                memcpy(sam[nq].ch,sam[q].ch,sizeof(sam[q].ch));
                sam[nq].fa=sam[q].fa;
                sam[np].fa=sam[q].fa=nq;
                for (;sam[p].ch[c]==q;p=sam[p].fa) sam[p].ch[c]=nq;
            }
        }
    }
    void dfs(int u){
        if (!u||sam[u].sz) return;
        sam[u].sz=1;
        rep(i,0,25) {
            int v=sam[u].ch[i];
            if (!v) continue;
            if (!sam[v].sz) dfs(v);
            sam[u].sz=(sam[u].sz+sam[v].sz)%mm;
        }
    }
    void sambuild(int n,char s[]){
        init();
        tot=last=1; 
        rep(i,1,n) extend(s[i]-'a');
        dfs(1);
    }
    void quebuild(int n,char s[]){
        int o,p,c;
        init();
        rep(i,0,25) head[i]=1;
        rep(i,1,n){
            o=++tot; c=s[i]-'a';
            rep(j,0,25) for (p=head[j];p&&!sam[p].ch[c];p=sam[p].fa) sam[p].ch[c]=o;    
              sam[o].fa=head[c];     head[c]=o; 
        }
        dfs(1);
    }
} A,B;
struct node{int x,y;};
ll dfs(int x,int y){
    if (vis[x][y]) return f[x][y];
    vis[x][y]=1;
    if (!y) return f[x][y]=A.sam[x].sz;
    f[x][y]=0;
    rep(i,0,25){
        int vx=A.sam[x].ch[i],vy=B.sam[y].ch[i];
        if (!vx) continue;
        f[x][y]=(f[x][y]+dfs(vx,vy))%mm;
    }
    return f[x][y]=f[x][y];
}
ll solve(){
    clr(vis,0); 
    return dfs(1,1);
}
int main(){
    scanf("%s",sa+1); scanf("%s",sb+1);
    n=strlen(sa+1); m=strlen(sb+1);
    A.sambuild(n,sa); B.sambuild(m,sb);
    printf("%lld\n",solve());
    B.quebuild(m,sb);
    printf("%lld\n",solve());
    A.quebuild(n,sa); B.sambuild(m,sb);
    printf("%lld\n",solve());
    B.quebuild(m,sb);
    printf("%lld\n",solve());
    return 0;
}

BZOJ3998: [TJOI2015]弦论

  • 一句话题意：求一个子串的第 k 小子串 （分多个相同子串算一个和算多个两种情况）

  • 做法：如果是多个算多个的话那么每个点的贡献要加到其fail上去否则就不用，然后算出自动机上每个点的子树大小，顺序遍历一遍就可以了

  • 代码实现：因为 SAM 中的节点的 fail 的编号可能在后面，我写的做法是将长度进行桶排，从长度大的算到长度小的。当然还有一种做法是建出 fail 树将子节点的贡献加到父亲上去

#include<cstring>
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#define rep(i,l,r) for (int i=l;i<=r;i++)
#define down(i,l,r) for (int i=l;i>=r;i--)
#define clr(x,y) memset(x,y,sizeof(x))
#define maxn 1000500
using namespace std;
int last,tot,n,T,K;
char s[maxn];
int fa[maxn],ch[maxn][31],l[maxn],q[maxn],b[maxn],sum[maxn],val[maxn],vis[maxn];
int read(){
    int x=0,f=1; char ch=getchar();
    while (!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while (isdigit(ch)) {x=x*10+ch-'0'; ch=getchar();}
    return x*f;
}
void expand(int c){
    int p,np,q,nq;
    p=last; last=np=++tot; l[np]=l[p]+1;
    for (;p&&!ch[p][c];p=fa[p]) ch[p][c]=np;
    if (!p) fa[np]=1;
    else {
        q=ch[p][c];
        if (l[q]==l[p]+1) fa[np]=q;
        else {
            nq=++tot; l[nq]=l[p]+1;
            memcpy(ch[nq],ch[q],sizeof(ch[nq]));
            fa[nq]=fa[q];
            fa[np]=fa[q]=nq;
            for (;p&&ch[p][c]==q;p=fa[p]) ch[p][c]=nq;
        }
    }  
    val[np]=1;
}
void dfs(int u,int k){
    if (k>=sum[u]) return;
    k-=val[u];
    if (!k) return;
    rep(j,0,25) if (ch[u][j]){
        int v=ch[u][j];
        if (sum[v]>=k){
            putchar(j+'a');
            dfs(v,k);
            return ;
        }
        k-=sum[v];
    }
}
int main(){
    scanf("%s",s+1);
    n=strlen(s+1);
    tot=last=1;
    rep(i,1,n) expand(s[i]-'a');
    T=read(); K=read();
    rep(i,1,tot) b[l[i]]++;
    rep(i,1,n) b[i]+=b[i-1];
    rep(i,1,tot) q[b[l[i]]--]=i;
    down(i,tot,1) {
        int t=q[i];
        if (T==1) val[fa[t]]+=val[t];
        else val[t]=1;
    }
    val[1]=0;
    down(i,tot,1){
        int t=q[i];
        sum[t]=val[t];
        rep(j,0,25) sum[t]+=sum[ch[t][j]];
    }
    if (sum[1]<K) {puts("-1"); return 0;}
    dfs(1,K);
    return 0;
}

BZOJ3238: [Ahoi2013]差异

  • 一句话题意：求一个串的两两后缀的 lcp

  • 做法：逆序建出 SAM，它的 fail 树就是后缀树，然后扫一遍就可以了

#include<cstring>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#define rep(i,l,r) for (int i=l;i<=r;i++)
#define down(i,l,r) for (int i=l;i>=r;i--)
#define clr(x,y) memset(x,y,sizeof(x))
#define maxn 1005000
#define ll long long
#define inf int(1e9)
#define mm 1000000007
using namespace std;
char s[maxn];
ll ans;
int n,m;
int read(){
    int x=0,f=1; char ch=getchar();
    while (!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while (isdigit(ch)) {x=x*10+ch-'0'; ch=getchar();}
    return x*f;
}
struct data{
    struct sam{int l,fa,ch[30];ll sz;} sam[maxn];
    int tot,root,last;
    void init(){
        clr(sam,0); tot=1; 
    }
    void extend(int c){
        int p,np,q,nq;
        p=last,np=++tot; last=np;
        sam[np].l=sam[p].l+1;
        for (;p&&!sam[p].ch[c];p=sam[p].fa) sam[p].ch[c]=np;
        if (!p) sam[np].fa=1;
        else {
            q=sam[p].ch[c];
            if (sam[p].l+1==sam[q].l) sam[np].fa=q;
            else {
                nq=++tot; sam[nq].l=sam[p].l+1;
                memcpy(sam[nq].ch,sam[q].ch,sizeof(sam[q].ch));
                sam[nq].fa=sam[q].fa;
                sam[np].fa=sam[q].fa=nq;
                for (;sam[p].ch[c]==q;p=sam[p].fa) sam[p].ch[c]=nq;
            }
        }
        sam[np].sz=1;
    }
    void sambuild(int n,char s[]){
        tot=last=1; 
        down(i,n,1) extend(s[i]-'a');
    }
} A;
ll sum[maxn];
int l[maxn],head[maxn],tot;
struct node{int obj,pre;
}e[maxn];
void insert(int x,int y){
    e[++tot].obj=y; e[tot].pre=head[x]; head[x]=tot;
}
void dfs(int u){
    for (int j=head[u];j;j=e[j].pre){
        int v=e[j].obj;
        dfs(v);
        ans-=2LL*l[u]*sum[u]*sum[v];
        sum[u]+=sum[v];
    }
}
int main(){
    scanf("%s",s+1);
    n=strlen(s+1);
    ans=1LL*n*(n-1)*(n+1)/2;
    A.sambuild(n,s);
    rep(i,1,A.tot) l[i]=A.sam[i].l,sum[i]=A.sam[i].sz,insert(A.sam[i].fa,i);
    dfs(1);
    printf("%lld\n",ans);
    return 0;
}
ctlchild
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
洛谷oj上面的一些题目答案
04-06
3. 字符串处理：KMP、Rabin-Karp、Boyer-Moore等字符串匹配算法，以及后缀数组、后缀自动机等高级技巧。 4. 数据结构：链表、树、堆、队列、栈、哈希表等，它们在解决特定问题时有独特优势。 五、学习资源推荐 ...
CCF题目和答案.zip
05-18
5. **字符串处理**：KMP、Rabin-Karp、Boyer-Moore等字符串匹配算法，以及后缀数组、后缀自动机等高级技术，常用于处理字符串搜索和模式匹配问题。 6. **数学逻辑**：逻辑推理、概率统计、组合优化等，对于解决一些...
后缀自动机模板题hdu_后缀自动机习题合集
weixin_30230059的博客
01-17 153
constmaxn=400000;varson:array[0..maxn,0..25]oflongint;pre,step:array[0..maxn]oflongint;last,tot:longint;functionaddpoint:longint;vari:longint;begininc(tot);//pre[tot]:=-1;// for i:=0 to 25 do son[tot,...
后缀自动机模板题hdu_[hdu4416 Good Article Good sentence]后缀自动机SAM
weixin_35823536的博客
01-17 97
题意：给出串A和串集合B={B1,B2,...,Bn}，求串A的所有不同子串中不是B中任一串的子串的数目。思路：把A和B中所有字符串依次拼接在一起，然后构造后缀自动机，计算每个状态的R集合元素的最大值r，然后统计那些r≤length(A)的状态。hdu不卡时间卡空间，这是最郁闷的。。。导致下面的程序只在本地随机数据没发现错误，提交就MLE。#include using namespace std;...
后缀自动机习题集与归纳
guoshiyuan484的博客
09-04 1259
学习感悟：什么论文证明根本就看不懂。。。。。还是看代码，然后自己再yy下复杂度再理解下是最好的学习方法。。不要死扣论文！！！！！！ 理解后缀自动机的关键是明白它与后缀树的关系。要明白这一点后缀链接的性质fa(max)+1=son(min-1)有是另一个关键 多串的题目： 广义后缀自动机：广义的和狭义的主要区别就是广义的串是不连续转移的，狭义的一个串可以看成是多个串组合而成且连续转移。 其实
后缀自动机题目整理
EM LGH
02-13 225
后缀自动机题目整理 1. 洛谷P1368 (工艺) 求最小表示 2. 洛谷P3804 (模板) 统计单词出现次数，right集合大小 3. SPOJ8222 (NSUBSTR-Substrings) 简单动态规划 4. APIO2014  (回文串) 后缀树，倍增 5. SPOJ1812 (LCS2) 最长公共子串 6. TJOI2015   (弦...
[后缀自动机 模板题] SPOJ 8222 Substrings
雯舞
01-28 699
题目大意：求某个长度的所有子串中出现次数最多的次数每个状态对应一段长度区间的子串 right集合的大小就是出现次数 那么我们用|right(x)|去更新f[maxs[x]]的值，最后从大到小用f[i]去更新f[i-1]的值即可#include<cstdio> #include<cstdlib> #include<algorithm> using namespace std;inline char
[NOI2016]优秀的拆分_C++_优秀的拆分_
09-30
【NOI2016】优秀的拆分是一个编程竞赛题目，主要涉及的编程语言是C++，并采用了后缀自动机（Suffix Automaton）和点分治（Pointwise Divide and Conquer）这两种高级算法。这里我们将深入探讨这两个算法以及它们在...
形式语言与自动机第一章作业
06-07
题目给出了特定字符串集合，并分别列举了它们的前缀、后缀、真前缀和真后缀。真前缀与真后缀是指不包含整个字符串本身的前缀和后缀。通过分析给出的字符串，我们可以发现这些集合的正确性。 1.22题提及的“具有前缀...
ACM题目推荐
03-17
5. **字符串处理**：字符串匹配（如KMP算法）、后缀数组、后缀自动机等，对于处理文本类问题至关重要。 6. **数据结构**：链表、树、堆、队列、栈等基本数据结构，以及高级数据结构如平衡二叉树、Trie树、跳跃表等...
后缀自动机 陈立杰演讲稿
04-11
陈立杰2012年冬令营的演讲稿，讲解了后缀自动机的原理，实现方法与应用。
后缀自动机应用及题目
AcTarjan的博客
09-26 417
1、最长公共子串问题（LCS问题） 题目：SPOJ-LCS     SPOJ-LCS2 2、最长不公共子串问题 题目：4032 3、最小表示法问题 题目：落谷P1368 4、第k小子串问题 题目：bzoj-3998 5、后缀自动机+dp 题目：SPOJ-Substring      落谷P3804       4516      4566 6、后缀自动机+维护 题目：2555...
专题训练2 后缀自动机题目清单
qq_39898877的博客
09-16 735
模板 void ins(int ch){ int p=last,np=++cnt;mx[np]=mx[p]+1;last=np;size[np]=1; while(p &amp;&amp; !son[p][ch]) son[p][ch]=np,p=fa[p]; if(!p) fa[np]=root; else{ int q=son[p][ch];...
后缀自动机题解
linjiayang2016的博客
09-20 395
后缀自动机(SAM)是一种优秀的数据结构，它作为一种自动机，不仅能接受一个字符串所有的后缀，还可以接受所有子串。
后缀自动机刷题计划
diaopinshuo4087的博客
06-19 112
后缀自动机刷题计划 codevs3160: 最长公共子串 bzoj3998: [TJOI2015]弦论 bzoj2946: [Poi2000]公共串 bzoj3926: [Zjoi2015]诸神眷顾的幻想乡 bzoj2555: SubString bzoj4566: [Haoi2016]找相同字符 bzoj3238: [Ahoi2013]差异 bzoj2806: ...
后缀自动机（SAM）讲解 + Luogu p3804【模板】后缀自动机 (SAM)
最新发布
Jacob0824的博客
07-28 2419
后缀自动机 SAM
洛谷3804 【模板】后缀自动机
forever_shi的博客
12-01 217
题目链接 题意： 给你一个n个字符的字符串，求所有出现次数大于1的子串乘子串长度的最大值。n&lt;=1e6 题解： 感觉全机房都早就会后缀自动机了啊，就我不会。而且感觉自己学得还不怎么样，似乎不是那么明白，感觉药丸。 这个题的话建出后缀自动机之后，我们根据SAM的性质可知，一个点在parent树的子树中的叶子节点个数就是根到该节点的子串出现的次数。我们在建后缀自动机的时候已经求出了从根到每个节点...
后缀自动机 [取巨神博客之精华]
FSYo 的博客
02-03 184
大部分内容来源于https://www.luogu.org/blog/Kesdiael3/hou-zhui-zi-dong-ji-yang-xie 1. 后缀自动机可以在一个DAG上表示所有子串 2. 在trie树中插入每个后缀就是后缀自动机的暴力版本 对于aabab建trie，红色为根，黄色为终止节点     3. endpos 的定义 4. 一些性质 1.如果两个子串的...
子树的大小
kala0的博客
09-06 3634
这是找树的重心的经典题目。 树的重心有下面几条常见性质： 定义1：找到一个点，其所有的子树中最大的子树节点数最少，那么这个点就是这棵树的重心。 定义2：以这个点为根，那么所有的子树（不算整个树自身）的大小都不超过整个树大小的一半。 性质1：树中所有点到某个点的距离和中，到重心的距离和是最小的；如果有两个重心，那么他们的距离和一样。 性质2：把两个树通过一条边相连得到一个新的树，那么新的树
利用后缀自动机解决字符串问题
陈立杰提到，后缀自动机在解决特定的字符串问题时，比如在SPOJ上的LongestCommonSubstringII题目中，能够提供更高效的解决方案，特别是在面对时间限制较严苛的问题时。 首先，后缀自动机的基本概念是建立在有限状态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值