题意
给出两个长度小于等于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
",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;
}