后缀自动机

最新推荐文章于 2022-09-01 20:10:41 发布

GDRetop

最新推荐文章于 2022-09-01 20:10:41 发布

阅读量794

点赞数

分类专栏： ##ACM-ICPC编程题 ##字符串 ACM之数据结构文章标签： acm hdu4622 spoj1811 后缀自动机字符串

本文链接：https://blog.csdn.net/firenet1/article/details/38310801

版权

##ACM-ICPC编程题同时被 3 个专栏收录

173 篇文章 0 订阅

订阅专栏

ACM之数据结构

15 篇文章 2 订阅

订阅专栏

##字符串

6 篇文章 0 订阅

订阅专栏

后缀自动机学习

后缀自动机就是能识别一个串的所有后缀，附加功能是可以识别所有字串，还能统计字串个数。

后缀自动机的parent是指该节点的父亲，len表示这个节点能表示的最长字串的长度

child[][]表示该节点添加一个字符能到达的状态。。

spoj1811 求两个串的最长公共字串

解法：用a串建立后缀自动机，然后用b串在自动机上跑，其中parent数组记录节点的父亲，len记录该节点能表示的最大字串长度

定义长度为num，如果遇到字符x存在孩子child[u]那么num++，否则找父亲节点，直到找到有child[u]的节点

同时令num=len[u]+1(父亲节点的len值一定是跟从根到该节点长度一致的的）

如果失配了，也就是访问到根，那么num=0，不断记录num的最大值即可

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define maxn  510000
struct Auto_Sufix{
    int parent[maxn];
    int child[maxn][26];
    int len[maxn];
    int last;
    int cnt;
    int newNode(){
        memset(child[cnt],0,sizeof(child[cnt]));
        len[cnt] = parent[cnt] = 0;
        return cnt++;
    }
    void init(){
        last  = cnt = 1;
        newNode();
    }
    void add(int x){
        int np = newNode(),pa = last;
        len[np] = len[last]+1;
        while(pa && !child[pa][x])child[pa][x]=np,pa=parent[pa];
        if(pa == 0) parent[np] = 1;
        else if(len[pa]+1==len[child[pa][x]]) parent[np]=child[pa][x];
        else {
            int nq = newNode(),p=child[pa][x];
            memcpy(child[nq],child[p],sizeof(child[p]));
            len [nq] = len[pa]+1;
            parent[nq] = parent[p];
            parent[np] = parent[p] = nq;
            for(;pa&&child[pa][x]==p;child[pa][x]=nq,pa=parent[pa]);
        }
        last = np;
    }
    int getmore(){
        int pa = parent[last];
        return len[last]-len[pa];
    }

    int getMaxCommon(char*word){
        int len1 = strlen(word);
        int ans = 0,num=0,u=1,x;
        for(int i = 0;i < len1; i++){
            x = word[i]-'a';
            if(child[u][x] != 0 ){
                num++,u=child[u][x];
            }
            else {
                while(u&&!child[u][x]) u=parent[u];
                if(u==0)u=1,num=0;
                else num=len[u]+1,u=child[u][x];
            }
            ans=max(ans,num);
        }
        return ans;
    }
};


Auto_Sufix sufix;
char word[maxn];
int main(){
    while(scanf("%s",word)!=EOF){
        sufix.init();
        int len = strlen(word);
        for(int i = 0;i < len ;i++)
            sufix.add(word[i]-'a');
        scanf("%s",word);
        int ans= sufix.getMaxCommon(word);
        printf("%d\n",ans);
    }
    return 0;
}

spoj1812 求多个串的最长公共字串

跟上一题类似，先建立一个自动机，然后用其他串在上面跑

用ans数组记录当前串到每个状态得到的最大长度，用原来的自动机的len记录所有串到达这些状态的公共长度的最大值

但是在跟新len值的时候需要注意：因为一个状态能表示的长度大于其父亲状态的长度，如果到达这个状态了，说明其

父亲状态也是可达，同时父亲的父亲。。。也是可达的。所以还需要跟新父亲状态的ans值

因为后缀自动机的节点是一个拓扑图，没有环路的有向图，根据定义len越大的状态能表示的字串越多，其父亲的状态的len

必然小于他的len值，对这些状态的len值拍个序，就能实现逆拓扑序了，采用基数排序，可以做到o(n)的排序

然后用len值最大的节点跟新len，在用这个节点跟新该父亲的ans即可

top[i]记录的就是len值排在i位的节点的下标

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define maxn  210000
struct Auto_Sufix{
    int parent[maxn];
    int child[maxn][26];
    int len[maxn];
    int last;
    int cnt;
    int newNode(){
        memset(child[cnt],0,sizeof(child[cnt]));
        len[cnt] = parent[cnt] = 0;
        return cnt++;
    }
    void init(){
        last  = cnt = 1;
        newNode();
    }
    void add(int x){
        int np = newNode(),pa = last;
        len[np] = len[last]+1;
        while(pa && !child[pa][x])child[pa][x]=np,pa=parent[pa];
        if(pa == 0) parent[np] = 1;
        else if(len[pa]+1==len[child[pa][x]]) parent[np]=child[pa][x];
        else {
            int nq = newNode(),p=child[pa][x];
            memcpy(child[nq],child[p],sizeof(child[p]));
            len [nq] = len[pa]+1;
            parent[nq] = parent[p];
            parent[np] = parent[p] = nq;
            for(;pa&&child[pa][x]==p;child[pa][x]=nq,pa=parent[pa]);
        }
        last = np;
    }
    int getmore(){
        int pa = parent[last];
        return len[last]-len[pa];
    }

};
Auto_Sufix sufix;
char word[maxn];
int ans[maxn];
int top[maxn];
int main(){
    gets(word);
    sufix.init();
    int len = strlen(word);
    for(int i = 0;i < len ;i++)
        sufix.add(word[i]-'a');
    memset(ans,0,sizeof(ans));

    int t = 0;

    for(int i = 0;i < sufix.cnt;i++) ans[i]=0;
    for(int i = 0;i < sufix.cnt;i++) ans[sufix.len[i]]++;
    for(int i = 1;i < sufix.cnt;i++) ans[i] += ans[i-1];
    for(int i = sufix.cnt-1;i>0;i--) top[--ans[sufix.len[i]]]=i;
    memset(ans,0,sizeof(ans));

    while(gets(word)){
        int len1 = strlen(word);
        int num=0,u=1,x;
        for(int i = 0;i < len1; i++){
            x = word[i]-'a';
            if(sufix.child[u][x] != 0 ){
                num++,u=sufix.child[u][x];
            }
            else {
                while(u&&!sufix.child[u][x]) u=sufix.parent[u];
                if(u==0)u=1,num=0;
                else num=sufix.len[u]+1,u=sufix.child[u][x];
            }
            ans[u] = max(ans[u],num);
        }
        for(int i = sufix.cnt-1;i>1;i--){
            u = top[i];
            sufix.len[u] = min(sufix.len[u],ans[u]);
            ans[sufix.parent[u]] = max(ans[sufix.parent[u]],ans[u]);
            ans[u] = 0;
        }
    }
    int res  = 0 ;
    for(int i = 2;i < sufix.cnt;i++)
        res = max(res,sufix.len[i]);
    printf("%d\n",res);
    return 0;
}

hdu 4416Good Article Good sentence

求一个字符串A 的所有不重复字串的个数，同时这些子串不出现在s1,s2,.....sn中

同样用A建立一个自动机，然后开一个len1数组，记录的是s1到sn在这个自动机上跑能得到字串长度的最大值

同样用逆拓扑序遍历最后生成的len1数组，且需要跟新每个节点的父亲节点。记录len1[u]-len[parenrt[u]]]表示到达的这个状态最多可以表示

几个字串，可能为负数，因为不可达，那么取0和该值得最大值。

父亲节点的值为len1[u]和len[paren[u]]的最小值，防止重复计算

然后用a串的字串数-重复的字串数就是答案，可能超int

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 200001
int parent[maxn],child[maxn][26],len[maxn],len1[maxn];
int cnt,last;
int newNode(){
    memset(child[cnt],0,sizeof(child[cnt]));
    len[cnt] = parent[cnt] = 0;
    return cnt++;
}
void init(){
    cnt = last = 1;
    newNode();
}

void add(int x){
    int pa = last, np = newNode();
    len[np] = len[pa]+1;
    last = np;
    while(pa && !child[pa][x]) child[pa][x] = np,pa=parent[pa];
    if(pa == 0) parent[np] = 1;
    else if(len[child[pa][x]] == len[pa]+1) parent[np] = child[pa][x];
    else {
        int nq = newNode(), p = child[pa][x];
        memcpy(child[nq],child[p],sizeof(child[nq]));
        parent[nq] = parent[p];
        len[nq] = len[pa]+1;
        parent[p] = parent[np] = nq;
        while(pa && child[pa][x] == p) child[pa][x]=nq,pa=parent[pa];
    }
}
#define ll long long
ll getmore(){
    ll ans = 0;
    for(int i = 2;i < cnt;i++)
        ans += len[i]-len[parent[i]];
    return ans;
}

char word[maxn];
int bucket[maxn],top[maxn];
int main(){
    int t,n,lenth;
    scanf("%d",&t);
    for(int tt = 1; tt <= t; tt++){
        scanf("%d\n",&n);
        gets(word);
        lenth = strlen(word);
        init();
        for(int i = 0;i < lenth; i++)
            add(word[i]-'a');
        ll ans = getmore();
        for(int i = 0;i < cnt; i++)len1[i] = 0;

        while(n--){
            gets(word);
            lenth = strlen(word);
            int u=1,x,sum=0;
            for(int i = 0;i < lenth; i++){
                x = word[i]-'a';
                if(child[u][x] != 0) u = child[u][x],sum++;
                else {
                    while(u&&child[u][x]==0)u=parent[u];
                    if(u == 0) u=1,sum=0;
                    else sum=len[u]+1,u=child[u][x];
                }
                len1[u] = max(sum,len1[u]);
            }
        }
        for(int i = 0;i < cnt;i++)bucket[i] = 0;
        for(int i = 0;i < cnt;i++)bucket[len[i]]++;
        for(int i = 1;i < cnt;i++)bucket[i]+=bucket[i-1];
        for(int i = cnt-1;i >=0;i--)top[--bucket[len[i]]]=i;
        long long  res = 0;
        int u,n;
        for(int i = cnt-1;i > 1;i--){
            u = top[i];
//            if(len1[u] == 0) res+=len[u]-len[parent[u]];
//            else if(len1[u]<len[u])res+=len[u]-len1[u];
//            len1[parent[u]] = max(len1[parent[u]],len1[u]);
            n = max(0,len1[u]-len[parent[u]]);
            res+=n;
            if(parent[u])len1[parent[u]] = min(len[parent[u]],max(len1[u],len1[parent[u]]));
        }
        printf("Case %d: %I64d\n",tt,ans-res);

    }
    return 0;
}

hdu 4622Reincarnation多校题

给一个字符串，给一些询问求在某一个区间字串个数

后缀自动机枚举不同起点，ans[i][j]表示从i到j的字串个数

然后在线回答即可。离线回答可能快一些，可以减去一些不必要的起点

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define maxn 4007
struct Auto_Sufix{
    int parent[maxn];
    int child[maxn][26];
    int len[maxn];
    int last;
    int cnt;
    int newNode(){
        memset(child[cnt],0,sizeof(child[cnt]));
        len[cnt] = parent[cnt] = 0;
        return cnt++;
    }
    void init(){
        last = cnt = 1;
        newNode();
    }
    void add(int x){
        int np = newNode(),pa = last;
        len[np] = len[last]+1;
        last = np;

        while(pa && !child[pa][x])child[pa][x]=np,pa=parent[pa];
        if(pa == 0) parent[np] = 1;
        else if(len[pa]+1==len[child[pa][x]]) parent[np]=child[pa][x];
        else {
            int nq = newNode(),p=child[pa][x];
            memcpy(child[nq],child[p],sizeof(child[p]));
            len [nq] = len[pa]+1;
            parent[nq] = parent[p];
            parent[np] = parent[p] = nq;
            for(;pa&&child[pa][x]==p;child[pa][x]=nq,pa=parent[pa]);
        }
    }
    int getmore(){
        int pa = parent[last];
        return len[last]-len[pa];
    }
};


Auto_Sufix sufix;
char word[maxn];
int ans[maxn][maxn];
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%s",word);
        memset(ans,0,sizeof(ans));
        int n = strlen(word);
        for(int i = 0;i < n; i++){
            sufix.init();
            for(int j = i;j < n; j++){
                sufix.add(word[j]-'a');
                ans[i][j] = ans[i][j-1]+sufix.getmore();
            }
        }
        int q,b,t;
        scanf("%d",&q);
        while(q--){
            scanf("%d%d",&b,&t);
            printf("%d\n",ans[b-1][t-1]);
        }

    }
    return 0;
}

hdu 4436 str2int

给一些数字字符串，求这些字符串的字串（不重复的，没有前缀0）的和。

将这些字符串用一个连接符连接起来，然后建立后缀自动机

然后按照len值的大小排序

因为不能有前缀0，所以根节点不能访问0的孩子节点

用sum[u]标记u这个所有能到这个点的数值之和，num[u]表示有多少个路径到这里

那么sum[u]就是以u结束的数的和然后转移的时候，sum[u]*10+num[u]*j j表示后面接的数字

所有合法的sum[u]之和就是答案

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 200007
#define mod 2012
int parent[maxn],child[maxn][11],len[maxn];
int cnt,last;
int newNode(){
    memset(child[cnt],0,sizeof(child[cnt]));
    len[cnt] = parent[cnt] = 0;
    return cnt++;
}
void init(){
    cnt = last = 1;
    newNode();
}

void add(int x){
    int pa = last, np = newNode();
    len[np] = len[pa]+1;
    last = np;
    while(pa && !child[pa][x]) child[pa][x] = np,pa=parent[pa];
    if(pa == 0) parent[np] = 1;
    else if(len[child[pa][x]] == len[pa]+1) parent[np] = child[pa][x];
    else {
        int nq = newNode(), p = child[pa][x];
        memcpy(child[nq],child[p],sizeof(child[nq]));
        parent[nq] = parent[p];
        len[nq] = len[pa]+1;
        parent[p] = parent[np] = nq;
        while(pa && child[pa][x] == p) child[pa][x]=nq,pa=parent[pa];
    }
}

char word[maxn];
int bucket[maxn],top[maxn];
int num[maxn],sum[maxn];
int main(){
    int t;
    while(scanf("%d",&t)!=EOF){
        int len1 = 0;
        for(int i = 0;i < t;i++){
            scanf("%s",&word[len1]);
            len1 += strlen(&word[len1]);
            word[len1++]='0'+10;
        }
        init();
        for(int i = 0;i < len1;i++)
            add(word[i]-'0');

        memset(bucket,0,sizeof(bucket));
        for(int i = 1;i < cnt; i++)bucket[len[i]]++;
        for(int i = 1;i < cnt; i++)bucket[i]+=bucket[i-1];
        for(int i = cnt-1;i > 0;i--)top[--bucket[len[i]]]=i;

        memset(num,0,sizeof(num));
        memset(sum,0,sizeof(sum));
        num[1]=1;
        int ans = 0,v,res,u,j;
        for(int i = 0;i<cnt-1;i++){
            u = top[i];
            for(j = 0;j < 10;j++){
                if(j == 0 && u == 1) continue;
                if(child[u][j]==0)continue;

                v = child[u][j];
                num[v]+=num[u];
                if(num[v] >= mod)num[v]-=mod;
                res = sum[u]*10 + num[u]*j;
                sum[v]+=res;
                sum[v]%=mod;
            }
            ans+=sum[u];
            if(ans >= mod)ans-=mod;
        }
        ans%=mod;
        printf("%d\n",ans);
    }
    return 0;
}