后缀自动机经典模板题集合

最新推荐文章于 2022-10-17 10:51:10 发布
最新推荐文章于 2022-10-17 10:51:10 发布
阅读量1k 收藏 16
点赞数 8
分类专栏： acm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35885746/article/details/83387554
版权

花了很久总结出来的基本操作 一次性全丢这里了

1：存在性查询

查询一个字符串是否是另一个字符串的子串

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e4+5;
char s[maxn];
int n;
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2];
    int last,cnt;
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
    }
    int inline newnode()
    {
        cnt++;
        memset(next[cnt],0,sizeof next[cnt]);
        fa[cnt]=l[cnt]=0;
        return cnt;
    }
    void add(int c)
    {
        int p=last;
        int np=newnode();
        l[np]=l[p]+1;
        last=np;
        while(p&&!next[p][c])
        {
            next[p][c]=np,p=fa[p];
        }
        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                l[nq]=l[p]+1;
                memcpy(next[nq],next[q],sizeof next[q]);
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
    }
}sam;
int main()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    sam.init();
    for(int i=1;i<=n;i++)
        sam.add(s[i]-'a');
    scanf("%s",s+1);
    n=strlen(s+1);
    int p=1;
    for(int i=1;i<=n;i++)
    {
        if(sam.next[p][s[i]-'a'])
            p=sam.next[p][s[i]-'a'];
        else
        {
            printf("NO\n");
            return 0;
        }
    }
    printf("YES\n");
    return 0;
}

2：不同的子串个数

求一个字符串有多少个本质不同的子串

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e4+5;
char s[maxn];
int n;
int ans=0;
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2];
    int last,cnt;
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
    }
    int inline newnode()
    {
        cnt++;
        memset(next[cnt],0,sizeof next[cnt]);
        fa[cnt]=l[cnt]=0;
        return cnt;
    }
    void add(int c)
    {
        int p=last;
        int np=newnode();
        l[np]=l[p]+1;
        last=np;
        while(p&&!next[p][c])
        {
            next[p][c]=np,p=fa[p];
        }
        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                l[nq]=l[p]+1;
                memcpy(next[nq],next[q],sizeof next[q]);
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
    }
    int count()
    {
        for(int i=1;i<=cnt;i++)
            ans+=(l[i]-l[fa[i]]);
        return ans;
    }
}sam;
int main()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    sam.init();
    for(int i=1;i<=n;i++)
        sam.add(s[i]-'a');
    printf("%d\n",sam.count());
    return 0;
}

3：不同子串的总长

求一个字符串其本质不同子串的长度和

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e4+5;
char s[maxn];
int n;
int ans=0;
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2],mmin[maxn*2];
    int last,cnt;
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
    }
    int inline newnode()
    {
        cnt++;
        memset(next[cnt],0,sizeof next[cnt]);
        fa[cnt]=l[cnt]=0;
        return cnt;
    }
    void add(int c)
    {
        int p=last;
        int np=newnode();
        mmin[np]=l[np]=l[p]+1;
        last=np;
        while(p&&!next[p][c])
        {
            mmin[np]=min(mmin[np],mmin[p]+1);
            next[p][c]=np,p=fa[p];
        }
        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                l[nq]=l[p]+1;
                mmin[q]=l[p]+2;
                memcpy(next[nq],next[q],sizeof next[q]);
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
        ans+=(l[last]+mmin[last])*(l[last]-mmin[last]+1)/2;
    }
}sam;
int main()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    sam.init();
    for(int i=1;i<=n;i++)
        sam.add(s[i]-'a');
    printf("%d\n",ans);
    return 0;
}

4：字典序第k小子串

求一个字符串的字典序第k小的子串，当op==0时，不同位置的相同串算同一个，当op==1时，不同位置的相同串算多个

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e5+5;
char s[maxn];
int n;
int siz[maxn*2];
int sum[maxn*2];
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2],mmin[maxn*2];
    int last,cnt;
    int cntA[maxn*2],A[maxn*2];
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
    }
    int inline newnode()
    {
        cnt++;
        memset(next[cnt],0,sizeof next[cnt]);
        fa[cnt]=l[cnt]=0;
        return cnt;
    }
    void add(int c)
    {
        int p=last;
        int np=newnode();
        mmin[np]=l[np]=l[p]+1;
        last=np;
        while(p&&!next[p][c])
        {
            mmin[np]=min(mmin[np],mmin[p]+1);
            next[p][c]=np,p=fa[p];
        }
        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                l[nq]=l[p]+1;
                mmin[q]=l[p]+2;
                memcpy(next[nq],next[q],sizeof next[q]);
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
        siz[np]=1;
    }
    void work(int op)
    {
        memset(cntA,0,sizeof cntA);
        for(int i=1;i<=cnt;i++)
            cntA[l[i]]++;
        for(int i=1;i<=n;i++)
            cntA[i]+=cntA[i-1];
        for(int i=1;i<=cnt;i++)
            A[cntA[l[i]]--]=i;
        for(int i=cnt;i>=1;i--)
        {
            int p=A[i];
            if(op)
                siz[fa[p]]+=siz[p];
            else siz[p]=1;
        }
        siz[1]=0;
        for(int i=cnt;i>=1;i--)
        {
            int p=A[i];
            sum[p]=siz[p];
            for(int j=0;j<26;j++)
                sum[p]+=sum[next[p][j]];
        }
    }
}sam;
int main()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    sam.init();
    for(int i=1;i<=n;i++)
        sam.add(s[i]-'a');
    int op;
    scanf("%d",&op);
    sam.work(op);
    int k;
    scanf("%d",&k);
    if(k>sum[1])
        printf("-1\n");
    else
    {
        int p=1;
        while(k>siz[p])
        {
            k-=siz[p];
            for(int i=0;i<26;i++)
            {
                if(sum[sam.next[p][i]]>=k)
                {
                    printf("%c",'a'+i);
                    p=sam.next[p][i];
                    break;
                }
                else k-=sum[sam.next[p][i]];
            }
        }
        printf("\n");
    }
    return 0;
}

5：最小循环移位

求一个字符串和它循环同构的字典序最小字符串

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e4+5;
char s[maxn];
int n;
int siz[maxn*2];
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2],mmin[maxn*2];
    int last,cnt;
    int cntA[maxn*2],A[maxn*2];
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
    }
    int inline newnode()
    {
        cnt++;
        memset(next[cnt],0,sizeof next[cnt]);
        fa[cnt]=l[cnt]=0;
        return cnt;
    }
    void add(int c)
    {
        int p=last;
        int np=newnode();
        mmin[np]=l[np]=l[p]+1;
        last=np;
        while(p&&!next[p][c])
        {
            mmin[np]=min(mmin[np],mmin[p]+1);
            next[p][c]=np,p=fa[p];
        }
        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                l[nq]=l[p]+1;
                mmin[q]=l[p]+2;
                memcpy(next[nq],next[q],sizeof next[q]);
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
    }
}sam;
int main()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    sam.init();
    for(int i=1;i<=n;i++)
        sam.add(s[i]-'a');
    for(int i=1;i<=n;i++)
        sam.add(s[i]-'a');
    int p=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<26;j++)
        {
            if(sam.next[p][j])
            {
                printf("%c",'a'+j);
                p=sam.next[p][j];
                break;
            }
        }
    }
    printf("\n");
    return 0;
}

6：出现次数查询

求一个字符串在另一个字符串中出现了多少次

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e4+5;
char s[maxn];
int n;
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2],mmin[maxn*2],right[maxn*2];
    int last,cnt;
    int cntA[maxn*2],A[maxn*2];
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
    }
    int inline newnode()
    {
        cnt++;
        memset(next[cnt],0,sizeof next[cnt]);
        fa[cnt]=l[cnt]=0;
        return cnt;
    }
    void add(int c)
    {
        int p=last;
        int np=newnode();
        mmin[np]=l[np]=l[p]+1;
        last=np;
        while(p&&!next[p][c])
        {
            mmin[np]=min(mmin[np],mmin[p]+1);
            next[p][c]=np,p=fa[p];
        }
        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                l[nq]=l[p]+1;
                mmin[q]=l[p]+2;
                memcpy(next[nq],next[q],sizeof next[q]);
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
    }
    void work()
    {
        memset(cntA,0,sizeof cntA);
        for(int i=1;i<=cnt;i++)
            cntA[l[i]]++;
        for(int i=1;i<=n;i++)
            cntA[i]+=cntA[i-1];
        for(int i=1;i<=cnt;i++)
            A[cntA[l[i]]--]=i;
        int p=1;
        for(int i=1;i<=n;i++)
        {
            p=next[p][s[i]-'a'];
            right[p]=1;
        }
        for(int i=cnt;i>=1;i--)
        {
            p=A[i];
            if(fa[p])
                right[fa[p]]+=right[p];
        }
    }
}sam;
int main()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    sam.init();
    for(int i=1;i<=n;i++)
        sam.add(s[i]-'a');
    sam.work();
    scanf("%s",s+1);
    n=strlen(s+1);
    int p=1;
    for(int i=1;i<=n;i++)
        p=sam.next[p][s[i]-'a'];
    printf("%d\n",sam.right[p]);
    return 0;
}

7：首次出现位置查询

求一个字符串在另一个字符串中首次出现的位置

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e4+5;
char s[maxn];
int n;
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2],num[maxn*2],right[maxn*2],mmin[maxn*2];
    int last,cnt;
    int cntA[maxn*2],A[maxn*2],firstpos[maxn*2];
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
    }
    int inline newnode()
    {
        cnt++;
        memset(next[cnt],0,sizeof next[cnt]);
        fa[cnt]=l[cnt]=num[cnt]=0;
        return cnt;
    }
    void add(int c)
    {
        int p=last;
        int np=newnode();
        mmin[np]=l[np]=l[p]+1;
        firstpos[np]=l[np]-1;
        last=np;
        while(p&&!next[p][c])
        {
            mmin[np]=min(mmin[np],mmin[p]+1);
            next[p][c]=np,p=fa[p];
        }

        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                l[nq]=l[p]+1;
                mmin[q]=l[p]+2;
                firstpos[nq]=firstpos[q];
                memcpy(next[nq],next[q],sizeof next[q]);
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                num[nq]=num[q];
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
    }
    void work()
    {
        memset(cntA,0,sizeof cntA);
        for(int i=1;i<=cnt;i++)
            cntA[l[i]]++;
        for(int i=1;i<=n;i++)
            cntA[i]+=cntA[i-1];
        for(int i=1;i<=cnt;i++)
            A[cntA[l[i]]--]=i;
        int p=1;
        for(int i=1;i<=n;i++)
        {
            p=next[p][s[i]-'a'];
            right[p]=1;
        }
        for(int i=cnt;i>=1;i--)
        {
            p=A[i];
            if(fa[p])
                right[fa[p]]+=right[p];
        }
    }
}sam;
int main()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    sam.init();
    for(int i=1;i<=n;i++)
        sam.add(s[i]-'a');
    sam.work();
    scanf("%s",s+1);
    n=strlen(s+1);
    int p=1;
    for(int i=1;i<=n;i++)
    {
        p=sam.next[p][s[i]-'a'];
    }
    printf("%d\n",sam.firstpos[p]-n+1);//下标从零开始
    return 0;
}

8：所有出现位置查询

求一个字符串在另一个字符串中所有出现的位置

挖坑待补...

9：查询不在文本中出现的最短字符串长度

求出一个长度最短的字符串，使得它不是给定字符串的子串。

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
char s[maxn];
int n;
int ans;
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2];
    int last,cnt;
    int cntA[maxn*2],A[maxn*2];
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
        ans=0x3f3f3f3f;
    }
    int inline newnode()
    {
        cnt++;
        memset(next[cnt],0,sizeof next[cnt]);
        fa[cnt]=l[cnt]=0;
        return cnt;
    }
    void add(int c)
    {
        int p=last;
        int np=newnode();
        l[np]=l[p]+1;
        last=np;
        while(p&&!next[p][c])
            next[p][c]=np,p=fa[p];
        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                l[nq]=l[p]+1;
                memcpy(next[nq],next[q],sizeof next[q]);
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
    }
    void dfs(int x,int deep)
    {
        if(ans<=deep)
            return ;
        for(int i=0;i<26;i++)
        {
            if(!next[x][i])
            {
                ans=min(ans,deep);
                return ;
            }
        }
        for(int i=0;i<26;i++)
            dfs(next[x][i],deep+1);
    }
}sam;
int main()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    sam.init();
    for(int i=1;i<=n;i++)
        sam.add(s[i]-'a');
    sam.dfs(1,1);
    printf("%d\n",ans);
    return 0;
}

10：求两个字符串的最长公共子串

求给定两个字符串的最长公共子串

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e4+5;
char s[maxn];
int n;
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2],num[maxn*2];;
    int last,cnt;
    long long ans=0;
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
        ans=0;
    }
    int inline newnode()
    {
        cnt++;
        memset(next[cnt],0,sizeof next[cnt]);
        fa[cnt]=l[cnt]=num[cnt]=0;
        return cnt;
    }
    void add(int c)
    {
        int p=last;
        int np=newnode();
        l[np]=l[p]+1;
        last=np;
        while(p&&!next[p][c])
            next[p][c]=np,p=fa[p];
        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                l[nq]=l[p]+1;
                memcpy(next[nq],next[q],sizeof next[q]);
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                num[nq]=num[q];
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
    }
}sam;
int main()
{
    scanf("%s",s+1);
    sam.init();
    n=strlen(s+1);
    for(int i=1;i<=n;i++)
        sam.add(s[i]-'a');
    scanf("%s",s+1);
    n=strlen(s+1);
    int now=1,last=1;
    int ans=0,len=0;
    for(int i=1;i<=n;i++)
    {
        int x=s[i]-'a';
        if(sam.next[now][x])
        {
            len++;
            now=sam.next[now][x];
        }
        else
        {
            while(now&&!sam.next[now][x]) now=sam.fa[now];
            if(!now)
                now=1,len=0;
            else len=sam.l[now]+1,now=sam.next[now][x];
        }
        ans=max(ans,len);
    }
    printf("%d\n",ans);
    return 0;
}

11：多个字符串的最长公共子串

求给定的所有字符串的最长公共子串

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+5;
char s[maxn];
int n;
int ans;
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2],mmin[maxn*2],mmax[maxn*2];
    int last,cnt;
    int cntA[maxn*2],A[maxn*2];
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
        ans=0;
    }
    int inline newnode()
    {
        cnt++;
        memset(next[cnt],0,sizeof next[cnt]);
        fa[cnt]=l[cnt]=0;
        return cnt;
    }
    void add(int c)
    {
        int p=last;
        int np=newnode();
        l[np]=mmin[np]=l[p]+1;
        last=np;
        while(p&&!next[p][c])
            next[p][c]=np,p=fa[p];
        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                l[nq]=mmin[nq]=l[p]+1;
                memcpy(next[nq],next[q],sizeof next[q]);
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
    }
    void work()
    {
        memset(cntA,0,sizeof cntA);
        for(int i=1;i<=cnt;i++)
            cntA[l[i]]++;
        for(int i=1;i<=n;i++)
            cntA[i]+=cntA[i-1];
        for(int i=cnt;i>=1;i--)
            A[cntA[l[i]]--]=i;
    }
    void solve()
    {
        while(scanf("%s",s+1)!=EOF)
        {
            int p=1;
            int len=0;
            for(int i=1;s[i];i++)
            {
                int x=s[i]-'a';
                if(next[p][x])
                {
                    p=next[p][x];
                    mmax[p]=max(mmax[p],++len);
                }
                else
                {
                    while(p&&!next[p][x]) p=fa[p];
                    if(!p)
                    {
                        p=1,len=0;
                    }
                    else
                    {
                        len=l[p]+1,p=next[p][x];
                        mmax[p]=max(mmax[p],len);
                    }
                }
            }
            for(int i=cnt;i>=1;i--)
            {
                p=A[i];
                mmin[p]=min(mmin[p],mmax[p]);
                if(fa[p])
                {
                    mmax[fa[p]]=max(mmax[fa[p]],mmax[p]);
                }
                mmax[p]=0;
            }
        }
        for(int i=1;i<=cnt;i++)
        {
            ans=max(ans,mmin[i]);
        }
    }
}sam;
int main()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    sam.init();
    for(int i=1;i<=n;i++)
        sam.add(s[i]-'a');
    sam.work();
    sam.solve();
    printf("%d\n",ans);
    return 0;
}

12：出现次数介于一定范围的子串个数

求给定的字符串有多少个本质不同子串出现次数介于a，b之间

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+5;
char s[2*maxn];
int n;
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2];
    int last,cnt;
    int cntA[maxn*2],A[maxn*2];
    int right[maxn*2];
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
    }
    void add(int c)
    {
        int p=last;
        int np=++cnt;
        right[np]=1;
        memset(next[cnt],0,sizeof next[cnt]);
        l[np]=l[p]+1;
        last=np;
        while(p&&!next[p][c])
            next[p][c]=np,p=fa[p];
        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                l[nq]=l[p]+1;
                memcpy(next[nq],next[q],sizeof next[q]);
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
    }
    void work()
    {
        memset(cntA,0,sizeof cntA);
        for(int i=1;i<=cnt;i++)
            cntA[l[i]]++;
        for(int i=1;i<=n;i++)
            cntA[i]+=cntA[i-1];
        for(int i=1;i<=cnt;i++)
            A[cntA[l[i]]--]=i;
        int p=1;
        for(int i=1;i<=n;i++)
        {
            p=next[p][s[i]-'a'];
            right[p]=1;
        }
        for(int i=cnt;i>=1;i--)
        {
            p=A[i];
            if(fa[p])
                right[fa[p]]+=right[p];
        }
    }
}sam;
int main()
{
    int a,b;
    while(scanf("%s",s)!=EOF)
    {
        scanf("%d%d",&a,&b);
        n=strlen(s);
        sam.init();
        for(int i=0;i<n;i++)
            sam.add(s[i]-'a');
        sam.work();
        long long ans=0;
        for(int i=1;i<=sam.cnt;i++)
        {
            if(a<=sam.right[i]&&sam.right[i]<=b)
            {
                ans+=sam.l[i]-sam.l[sam.fa[i]];//加上当前节点到父节点之间的不同子串个数
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}

 

13：求出现次数大于等于k的不同子串的个数

求给定字符串出现次数大于等于k的不同子串的个数且要求支持拓展字符串

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e4+5;
char s[2*maxn];
int n,m,k;
struct Suffix_Automation
{
    int next[maxn*2][26],fa[maxn*2],l[maxn*2];
    int ans;
    int last,cnt;
    int cntA[maxn*2],A[maxn*2];
    int num[maxn*2];
    void init()
    {
        last=cnt=1;
        fa[1]=l[1]=0;
        memset(next[1],0,sizeof next[1]);
        ans=0;
    }
    void add(int c)
    {
        int p=last;
        int np=++cnt;
        memset(next[cnt],0,sizeof next[cnt]);
        l[np]=l[p]+1;
        last=np;
        while(p&&!next[p][c])
            next[p][c]=np,p=fa[p];
        if(!p)
            fa[np]=1;
        else
        {
            int q=next[p][c];
            if(l[q]==l[p]+1)
                fa[np]=q;
            else
            {
                int nq=++cnt;
                memcpy(next[nq],next[q],sizeof next[q]);
                l[nq]=l[p]+1;
                num[nq] = num[q];
                fa[nq]=fa[q];
                fa[np]=fa[q]=nq;
                while(next[p][c]==q)
                    next[p][c]=nq,p=fa[p];
            }
        }
        int t=last;
		while(t)
        {
			if(num[t]>=k)
				break;
			num[t]++;
			if(num[t]==k)
				ans+=l[t]-l[fa[t]];
			t=fa[t];
		}
    }
}sam;
int main()
{
    char c[3];
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
		scanf("%s",s);
		n=strlen(s);
		sam.init();
		for(int i=0;i<n;i++)
		{
			sam.add(s[i]-'a');
		}
		while(m--)
		{
			int flag;
			scanf("%d",&flag);
			if(flag==1)
			{
				scanf("%s",c);
				sam.add(c[0]-'a');
			}
            else printf("%d\n",sam.ans);
		}
	}
    return 0;
}

 

Lv1_kangdi
关注
  • 8
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
AC自动机_AC自动机模板_
09-30
它的主要功能是高效地在一个字符串集合中进行多模式匹配，即同时查找多个模式串在主串中的出现位置。AC自动机在构建完成后，可以实现一次遍历输入文本，查找到所有匹配的模式串，其时间复杂度为O(n)，n代表输入文本...
后缀自动机（模板+例题）
weixin_30325071的博客
07-16 159
存个模板 void get_SAM(int w) {//加入的字母-'a' //c[w]域是一个DAG 存的是转移边 也就是后缀自动机 而par域是存辅助建后缀自动机的parent树 int x=++ndnum,tmp=lasts; nd[x].len=nd[lasts].len+1; //一直向下跳 直到在parent树上找到第一个包...
【学习笔记】后缀自动机基础和几个模板题
HaibaraAi的博客
07-24 81
刚开始学SAM，就从板子题开始叭 先贴几个原理讲解和证明： https://oi-wiki.org/string/sam/ https://www.luogu.com.cn/blog/Kesdiael3/hou-zhui-zi-dong-ji-yang-xie https://www.luogu.com.cn/blog/xzyxzy/solution-p3804 全看懂得看两三天… 主要要理解：自动机的图mp，对应的parent树fa，当前状态的最长字符串的长len，以及能间接求出来的当前状态的最短字符串长
后缀自动机模板题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,...
后缀自动机专题练习
HeartWine的博客
10-20 381
一、SAM的性质: SAMSAMSAM是个状态机。一个起点，若干终点。原串的所有子串和从SAMSAMSAM起点开始的所有路径一一对应，不重不漏。所以终点就是包含后缀的点。 每个点包含若干子串，每个子串都一一对应一条从起点到该点的路径。且这些子串一定是里面最长子串的连续后缀。 SAMSAMSAM问题中经常考虑两种边： (1)(1)(1) 普通边，类似于TrieTrieTrie。表示在某个状态所表示的所有子串的后面添加一个字符。 (2)(2)(2) Link、FatherLink、FatherLink、Fath
SAM(后缀自动机)的题型总结
最新发布
weixin_52624555的博客
10-17 368
sam
浙江大学ACM模板(经典代码)
04-24
4. **字符串处理**：KMP算法、后缀数组、后缀自动机等，这些在文本处理和模式匹配中极为重要。 5. **数学**：组合数学、数论、线性代数、概率统计等，许多算法问题需要用到这些基础知识。 6. **数据结构**：栈、...
ACM算法模板和pku代码
11-09
本科参加ACM竞赛的过程中积累下来的一部分算法模板，和自己在PKU上面做的一部分题目。 模板目录结构： 目录: 动态规划 O(n^2)的最长上升子序列 nlogn最长上升子序列 高精度 计算几何 Graham扫描法 两线段交点 凸...
邝斌的ACM模板1
08-03
6. **后缀自动机**：与后缀数组类似，但提供了更轻量级的实现，同样能快速处理字符串模式匹配问题。 在数学领域，模板涉及： 1. **素数**：包括素数的判断和生成，是许多数论问题的基础。 2. **素数筛选和合数分解*...
ACM算法模版大集合
10-15
一大堆模版 自己可以下来参考 应该有200个以上吧 自己下来看看 ... 后缀树/后缀数组 LCA/RMQ 有限状态自动机理论 排序 选择/冒泡 快速排序 堆排序 归并排序（OK） 基数排序 拓扑排序 排序网络
后缀自动机模板题hdu_[hdu4416 Good Article Good sentence]后缀自动机SAM
weixin_35823536的博客
01-17 96
题意：给出串A和串集合B={B1,B2,...,Bn}，求串A的所有不同子串中不是B中任一串的子串的数目。思路：把A和B中所有字符串依次拼接在一起，然后构造后缀自动机，计算每个状态的R集合元素的最大值r，然后统计那些r≤length(A)的状态。hdu不卡时间卡空间，这是最郁闷的。。。导致下面的程序只在本地随机数据没发现错误，提交就MLE。#include using namespace std;...
后缀自动机的一些简单题目
ctlchild的博客
09-20 621
对于后缀自动机的论文很多，这里记录一些比较简单的题目便于熟悉后缀自动机的基本应用 只有四道题目有一点少，今后会好好填坑 BZOJ4032: [HEOI2015]最短不公共子串 一句话题意：给两个串 A 和 B，求 A 最短子串且不是 B 的子串，A 最短子串且不是B的子序列，A 最短子序列且不是 B 的子串，A 最短子序列且不是 B 的子序列 做法：建出后缀自动机和序列自动机，自动机上每一条路径
后缀自动机应用及例题
生活不易，多才多艺
06-17 2149
后缀自动机…真的好难啊……. 想学的可以看陈立杰课件……以及众多题解 题目 题目 1. 洛谷P3804【模板】后缀自动机 2.spoj1811 LCS 3.spoj1812 LCS2 1. 洛谷P3804【模板】后缀自动机 题意：求字符串 S 中所有出现次数不为 1 的子串的出现次数乘上该子串长度的最大值。 做法：建立SAM，令叶子节点 size 等于 1...
HDU5558后缀自动机模板题
lixuepeng_001的博客
10-13 946
我只能说后缀自动机时间复杂度简直666     感叹clj神#include using namespace std; const int maxn=100005; const int SIGMA_SIZE=26; struct SAM_Node { SAM_Node *par,*next[SIGMA_SIZE]; int len,id,pos; SAM_Node()
[后缀自动机 模板题] SPOJ 8222 Substrings
雯舞
01-28 697
题目大意：求某个长度的所有子串中出现次数最多的次数每个状态对应一段长度区间的子串 right集合的大小就是出现次数 那么我们用|right(x)|去更新f[maxs[x]]的值，最后从大到小用f[i]去更新f[i-1]的值即可#include<cstdio> #include<cstdlib> #include<algorithm> using namespace std;inline char
后缀自动机习题集与归纳
guoshiyuan484的博客
09-04 1256
学习感悟：什么论文证明根本就看不懂。。。。。还是看代码，然后自己再yy下复杂度再理解下是最好的学习方法。。不要死扣论文！！！！！！ 理解后缀自动机的关键是明白它与后缀树的关系。要明白这一点后缀链接的性质fa(max)+1=son(min-1)有是另一个关键 多串的题目： 广义后缀自动机：广义的和狭义的主要区别就是广义的串是不连续转移的，狭义的一个串可以看成是多个串组合而成且连续转移。 其实
后缀自动机例题精讲
lleozhang的博客
04-20 576
这一篇是后缀自动机的一些例题题解及总结： 例： bzoj 3998 题意：求一个字符串中第k小子串，t=0表示子串仅区别字典序，t=1表示子串区分起止位置 解析：建起后缀自动机，构造parent树，利用后缀自动机有向无环累计子串个数查询即可 具体解析：https://blog.csdn.net/lleozhang/article/details/89413818 bzoj 2780 ...
后缀自动机题解
linjiayang2016的博客
09-20 395
后缀自动机(SAM)是一种优秀的数据结构，它作为一种自动机，不仅能接受一个字符串所有的后缀，还可以接受所有子串。
【后缀自动机】
weixin_33749131的博客
08-25 101
后缀自动机也是解决字符串问题的常用工具，犀利在O(N)的空间复杂度下存在给定串的后缀以及子串，而且支持在线的操作。 POJ-1509 Glass Beads 题意：求一个字符串的最小表示的开始下标。 分析：其实有一个O(N)的算法专门来解决这个问题，并且实现非常简单，不过后缀自动机同样能够解决这个问题。首先把这个串重复两次，然后从前往后一一将字符加入到后缀自动机中，最后从根开始向下遍历串的长...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值