bzoj4032-最短不公共子串

题意

给出两个长度小于等于2000的小写字母串，四个问题：

• A的最短子串不是B的子串
• A的最短子串不是B的子序列
• A的最短子序列不是B的子串
• A的最短子序列不是B的子序列

分析

虽然求的是不公共，但是这还是一个字符串的匹配问题，只不过是求匹配不到。

对于子串的匹配问题，可以使用后缀自动机。然而对于子序列的匹配问题，提出一种新的数据结构，称为子序列自动机。

子序列自动机是一个能够跑出一个串的所有子序列的有限状态机，基本思路是每个点存每一种字符下一次出现位置的点，这样就可以保证跑出所有的子序列，并且状态数是\(O(n)\)的。子序列自动机的构建方法很简单，只要从后往前扫一次，维护每个字符最后出现的位置即可，所以它只支持在前端添加字符。

这样的子序列自动机的空间复杂度都是\(O(n|s|)\)，其中\(s\)为字符集。构建的时间复杂度为\(O(n|s|)\)，一次转移是\(O(1)\)的。

然而如果字符集过大，这样的复杂度很明显是不能被支持的。注意到这其实是一个从后往前扫的过程，不断地维护一个序列，所以我们可以把这个数组换成一个可持久化线段树，那么这样的空间复杂度，构建复杂的都是\(O(nlog|s|)\)，一次转移就变成了\(O(log|s|)\)。

那么前两问就直接枚举A串的左端点，直接在两种自动机上跑一下即可。

后两问是与子序列有关的，所以可以考虑动态规划。设\(f[i]\)表示在自动机上走到\(i\)号点至少是多长的子序列，那么每次扫描每个点，往后转移一下即可。最终答案为\(f[null]\)（或程序中的\(f[0]\)，即空状态）。

代码

#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
#define print(x) printf("%d\n",x==inf?-1:x)
using namespace std;
int read(int a[]) {
    char c=getchar();
    int len=0;
    for (;!isalpha(c);c=getchar());
    for (;isalpha(c);c=getchar()) a[++len]=c-'a'+1;
    return len;
}
const int maxn=2e3+10;
const int maxc=27;
const int inf=0x3f3f3f3f;
int a[maxn],b[maxn];
int n,m,f[maxn][maxn<<1];
struct SAM {
    int t[maxn<<1][maxc],len[maxn<<1],link[maxn<<1],tot,last;
    SAM ():tot(1),last(1) {}
    void add(int x) {
        int nw=++tot,i;
        len[nw]=len[last]+1;
        for (i=last;i && !t[i][x];i=link[i]) t[i][x]=nw;
        if (i) {
            int p=t[i][x];
            if (len[p]==len[i]+1) link[nw]=p; else {
                int q=++tot;
                len[q]=len[i]+1;
                for (int j=i;j && t[j][x]==p;j=link[j]) t[j][x]=q;
                link[q]=link[p];
                link[p]=link[nw]=q;
                memcpy(t[q],t[p],sizeof t[p]);
            }
        } else link[nw]=1;
        last=nw;
    }
    void build(int a[],int n) {
        for (int i=1;i<=n;++i) add(a[i]);
    }
    int run(int a[],int n) {
        int now=1;
        for (int i=1;i<=n;++i) if (t[now][a[i]]) now=t[now][a[i]]; else return i;
        return inf;
    }
    int size() {
        return tot;
    }
} sam;
struct LAM {
    int t[maxn][maxc],aux[maxc],tot;
    void build(int a[],int n) {
        tot=n+1;
        for (int i=n;i;--i) {
            memcpy(t[i+1],aux,sizeof aux);
            aux[a[i]]=i+1;
        }
        memcpy(t[1],aux,sizeof aux);
    }
    int run(int a[],int n) {
        int now=1;
        for (int i=1;i<=n;++i) if (t[now][a[i]]) now=t[now][a[i]]; else {
            return i;
        }
        return inf;
    }
    int size() {
        return tot;
    }
} lam;
void up(int &x,int y) {
    x=min(x,y);
}
void one() {
    int ans=inf;
    for (int i=1;i<=n;++i) 
        up(ans,sam.run(a+i-1,n-i+1));
    print(ans);
}
void two() {
    int ans=inf;
    for (int i=1;i<=n;++i) 
        up(ans,lam.run(a+i-1,n-i+1));
    print(ans);
}
void three() {
    int ans=inf,dian=sam.size();
    memset(f,0x3f,sizeof f);
    f[0][1]=0;
    for (int i=1;i<=n;++i) {
        f[i][1]=0;
        for (int j=1;j<=dian;++j) f[i][j]=f[i-1][j];
        for (int j=1;j<=dian;++j) {
            up(f[i][sam.t[j][a[i]]],min(f[i-1][sam.t[j][a[i]]],f[i-1][j]+1));
        }
    }
    ans=f[n][0];
    print(ans);
}
void four() {
    int ans=inf,dian=lam.size();
    memset(f,0x3f,sizeof f);
    f[0][1]=0;
    for (int i=1;i<=n;++i) {
        f[i][1]=0;
        for (int j=1;j<=dian;++j) f[i][j]=f[i-1][j];
        for (int j=1;j<=dian;++j) {
            up(f[i][lam.t[j][a[i]]],min(f[i-1][lam.t[j][a[i]]],f[i-1][j]+1));
        }
    }
    ans=f[n][0];
    print(ans);
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("test.in","r",stdin);
    freopen("my.out","w",stdout);
#endif
    n=read(a);
    m=read(b);
    sam.build(b,m);
    lam.build(b,m);
    one();
    two();
    three();
    four();
    return 0;
}

转载于:https://www.cnblogs.com/owenyu/p/6818012.html