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;
}