Job 1058 T9

Question: http://acm.jlu.edu.cn/joj/showproblem.php? Pid = 1, 1058

 

Algorithm: Trie tree, breadth-first search

Idea: Build a dictionary into a Trie tree. Each time a key sequence is processed, a queue is established and processed cyclically. During the initial cycle, the Trie root node is queued. During each cycle, traverse all the child nodes of each node in the queue, and queue all the nodes of the child nodes that are the same as the keys currently processed, select the node with the highest priority in the current queue, output the path from the root node to the node, and then start a new cycle to process the next button in the Key sequence.

This question can also be done in another way, that is, when the dictionary is read, the key sequence of the current word is generated at the same time. After reading the key sequence, search in the dictionary sequentially. During the search process, the priority of words with the same prefix must be accumulated. It is easier to use the Trie tree.

The code for using the Trie tree is as follows:

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 tree, wide search
8. *
9. * State: Acceptd, 0.00 s, 416 K
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', '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. /* If the value of oldbrother is null, the subtree of P is empty */
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. }