JOJ 1058 T9

题目：http://acm.jlu.edu.cn/joj/showproblem.php?pid=1058

 

算法：Trie树，广度优先搜索

思路：把字典建成一个Trie树，每次处理一个按键序列时，都建立一个队列，循环处理，初始循环时，Trie的根结点入队，每次循环时，遍历当前在队列中的每一个结点的所有子结点，把它们的子结点当中与当前所处理的按键相同的结点入队，全部入队完毕后，选中当前队列中的优先级最高的结点，输出从根结点到该结点的路径，然后开始新一轮循环，处理按键序列中的下一个按键。

这个题目还可以用另一种方法来做，就是在读入字典的时候，同时生成当前单词的按键序列。然后读入按键序列后，在字典中顺序查找，在查找过程中，把前缀相同的单词的优先级要累加起来。感觉还是使用Trie树更简单些。

使用Trie树的代码如下：

1. /* {JOJ1058:T9}
2.  * Date & Time: Thu Oct 09 19:42:13 2008
3.  * File: 1058.c
4.  * Author: WangHaibin
5.  * Platform: windows xp sp2, emacs 22.1, gcc, gdb
6.  *
7.  * Algorithm: Trie树，广度搜索
8.  *
9.  * State: Acceptd, 0.00s, 416K
10.  * */
11. #include <stdio.h>
12. #include <stdlib.h>
13. #include <string.h>
15. typedef struct _tn {
16.     char letter;
17.     int frequency;
18.     char belongTo;
19.     struct _tn *child, *brother, *parent;
20.     char isComplete;
21. } TrieNode;
23. TrieNode *root;
24. char belongTo[26] = {'2','2','2','3','3','3','4','4','4','5','5','5','6','6','6',
25.              '7','7','7','7','8','8','8','9','9','9','9'};
27. void insert(const char* word, int freq) {
28.     TrieNode *p = root, *oldBrother = NULL, *dest = root->child;
29.     int k = 0, len = strlen(word);
31.     for(k = 0; k < len; k++) {
32.     while(dest != NULL && dest->letter != word[k]) {
33.         oldBrother = dest, dest = dest->brother;
34.     }
35.     if(dest) {
36.         dest->frequency += freq;
37.     } else {
38.         /* dest is NULL, word[0] not found */
39.         dest = (TrieNode*)malloc(sizeof(TrieNode));
40.         dest->letter = word[k];
41.         dest->frequency = freq;
42.         dest->parent = p;
43.         dest->brother = NULL;
44.         dest->child = NULL;
45.         dest->belongTo = belongTo[word[k]-'a'];
46.         dest->isComplete = 0;
47.         if(oldBrother) {
48.         oldBrother->brother = dest;
49.         } else {
50.         /* oldBrother为空，说明p的子树为空 */
51.         p->child = dest;
52.         }
53.     }
54.     p = dest;
55.     dest = p->child;
56.     oldBrother = NULL;
57.     }
58.     p->isComplete = 1;
59. }
61. void solve(const char* seq) {
62.     TrieNode *queue[1024];
63.     int front = 0, rear = 0, k = 0, i, j, maxfreq;
64.     TrieNode *curLayer;
65.     char path[128] = {0};
67.     queue[rear++] = root;
68.     while(seq[k] != '1') {
69.     i = rear - front;
70.     for(j = 1; j <= i; j++) {
71.         curLayer = queue[front]->child;
72.         front++;
73.         while(curLayer) {
74.         if(curLayer->belongTo == seq[k]) {
75.             queue[rear++] = curLayer;
76.         }
77.         curLayer = curLayer->brother;
78.         }
79.     }
80.     if(front == rear) {
81.         /* queue is empty */
82.         printf("MANUALLY/n");
83.         k++;
84.         continue;
85.     }
86.     for(i = front + 1, maxfreq = queue[front]->frequency, j = front; i < rear; i++) {
87.         if(queue[i]->frequency > maxfreq) {
88.         maxfreq = queue[i]->frequency;
89.         j = i;
90.         }
91.     }
92.     curLayer = queue[j]->parent;
93.     i = 126;
94.     path[i] = queue[j]->letter;
95.     while(curLayer != root) {
96.         path[--i] = curLayer->letter;
97.         curLayer = curLayer->parent;
98.     }
99.     printf("%s/n", path+i);
100.     k++;
102.     }
103. }
106. void deleteTree(TrieNode* t) {
107.     if(t != NULL) {
108.     deleteTree(t->child);
109.     deleteTree(t->brother);
110.     free(t);
111.     }
112. }
114. int main() {
115.     int n, w, p, m, i;
116.     char word[128], seq[128];
118.     root = (TrieNode*)malloc(sizeof(TrieNode));
119.     root->child = NULL;
120.     root->brother = NULL;
122.     /*freopen("in.txt", "r", stdin);*/
123.     scanf("%d", &n);
124.     for(i = 1; i <= n; i++) {
125.     scanf("%d", &w);
126.     while(w--) {
127.         scanf("%s%d", word, &p);
128.         insert(word, p);
129.     }
130.     scanf("%d", &m);
131.     printf("Scenario #%d:/n", i);
132.     while(m--) {
133.         scanf("%s", seq);
134.         solve(seq);
135.         printf("/n");
136.     }
137.     deleteTree(root->child);
138.     root->child = NULL;
139.     root->brother = NULL;
140.     printf("/n");
141.     }
143.     return 0;
144. }