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