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

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

1：存在性查询

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

#include
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
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
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
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
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
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
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
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
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
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
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

 

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

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

#include
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