HDU-2222 Keyword Search

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2222

题目大意：

给你很多个单词，然后给你一篇文章，问给出的单词在文章中出现的次数。

解题思路：

AC自动机入门题。需要注意的就是可能有重复单词，坑死人不偿命！~~~~

代码如下：（红色字体是本人加的并非原文内容！）

[cpp]  view plain copy

1. #include<iostream>  
2. #include<cstdio>  
3. #include<cstring>  
4. #include<string>  
5. using namespace std;  
6. #define N 500010  
7. char str[1000010], keyword[51];  
8. int head, tail;  
9.   
10. struct node  
11. {  
12.     node *fail;  
13.     node *next[26];  
14.     int count;  
15.     node() //初始化，（类似于构造函数）原文是：init
16.     {  
17.         fail = NULL;  
18.         count = 0;  
19.         for(int i = 0; i < 26; ++i)  
20.             next[i] = NULL;  
21.     }  
22. }*q[N];  
23. node *root;  
24.   
25. void insert(char *str) //建立Trie  
26. {  
27.     int temp, len;  
28.     node *p = root;  
29.     len = strlen(str);  
30.     for(int i = 0; i < len; ++i)  
31.     {  
32.         temp = str[i] - 'a';  
33.         if(p->next[temp] == NULL)  //防止重复插入
34.             p->next[temp] = new node();  
35.         p = p->next[temp];  
36.     }  
37.     p->count++;  
38. }  
39.   
40. void build_ac() //初始化fail指针，BFS  
41. {  
42.     q[tail++] = root;  //BFS算法的第一步，根节点入队列
43.     while(head != tail)  //当队列中所有节点都被处理完，head == tail,广搜完成！
44.     {  
45.         node *p = q[head++]; //弹出队头 //终于理解了，head指向队列中本次要处理的节点，以此来完成先出！
46.         node *temp = NULL;  
47.         for(int i = 0; i < 26; ++i)  //对当前节点的孩子节点进行广度（横向）搜索
48.         {  
49.             if(p->next[i] != NULL)  //对有字符的节点建立fail指针
50.             {  
51.                 if(p == root) //第一个元素fail必指向根  
52.                     p->next[i]->fail = root;  
53.                 else  
54.                 {  
55.                     temp = p->fail; //失败指针  //从要被建立fail指针的节点的父亲节点的失败指针所指的节点开始
56.                     while(temp != NULL) //2种情况结束：匹配为空or找到匹配  
57.                     {  
58.                         if(temp->next[i] != NULL) //找到匹配  
59.                         {  
60.                             p->next[i]->fail = temp->next[i];  
61.                             break;  
62.                         }  
63.                         temp = temp->fail;  
64.                     }  
65.                     if(temp == NULL) //为空则从头匹配  
66.                         p->next[i]->fail = root;  
67.                 }                              //结束fail指针建立
68.                 q[tail++] = p->next[i]; //入队 //BFS算法的最后一步，将刚才处理完的节点入队列
69.             }  
70.         }  
71.     }  
72. }  
73.   
74. int query() //扫描  
75. {  
76.     int index, len, result;  
77.     node *p = root; //Tire入口  
78.     result = 0;  
79.     len = strlen(str);  
80.     for(int i = 0; i < len; ++i)  
81.     {  
82.         index = str[i] - 'a';  
83.         while(p->next[index] == NULL && p != root) //跳转失败指针  
84.             p = p->fail;  
85.         p = p->next[index];  
86.         if(p == NULL)  
87.             p = root;  
88.         node *temp = p; //p不动，temp计算后缀串  
89.         while(temp != root && temp->count != -1)  
90.         {  
91.             result += temp->count;  
92.             temp->count = -1;  
93.             temp = temp->fail;  
94.         }  
95.     }  
96.     return result;  
97. }  
98.   
99. int main()  
100. {  
101.     int ncase, num;  
102.     scanf("%d", &ncase);  
103.     while(ncase--)  
104.     {  
105.         head= tail = 0;  
106.         root = new node();  
107.         scanf("%d", &num);  
108.         getchar();  
109.         for(int i = 0; i < num; ++i)  
110.         {  
111.             gets(keyword);  
112.             insert(keyword);  
113.         }  
114.         build_ac();  
115.         scanf("%s", str);  
116.         printf("%d\n", query());  
117.     }  
118.     return 0;  
119. }