PAT 05-树8 Huffman Codes

以现在的生产力，是做不到一天一篇博客了。这题给我难得不行了，花了两天时间在PAT上还有测试点1没过，先写上吧。记录几个做题中的难点：1、本来比较WPL那块我是想用一个函数实现的，无奈我对传字符串数组无可奈何；2、实在是水平还不够，做题基本上都是要各种参考，当然以课件（网易云课堂《数据结构》（陈越，何钦铭））中给的方法为主，可是呢，关于ElementType的类型我一直确定不下来，最后还是参考了园友糙哥（http://www.cnblogs.com/liangchao/p/4286598.html#3158189）的博客；3、关于如何判断是否为前缀码的方法，我是用的最暴力的一一对比，不知如何能更好的实现。好了，具体的题目及测试点1未过的代码实现如下

  1 /*
  2     Name: 
  3     Copyright: 
  4     Author: 
  5     Date: 07/04/15 11:05
  6     Description: 
  7 In 1953, David A. Huffman published his paper "A Method for the Construction of Minimum-Redundancy Codes", and hence printed his name in the history of computer science. As a professor who gives the final exam problem on Huffman codes, I am encountering a big problem: the Huffman codes are NOT unique. For example, given a string "aaaxuaxz", we can observe that the frequencies of the characters 'a', 'x', 'u' and 'z' are 4, 2, 1 and 1, respectively. We may either encode the symbols as {'a'=0, 'x'=10, 'u'=110, 'z'=111}, or in another way as {'a'=1, 'x'=01, 'u'=001, 'z'=000}, both compress the string into 14 bits. Another set of code can be given as {'a'=0, 'x'=11, 'u'=100, 'z'=101}, but {'a'=0, 'x'=01, 'u'=011, 'z'=001} is NOT correct since "aaaxuaxz" and "aazuaxax" can both be decoded from the code 00001011001001. The students are submitting all kinds of codes, and I need a computer program to help me determine which ones are correct and which ones are not.
  8 
  9 Input Specification:
 10 
 11 Each input file contains one test case. For each case, the first line gives an integer N (2 <= N <= 63), then followed by a line that contains all the N distinct characters and their frequencies in the following format:
 12 
 13 c[1] f[1] c[2] f[2] ... c[N] f[N]
 14 where c[i] is a character chosen from {'0' - '9', 'a' - 'z', 'A' - 'Z', '_'}, and f[i] is the frequency of c[i] and is an integer no more than 1000. The next line gives a positive integer M (<=1000), then followed by M student submissions. Each student submission consists of N lines, each in the format:
 15 
 16 c[i] code[i]
 17 where c[i] is the i-th character and code[i] is a string of '0's and '1's.
 18 
 19 Output Specification:
 20 
 21 For each test case, print in each line either “Yes” if the student’s submission is correct, or “No” if not.
 22 
 23 Sample Input:
 24 7
 25 A 1 B 1 C 1 D 3 E 3 F 6 G 6
 26 4
 27 A 00000
 28 B 00001
 29 C 0001
 30 D 001
 31 E 01
 32 F 10
 33 G 11
 34 A 01010
 35 B 01011
 36 C 0100
 37 D 011
 38 E 10
 39 F 11
 40 G 00
 41 A 000
 42 B 001
 43 C 010
 44 D 011
 45 E 100
 46 F 101
 47 G 110
 48 A 00000
 49 B 00001
 50 C 0001
 51 D 001
 52 E 00
 53 F 10
 54 G 11
 55 Sample Output:
 56 Yes
 57 Yes
 58 No
 59 No
 60 */
 61 #include <stdio.h>
 62 #include <stdlib.h>
 63 #include <string.h>
 64 
 65 #define MinData 0
 66 
 67 typedef struct TreeNode
 68 {
 69     int Weight;
 70     struct TreeNode * Left, * Right;
 71 }HuffmanTree, * pHuffmanTree;
 72 typedef struct HeapStruct
 73 {
 74     pHuffmanTree Elements;
 75     int Size;
 76     int Capacity;
 77 }MinHeap, * pMinHeap;
 78 
 79 pMinHeap Create(int MaxSize);
 80 void Insert(pMinHeap pH, HuffmanTree item);
 81 pHuffmanTree Huffman(pMinHeap pH);
 82 pHuffmanTree DeleteMin(pMinHeap pH);
 83 int getWPL(pHuffmanTree pT, int layer, int WPL);
 84 
 85 int main()
 86 {
 87 //    freopen("in.txt", "r", stdin); // for test
 88     int N, i; // get input
 89     scanf("%d", &N);
 90     int a[N];
 91     char ch;
 92     for(i = 0; i < N; i++)
 93     {
 94         getchar();
 95         scanf("%c", &ch);
 96         scanf("%d",&a[i]);
 97     }
 98     
 99     int WPL = 0; // build min-heap and Huffman tree
100     pMinHeap pH;
101     HuffmanTree T;
102     pH = Create(N);
103     for(i = 0; i < N; i++)
104     {
105         T.Weight = a[i];
106         T.Left = NULL;
107         T.Right = NULL;
108         Insert(pH, T);    
109     }
110     pHuffmanTree pT;
111     pT = Huffman(pH);
112     
113     WPL = getWPL(pT, 0, WPL); // compare WPL
114     int M, j, k;
115     scanf("%d", &M);
116     int w[M], flag[M];
117     char s[N][N + 2];
118     for(i = 0; i < M; i++)
119     {
120         w[i] = 0;
121         flag[i] = 0;
122         for(j = 0; j < N; j++)
123         {
124             getchar();
125             scanf("%c", &ch);
126             scanf("%s", s[j]);
127             w[i] += strlen(s[j]) * a[j];
128         }
129         if(w[i] == WPL)
130         {
131             flag[i] = 1;
132             for(j = 0; j < N; j++)
133             {
134                 for(k = j + 1; k < N; k++)
135                 {
136                     if(strlen(s[j]) != strlen(s[k]))
137                     {
138                         if(strlen(s[j]) >strlen(s[k]))
139                             if(strstr(s[j], s[k]) == s[j])
140                             {
141                                 flag[i] = 0;
142                                 break;
143                             }
144                         else
145                             if(strstr(s[k], s[j]) == s[k])
146                             {
147                                 flag[i] = 0;
148                                 break;
149                             }
150                     }
151                 }
152             }
153         }
154     }
155     
156     for(i = 0; i < M; i++)
157     {
158         if(flag[i])
159             printf("Yes\n");
160         else
161             printf("No\n");
162     }
163 //    fclose(stdin); // for test
164     return 0;
165 }
166 
167 pMinHeap Create(int MaxSize)
168 {
169     pMinHeap pH = (pMinHeap)malloc(sizeof(MinHeap));
170     pH->Elements = (pHuffmanTree)malloc((MaxSize + 1) * sizeof(HuffmanTree));
171     pH->Size = 0;
172     pH->Capacity = MaxSize;
173     pH->Elements[0].Weight = MinData;
174     
175     return pH;
176 }
177 
178 void Insert(pMinHeap pH, HuffmanTree item)
179 {
180     int i;
181     
182     i = ++pH->Size;
183     for(; pH->Elements[i / 2].Weight > item.Weight; i /= 2)
184         pH->Elements[i] = pH->Elements[i / 2];
185     pH->Elements[i] = item;
186 }
187 
188 pHuffmanTree Huffman(pMinHeap pH)
189 {
190     int i;
191     pHuffmanTree pT;
192     
193     for(i = 1; i < pH->Capacity; i++)
194     {
195         pT = (pHuffmanTree)malloc(sizeof(HuffmanTree));
196         pT->Left = DeleteMin(pH);
197         pT->Right = DeleteMin(pH);
198         pT->Weight = pT->Left->Weight + pT->Right->Weight;
199         Insert(pH, *pT);
200     }
201     pT = DeleteMin(pH);
202     
203     return pT;
204 }
205 
206 pHuffmanTree DeleteMin(pMinHeap pH)
207 {
208     int Parent, Child;
209     pHuffmanTree pMinItem;
210     HuffmanTree temp;
211     
212     pMinItem = (pHuffmanTree)malloc(sizeof(HuffmanTree));
213     *pMinItem = pH->Elements[1];
214     temp = pH->Elements[pH->Size--];
215     for(Parent = 1; Parent * 2 <= pH->Size; Parent = Child)
216     {
217         Child = Parent * 2;
218         if((Child != pH->Size) && (pH->Elements[Child].Weight > pH->Elements[Child + 1].Weight))
219             Child++;
220         if(temp.Weight <= pH->Elements[Child].Weight)
221             break;
222         else
223             pH->Elements[Parent] = pH->Elements[Child];
224     }
225     pH->Elements[Parent] = temp;
226     
227     return pMinItem;
228 }
229 
230 int getWPL(pHuffmanTree pT, int layer, int WPL)
231 {
232     if(pT->Left == NULL && pT->Right == NULL)
233         WPL += layer * pT->Weight;
234     else
235     {
236         WPL = getWPL(pT->Left, layer + 1, WPL);
237         WPL = getWPL(pT->Right, layer + 1, WPL);
238     }
239     
240     return WPL;
241 }

 

转载于:https://www.cnblogs.com/qingkai/p/4403504.html