ZOJ3784 String of Infinity(AC自动机&&强连通分量)

题意：给你n个禁止串，然后你只能用字符表的前m个字符去写一个无限长的串，要求是不能包含禁止串，而且串在后面不能出现循环

比赛的时候想的是先建一个自动机，然后将自动机确定化，不能到达的状态全部弄出来。但是对于剩下的状态就卡住了，我怎么才能知道这些状态会构成循环呢？后来看了别人的代码，看到了强连通分量，我就恍然大悟了。其实只需要对剩下的未确定的状态，根据转移边建图，然后跑一次强连通分量。

这么做的效果就是将原图剩下的状态缩成了一个DAG，我们每次只能由根结点往下走，我们必然需要停留在某个强连通分量里，不然的话我走到拓扑序最后的分量就不能再走了（或者说走到拓扑序最后的话，就只能在那个强连通分量沿着分量内的边走“自环”）。如果这个强连通分量是一个环的话，那么显然我们停留在这个强连通分量里的话就会有循环节。所以问题转化为是否存在一个强连通分量它不是一个环。判断方法就是维系一个大小为n的强连通分量至少需要n条边，只要强连通分量内的边大于n，它就不是一个自环。

#pragma warning(disable:4996)
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#include <vector>
#include<queue>
#include<stack>
#include <cmath>
using namespace std;

#define maxn 210000
#define ll long long

int n, m;

struct Trie{
	Trie *fail, *go[26];
	bool ter; bool flag;
	void init(){
		memset(go, 0, sizeof(go)); fail = NULL; ter = false; flag = false;
	}
}pool[maxn], *root;
int tot;

void insert(char *c){
	int len = strlen(c); Trie *p = root;
	for (int i = 0; i < len; i++){
		if (p->go[c[i] - 'a'] != 0) p = p->go[c[i] - 'a'];
		else{
			pool[tot].init();
			p->go[c[i] - 'a'] = &pool[tot++];
			p = p->go[c[i] - 'a'];
		}
	}
	p->ter = true;
}

void getFail()
{
	queue<Trie*> que;
	que.push(root);
	root->fail = NULL;
	while (!que.empty()){
		Trie *temp = que.front(); que.pop();
		Trie *p = NULL;
		for (int i = 0; i < m; i++){
			if (temp->go[i] != NULL){
				if (temp == root) temp->go[i]->fail = root;
				else{
					p = temp->fail;
					while (p != NULL){
						if (p->go[i] != NULL){
							temp->go[i]->fail = p->go[i]; break;
						}
						p = p->fail;
					}
					if (p == NULL) temp->go[i]->fail = root;
				}
				que.push(temp->go[i]);
			}
		}
	}
}

bool ddfs(Trie *p){
	if (p == root||p==NULL) return false;
	if (p->flag == true) return p->ter;
	p->ter |= ddfs(p->fail); p->flag = true;
	return p->ter;
}

int pre[maxn], low[maxn], sccno[maxn],siz[maxn];
int sta[maxn],st;
int dfs_clock;
int scc_cnt;

int siz2[maxn];

void dfs(int u){
	low[u] = pre[u] = ++dfs_clock;
	sta[++st] = u;
	for (int i = 0; i < m; i++){
		Trie *p = pool[u].go[i];
		if (p->ter) continue;
		int v = p - pool;
		if (!pre[v]){
			dfs(v); low[u] = min(low[u], low[v]);
		}
		else if (!sccno[v]){
			low[u] = min(low[u], pre[v]);
		}
	}
	if (low[u] == pre[u]){
		++scc_cnt;
		while (1){
			int x = sta[st--]; sccno[x] = scc_cnt;
			siz[scc_cnt]++;
			if (x == u) break;
		}
	}
}
void find_scc()
{
	memset(siz, 0, sizeof(siz));
	memset(sccno, 0, sizeof(sccno));
	memset(low, 0, sizeof(low));
	memset(pre, 0, sizeof(pre));
	st = dfs_clock = 0; scc_cnt = 0;
	for (int i = 0; i < tot; i++){
		if (pool[i].ter) continue;
		if (!pre[i]) dfs(i);
	}
}

char str[1500];

int main()
{
	int T; cin >> T;
	while (T--)
	{
		cin >> n >> m;
		tot = 0; root = &pool[tot++]; root->init();
		for (int i = 0; i < n; i++){
			scanf("%s", str);
			insert(str);
		}
		getFail();
		for (int i = 0; i < tot; i++) ddfs(&pool[i]);
		for (int i = 0; i < tot; i++){
			Trie *p = &pool[i];
			for (int k = 0; k < m; k++){
				if (p->go[k] == NULL){
					Trie *temp = p; temp = temp->fail;
					while (temp != NULL){
						if (temp->go[k] != NULL) {
							p->go[k] = temp->go[k]; break;
						}
						temp = temp->fail;
					}
					if (temp == NULL) p->go[k] = root;
				}
			}
		}
		find_scc();
		memset(siz2, 0, sizeof(siz2));
		for (int i = 0; i < tot; i++){
			if (pool[i].ter) continue;
			for (int j = 0; j < m; j++){
				int k = pool[i].go[j] - pool;
				if (sccno[k] == sccno[i]){
					siz2[sccno[k]]++;
				}
			}
		}
		bool flag = false;
		for (int i = 1; i <= scc_cnt; i++){
			if (siz2[i]>siz[i]){
				flag = true; break;
			}
		}
		if (flag) puts("Yes");
		else puts("No");
	}
	return 0;
}