poj_3987 Trie图

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
#define LETTERS 26
#define MAX_NODES 500000
#define MAX_VIRUS_LEN 1004
#define MAX_PROGRAM_LEN 5100005
#define MAX_VIRUS_NUM 255
char gProgram[MAX_PROGRAM_LEN];
bool gVirusVisited[MAX_VIRUS_NUM];
int gVirusFindNum;
int gVirusNum;
struct Node{
	Node* childs[LETTERS];
	Node* prev;
	bool danger_node;
	int pattern_index;
	bool visited;			//判断节点是否被访问过

	//在trie图中遇到一个危险节点N（不一定为终止节点），此时母串遍历到当前位置P，可以确定在P之前，肯定出现了模式串
	//在N第一次被访问的时候，可以通过前缀指针找到N之前的所有模式串
	//(需要不断的找prev，直到node到达根节点，比如 ABCDE中有模式串 BCDE, CDE, DE，需要不断的找前缀指针直到root，来防止遗漏某个模式串）

	
	//遇到危险节点N，向前找前缀指针的时候，碰到某个之前被访问过的节点A，即可返回
	//这是因为，若A为危险节点，则它肯定在第一次被访问的时候就进行和N相同的处理（向前找模式串）
	//若A不是危险节点，在第一次被访问的时候，通过A的前缀指针，前缀指针的前缀指针....能到达的模式串都被找到了。因此之后
	//再次碰到A，直接返回即可。
};


Node gNodes[MAX_NODES];
int gNodeCount;
void Insert(Node* root, char* str, int pat){
	char*p = str;
	Node* node = root;
	while (*p != ‘\0‘){
		int index = *p - ‘A‘;
		if (node->childs[index] == NULL){
			node->childs[index] = gNodes + gNodeCount++;
		}
		node = node->childs[index];
		p++;
	}
	node->danger_node = true;
	if (node->pattern_index == 0)
		node->pattern_index = pat;
	else{	//有可能两个virus串，互为逆串
		node->pattern_index <<= 16;
		node->pattern_index |= pat;
	}
}

void BuildDfa(){
	Node* root = gNodes + 1;
	for (int i = 0; i < LETTERS; i++){
		gNodes[0].childs[i] = root;
	}
	root->prev = gNodes;
	gNodes[0].prev = NULL;
	queue<Node*> Q;
	Q.push(root);
	while (!Q.empty()){
		Node* node = Q.front();
		Q.pop();
		Node* prev = node->prev;
		Node* p;
		for (int i = 0; i < LETTERS; i++){
			if (node->childs[i]){
				p = prev;
				while (p && !p->childs[i]){
					p = p->prev;
				}
				node->childs[i]->prev = p->childs[i];
				if (p->childs[i]->danger_node)
					node->childs[i]->danger_node = true;
				Q.push(node->childs[i]);
			}
		}
	}
}

void FindPatternFromEndPoint(Node* node){
	do{
		if (node->visited)	//若该节点之前被访问过，则直接返回
			return;

		node->visited = true;
		if (node->pattern_index){
			if (node->pattern_index <= gVirusNum){
				if (! gVirusVisited[node->pattern_index]){
					gVirusVisited[node->pattern_index] = true;
					gVirusFindNum++;
				}
			}
			else{ //两个模式串互为逆串
				int virus1 = node->pattern_index & 0xFFFF;
				int virus2 = node->pattern_index >> 16;
				if (!gVirusVisited[virus1]){
					gVirusVisited[virus1] = true;
					gVirusFindNum++;
				}
				if (!gVirusVisited[virus2]){
					gVirusVisited[virus2] = true;
					gVirusFindNum++;
				}
			}
		}
		node = node->prev;
	} while (node->prev);
}

void Search(Node* root, char* str, int n){
	char*p = str;
	Node* node = root;
	while (*p != ‘\0‘){
		int index = *p - ‘A‘;
		if (gVirusFindNum >= n){
			return;
		}
		while (node && node->childs[index] == NULL){
			node = node->prev;
		}
		node = node->childs[index];
		if (node->danger_node){
			FindPatternFromEndPoint(node);
		}
		p++;
	}
}

int main(){
	int cas;
	scanf("%d", &cas);
	char virus[MAX_VIRUS_LEN];
	while (cas--){
		int n;
		memset(gNodes, 0, sizeof(gNodes));
		gNodeCount = 2;
		memset(gVirusVisited, false, sizeof(gVirusVisited));
		gVirusFindNum = 0;

		scanf("%d", &n);
		gVirusNum = n;
		getchar();
		for (int i = 0; i < n; i++){
			scanf("%s", virus);
			Insert(gNodes + 1, virus, i + 1);			
			reverse(virus, virus + strlen(virus));
			Insert(gNodes + 1, virus, i + 1);
		}
		BuildDfa();
		getchar();
		char tmp;
		int k = 0;
		for (;;){
			scanf("%c", &tmp);
			if (tmp == ‘\n‘)
				break;

			if (tmp != ‘[‘){
				gProgram[k++] = tmp;
			}
			else{
				int num;
				scanf("%d", &num);
				scanf("%c", &tmp);
				for (int i = 0; i < num; i++){
					gProgram[k++] = tmp;
				}
				scanf("%c", &tmp);
			}
		}
		gProgram[k++] = ‘\0‘;
		Search(gNodes + 1, gProgram, n);

		printf("%d\n", gVirusFindNum);
	}
	return 0;
}