[HEOI2015]最短不公共子串

题意：

给出两个字符串 $A$ 和 $B$ ，分别求出：
1.最短的串，是 $A$ 的子串，不是 $B$ 的子串。
2.最短的串，是 $A$ 的子串，不是 $B$ 的子序列。
3.最短的串，是 $A$ 的子序列，不是 $B$ 的子串。
4.最短的串，是 $A$ 的子序列，不是 $B$ 的子序列。

一道四合一题，如果分开做前两个好说，后两个得有点操作，不过由于我太菜做不得。而且暂时还不想学后两个点单独怎么做。

那我们把这四个看成一类问题。

考虑自动机：一个节点表示一个状态，每条边表示状态的转移。由于子串和子序列都能建出自动机来，那么我们只需要对两个自动机进行相同的转移，则 $A$ 中有而 $B$ 中没有的状态就是我们要找的答案。

子序列建成自动机这个应该都会，由于希望最长的匹配，肯定相同的字符越靠前越好。每个位置是一个点，向后每个字符往离它最近的点连边，时间复杂度与空间复杂度均为 $O(n*$ 字符集大小 $)$ 。

子串建成自动机可以选择前缀自动机也可选择后缀自动机，而这题数据范围是 $2000$ ，因为复杂度瓶颈并不在这里，当然如果不想考虑空间的话可以写 $sam$ 。我们这里只需要用 $trie$ 当自动机就可以了，把每个子串取出来建立一个 $trie$ ，字符总长度 $O(n^2)$ ，时间复杂度与空间复杂度均为 $O(n^2*字符集大小)$ 。看着大算算其实可过。

那么自动机就建好了，每次询问是什么，就把两个字符串建成相应的自动机就好了。那么现在考虑如何找答案。

因为一条边相当于加进去一个字符，我们进行 $BFS$ ，遇到第一个 $A$ 中存在而 $B$ 中不存在的状态就把长度 $+1$ 输出出来。如果遍历 $A$ 的完整个自动机（自动机肯定不会有环的），还没有找到一个 $B$ 中没有的状态，那 $A$ 就太逊了，输出 $-1$ 。

考虑 $BFS$ 复杂度： $trie$ 进行 $BFS$ 时，由于 $trie$ 是像树一样的结构，每个点只会被遍历一次，复杂度不会超过 $O(n^2)$ 。而当两个序列自动机进行遍历的时候，由于到达一个点可以通过不同的路径，如果无脑加点会被卡成指数级。我们需要用 $vis$ 数组记录一下哪些状态到达过，由于序列自动机节点有 $n$ 个，这样时间复杂度与空间复杂度也都是 $O(n^2)$ 的，而且这个复杂度瓶颈不可避，前面自然也就不需要那么优了。

不过要注意只有两个自动机同时为序列自动机的时候才用 $vis$ ，否则 $trie$ 那么多点也开不下是吧~

#include <bits/stdc++.h>
using namespace std;
const int N=101010;
const int qwq=2000100;
const int inf=0x3f3f3f3f;

struct T {

	char s[N];
	int n;
	int ch[qwq][26],cnt,now,rt;

	void trie() {
		memset(ch,0,sizeof(ch));
		rt = now = cnt = 1;
		for(int i=1;i<=n;i++) {
			now = rt;
			for(int j=i;j<=n;j++) {
				int c = s[j] - 'a';
				if(!ch[now][c]) ch[now][c] = ++cnt;
				now = ch[now][c];
			}
		}
	}

	void lie() {
		memset(ch,0,sizeof(ch));
		cnt = n; rt = 0;
		for(int i=1;i<=n;i++) {
			for(int j=i-1;j>=0;j--) {
				ch[j][ s[i]-'a' ] = i;
				if(s[j]==s[i]) break;
			}
		}
	}

} A,B;

struct E{ int x,y,le; };
queue <E> q;
bool vis[2333][2333];

int query() {
	bool flag = 0;
	if(A.rt==0 && B.rt==0) flag = 1;
	q.push( (E){A.rt,B.rt,0} );
	vis[A.rt][B.rt] = 1;
	while(!q.empty()) {
		E now = q.front(); q.pop();
		for(int i=0;i<25;i++) {
			int u = A.ch[now.x][i], v = B.ch[now.y][i];
			if(flag) { if(vis[u][v]) continue; }
			if(!u) continue;
			if(u && !v) { while(!q.empty()) q.pop(); return now.le+1; }
			q.push( (E){u,v,now.le+1} );
			if(flag) vis[u][v] = 1;
		}
	}
	return -1;
}

int main() {
	int ans4;
	scanf("%s%s",A.s+1,B.s+1);
	A.n = strlen(A.s+1); B.n = strlen(B.s+1);
	A.trie(); B.trie(); cout<<query()<<"\n";
	B.lie();            cout<<query()<<"\n";
	A.lie();            ans4 = query();
	B.trie();           cout<<query()<<"\n"<<ans4;
	return 0;
}

$sam$ 的做法：

后缀自动机时间建立的复杂度是 $O(n)$ 的，空间复杂度是 $O(n*26)$ 的，这让人很舒服，但是由于到达一个点同样有多条路径，我们每次 $BFS$ 都要记录 $vis$ 。

要注意 $sam$ 数组要开两倍。

#include <bits/stdc++.h>
using namespace std;
const int N=101010;
const int qwq=2000100;
const int inf=0x3f3f3f3f;

struct T {

	char s[2333];
	int n;
	int ch[4333][26],fa[4333],len[4333],cnt,now,rt;

	void insert(int c) {
		int u = now; now = ++cnt;
		len[cnt] = len[u] + 1;
		for(; u&&!ch[u][c]; u=fa[u]) ch[u][c] = cnt;
		if(!u) fa[cnt] = 1;
		else {
			int zjt = ch[u][c];
			if(len[zjt]==len[u]+1) fa[cnt] = zjt;
			else {
				int ob = cnt+1;
				memcpy(ch[ob],ch[zjt],sizeof(ch[zjt]));
				fa[ob] = fa[zjt]; len[ob] = len[u] + 1;
				fa[cnt] = fa[zjt] = ob;
				for(; u&&ch[u][c]==zjt; u=fa[u]) ch[u][c] = ob;
				cnt++;
			}
		}
	}

	void sam() {
		memset(ch,0,sizeof(ch));
		now = cnt = rt = 1;
		for(int i=1;i<=n;i++) insert(s[i]-'a');
	}

	void lie() {
		memset(ch,0,sizeof(ch));
		cnt = n; rt = 0;
		for(int i=1;i<=n;i++) {
			for(int j=i-1;j>=0;j--) {
				ch[j][ s[i]-'a' ] = i;
				if(s[j]==s[i]) break;
			}
		}
	}

} A,B;

struct E{ int x,y,le; };
queue <E> q;
bool vis[4333][4333];

int query() {
	memset(vis,0,sizeof(vis));
	q.push( (E){A.rt,B.rt,0} );
	vis[A.rt][B.rt] = 1;
	while(!q.empty()) {
		E now = q.front(); q.pop();
		for(int i=0;i<25;i++) {
			int u = A.ch[now.x][i], v = B.ch[now.y][i];
			if(vis[u][v] || !u) continue;
			if(u && !v) { while(!q.empty()) q.pop(); return now.le+1; }
			q.push( (E){u,v,now.le+1} );
			vis[u][v] = 1;
		}
	}
	return -1;
}

int main() {
	int ans4;
	scanf("%s%s",A.s+1,B.s+1);
	A.n = strlen(A.s+1); B.n = strlen(B.s+1);
	A.sam(); B.sam(); cout<<query()<<"\n";
	B.lie();            cout<<query()<<"\n";
	A.lie();            ans4 = query();
	B.sam();           cout<<query()<<"\n"<<ans4;
	return 0;
}