SPOJ Longest Common Substring II

素颜马尾好姑娘i 2022-08-04 04:26 138阅读 0赞

求十个串的最长连续公共子串。  
第一个串建立自动机。  
用其它每个串在自动机上跑一遍，记录每个状态上能匹配的最长长度。  
然后求每个状态匹配长度的最小值。

注意每个状态能匹配的，每个状态的父节点也能匹配。  
利用拓扑排序（按照len），从深到浅依次更新父亲的匹配长度。

模板敲错了，TLE了一个早上。

// whn6325689
    // Mr.Phoebe
    // http://blog.csdn.net/u013007900
    #include <algorithm>
    #include <iostream>
    #include <iomanip>
    #include <cstring>
    #include <climits>
    #include <complex>
    #include <fstream>
    #include <cassert>
    #include <cstdio>
    #include <bitset>
    #include <vector>
    #include <deque>
    #include <queue>
    #include <stack>
    #include <ctime>
    #include <set>
    #include <map>
    #include <cmath>
    #include <functional>
    #include <numeric>
    #pragma comment(linker, "/STACK:1024000000,1024000000")
    
    using namespace std;
    
    #define eps 1e-9
    #define PI acos(-1.0)
    #define INF 0x3f3f3f3f
    #define LLINF 1LL<<62
    #define speed std::ios::sync_with_stdio(false);
    
    typedef long long ll;
    typedef unsigned long long ull;
    typedef long double ld;
    typedef pair<ll, ll> pll;
    typedef complex<ld> point;
    typedef pair<int, int> pii;
    typedef pair<pii, int> piii;
    typedef vector<int> vi;
    
    #define CLR(x,y) memset(x,y,sizeof(x))
    #define CPY(x,y) memcpy(x,y,sizeof(x))
    #define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
    #define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))
    
    #define mp(x,y) make_pair(x,y)
    #define pb(x) push_back(x)
    #define lowbit(x) (x&(-x))
    
    #define MID(x,y) (x+((y-x)>>1))
    #define ls (idx<<1)
    #define rs (idx<<1|1)
    #define lson ls,l,mid
    #define rson rs,mid+1,r
    #define root 1,1,n
    
    template<class T>
    inline bool read(T &n)
    {
        T x = 0, tmp = 1;
        char c = getchar();
        while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
        if(c == EOF) return false;
        if(c == '-') c = getchar(), tmp = -1;
        while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
        n = x*tmp;
        return true;
    }
    template <class T>
    inline void write(T n)
    {
        if(n < 0)
        {
            putchar('-');
            n = -n;
        }
        int len = 0,data[20];
        while(n)
        {
            data[len++] = n%10;
            n /= 10;
        }
        if(!len) data[len++] = 0;
        while(len--) putchar(data[len]+48);
    }
    //-----------------------------------
    
    const int MAXN=100010;
    const int MAC=27;
    
    struct SAM
    {
        int len[MAXN<<1],next[MAXN<<1][MAC],fa[MAXN<<1],L,last;
        SAM()
        {
            init();
        }
        void init()
        {
            L=0;
            last=newnode(0,-1);
        }
        int newnode(int l,int pre)
        {
            fa[L]=pre;
            mat[L]=0;
            for(int i=0; i<MAC; i++)    next[L][i]=-1;
            len[L]=l;
            return L++;
        }
        void build(char *p)
        {
            int le=strlen(p);
            for(int i=0; i<le; i++)
                add(p[i]-'a',i);
        }
        void add(int x,int l)
        {
            int pre=last,now=newnode(len[pre]+1,-1);
            last=now;
            while(~pre&&next[pre][x]==-1)
            {
                next[pre][x]=now;
                pre=fa[pre];
            }
            if(pre==-1)fa[now]=0;
            else
            {
                int bro=next[pre][x];
                if(len[bro]==len[pre]+1)
                {
                    fa[now]=bro;
                }
                else
                {
                    int fail=newnode(len[pre]+1,fa[bro]);
                    for(int i=0; i<26; i++)
                    {
                        next[fail][i]=next[bro][i];
                    }
                    fa[bro]=fa[now]=fail;
                    while(~pre&&next[pre][x]==bro)
                    {
                        next[pre][x]=fail;
                        pre=fa[pre];
                    }
                }
            }
        }
        int sum[MAXN<<1],topo[MAXN<<1];
        void toposort()
        {
            CLR(sum,0);
            for(int i=0; i<L; i++)
            {
                sum[len[i]]++;
                allmat[i]=len[i];
            }
            for(int i=1; i<L; i++)    sum[i]+=sum[i-1];
            for(int i=0; i<L; i++)    topo[sum[len[i]]--]=i;
        }
        int mat[MAXN<<1],allmat[MAXN<<1];
        int find(char *s)
        {
            int ans=0,now=0,cnt=0;
            int n=strlen(s);
            for(int i=0; i<n; i++)
            {
                int x=s[i]-'a';
                if(~next[now][x])
                {
                    cnt++;
                    now=next[now][x];
                    mat[now]=max(mat[now],cnt);
                }
                else
                {
                    while(~now && next[now][x]==-1)
                    {
                        now=fa[now];
                    }
    
                    if(now==-1)
                        cnt=0;
                    else
                    {
                        cnt=len[now]+1;
                        now=next[now][x];
                        mat[now]=max(mat[now],cnt);
                    }
                }
            }
            for(int i=L-1; i>=0; i--)
                mat[fa[topo[i]]]=max(mat[fa[topo[i]]],mat[topo[i]]);
            for(int i=L-1; i>=1; i--)
            {
                allmat[i]=min(allmat[i],mat[i]);
                //cout<<allmat[i]<<" ("<<mat[i]<<")"<<" ";
                mat[i]=0;
            }
            //cout<<endl;
        }
    } T;
    char str[MAXN];
    
    int main()
    {
    // freopen("data.txt","r",stdin);
        scanf("%s",str);
        T.build(str);
        T.toposort();
        while(scanf("%s",str)!=EOF)
        {
            T.find(str);
        }
        int ans=0;
        for(int i=1; i<T.L; i++)
            ans=max(ans,T.allmat[i]);
        write(ans),putchar('\n');
        return 0;
    }

用队列进行逆拓扑

#include<vector>
    #include<iostream>
    #include<bits/stdc++.h>
    #include<cstring>
    #include<cmath>
    #include<algorithm>
    #include<cstdio>
    #define MAXN 2010000
    #pragma comment(linker, "/STACK:102400000,102400000")
    typedef long long LL;
    struct sam{
        int len[MAXN],next[MAXN][26],fail[MAXN],L,last,dp[MAXN],right[MAXN],deg[MAXN],vs[MAXN];
        sam(){
            init();
        }
        void init(){
            L=0;
            last=newnode(0,-1);
        }
        int newnode(int l,int pre)
        {
            fail[L]=pre;
            for(int i=0;i<26;i++)next[L][i]=-1;
            len[L]=l;
            right[L]=0;
            L++;
            return L-1;
        }
        void add(int x,int l)
        {
            int pre=last,now=newnode(l+1,-1);
            last=now;
            right[last]++;
            while(~pre&&next[pre][x]==-1){
                next[pre][x]=now;
                pre=fail[pre];
            }
            if(pre==-1)fail[now]=0;
            else{
                int bro=next[pre][x];
                if(len[bro]==len[pre]+1){
                    fail[now]=bro;
                }
                else{
                    int fa=newnode(len[pre]+1,fail[bro]);
                    for(int i=0;i<26;i++){
                        next[fa][i]=next[bro][i];
                    }
                    fail[bro]=fa,fail[now]=fa;
                    while(~pre&&next[pre][x]==bro){
                        next[pre][x]=fa;
                        pre=fail[pre];
                    }
                }
            }
        }
        void build(std::string s)
        {
            int n=s.length();
            for(int i=0;i<n;i++){
                add(s[i]-'a',i);
            }
            memset(deg,0,sizeof deg);
            for(int i=1;i<L;i++){
                dp[i]=len[i];
            // printf("len[%d]=%d\n",i,len[i]);
                if(~fail[i])deg[fail[i]]++;
            }
            int h=0,t=0;
            for(int i=0;i<L;i++){
                if(!deg[i])vs[t++]=i;
            }
            while(h<t){
                int v=vs[h++];
                if(~fail[v]){
                    deg[fail[v]]--;
                    if(!deg[fail[v]]){
                        vs[t++]=fail[v];
                    }
                }
            }
         // printf("%d____%d\n",L,t);
          /* for(int i=0;i<L;i++){ printf("len[%d]=%d____right:%d____fail:%d\n",i,len[i],right[i],fail[i]); for(int j=0;j<26;j++){ if(~next[i][j]){ printf("next[%d][%c]=%d\n",i,j+'a',next[i][j]); } } }*/
        }
        void query(std::string s)
        {
            int n=s.length(),pre=0,res=0;
            for(int i=0;i<L;i++){
                right[i]=0;
            }
            for(int i=0;i<n;i++){
                int x=s[i]-'a';
                if(~next[pre][x]){
                    pre=next[pre][x];
                    res++;
                    right[pre]=std::max(right[pre],res);
                }
                else{
                    while(~pre&&next[pre][x]==-1){
                        pre=fail[pre];
                    }
                    if(~pre){
                        res=len[pre]+1;
                        pre=next[pre][x];
                        right[pre]=std::max(right[pre],res);
                    }
                    else res=0;
                }
               // printf("right[%d]=%d__%d\n",pre,right[pre],res);
            }
            for(int i=0;i<L;i++){
                right[fail[vs[i]]]=std::max(right[fail[vs[i]]],right[vs[i]]);
            }
            for(int i=0;i<L;i++){
    
                dp[i]=std::min(dp[i],right[i]);
            }
        }
    }SAM;
    std::string s;
    int main()
    {
        std::cin>>s;
        SAM.init();
        SAM.build(s);
        while(std::cin>>s){
            SAM.query(s);
        }
        int ans=0;
        for(int i=0;i<SAM.L;i++){
            ans=std::max(ans,SAM.dp[i]);
        }
        printf("%d\n",ans);
        return 0;
    }