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.
Input Specification:
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:
c[1] f[1] c[2] f[2] … c[N] f[N]
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:
c[i] code[i]
where c[i] is the i-th character and code[i] is a string of ‘0’s and ‘1’s.
Output Specification:
For each test case, print in each line either “Yes” if the student’s submission is correct, or “No” if not.
Sample Input:7
A 1 B 1 C 1 D 3 E 3 F 6 G 6
4
A 00000
B 00001
C 0001
D 001
E 01
F 10
G 11
A 01010
B 01011
C 0100
D 011
E 10
F 11
G 00
A 000
B 001
C 010
D 011
E 100
F 101
G 110
A 00000
B 00001
C 0001
D 001
E 00
F 10
G 11
Sample Output:Yes
Yes
No
No
哈夫曼编码,这题前前后后写了两天吧。我的思路是1.先按给定序列构建一个哈夫曼树,计算WPL作为标准。2.而后对输入的字符串进行比较,若有前缀就输出No。3.计算输入序列的WPL,和标准WPL进行比较,得出结果。
#include<stdio.h>
#include<stdlib.h>
typedef struct huffman{
int hign;
int data;
struct huffman* right;
struct huffman* left;
}Huffman;
void PreRead(Huffman* T);
int cmp(char* t,char* k);
int CntChar(char* p);
Huffman* OldInsert(Huffman* P[],int* n,int k);
void NewInsert(Huffman* P[],int* n,Huffman* k);
Huffman* Delete(Huffman* heap[],int* n);
Huffman* MakeMinHuffman(Huffman* heap[],int* top);
int main(){
int n,i,m,k,h,p = 0,sum = 0,MinSum = 0;
scanf("%d",&n);
char sign[n],sign2[n],encoded[n][1000];
int weight[n],top = 1;
Huffman* heap[n+1],*chack[n+1];
*heap = (Huffman*)malloc(sizeof(Huffman)*(n+1));
*chack = (Huffman*)malloc(sizeof(Huffman)*(n+1));
heap[0]->data = -1;
heap[0]->left = heap[0]->right = NULL;
// 读取权重
getchar();
for(i = 0;i<n;i++){
scanf("%c",&sign[i]);
getchar();
scanf("%d",&weight[i]);
getchar();
}
// 构建N个哈夫曼树,每个里放一个权
for(i = 0;i<n;i++){
chack[i] = OldInsert(heap,&top,weight[i]);
}
Huffman* HUFFMAN = NULL;
// 构建哈夫曼树
HUFFMAN = MakeMinHuffman(heap,&top);
HUFFMAN->hign = 1;
// 给节点加上高度
PreRead(HUFFMAN);
// 计算最小wpl,作为标准
for(i = 0;i<n;i++){
MinSum += chack[i]->data*((chack[i]->hign)-1);
}
scanf("%d",&m);
getchar();
for(int j = 0;j<m;j++,sum = 0){
for(i = 0;i<n;i++){
sign2[i] = getchar();
getchar();
scanf("%s",encoded[i]);
getchar();
}
// 判断输入的序列是否出现前缀
for(k = 0,p = 0;k<n-1;k++)
for(h = k+1;h<n;h++){
if(cmp(encoded[k],encoded[h])){
if(0 == p)
printf("No\n");
p = 1;
}
}
// 判断wpl是否和标准wpl一样
if(0 == p){
for(h = 0;h<n;h++)
sum += weight[h]*CntChar(encoded[h]);
if(sum == MinSum)
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}
void PreRead(Huffman* T){
if(T!=NULL){
if(T->left!=NULL)
T->left->hign = T->hign+1;
if(T->right!=NULL)
T->right->hign = T->hign+1;
PreRead(T->left);
PreRead(T->right);
}
}
Huffman* MakeMinHuffman(Huffman* heap[],int* top){
int i,size = *top,k;
Huffman* T;
for(i = 1;i<size-1;i++){
T = (Huffman*)malloc(sizeof(Huffman));
T->left = (Huffman*)malloc(sizeof(Huffman));
T->left = Delete(heap,top);
T->right = (Huffman*)malloc(sizeof(Huffman));
T->right = Delete(heap,top);
T->data = T->left->data + T->right->data;
NewInsert(heap,top,T);
}
return T;
}
Huffman* Delete(Huffman* heap[],int* n){
int parent,child;
Huffman* MinItem;
Huffman* temp;
if(*n == 1)
return NULL;
MinItem = heap[1];
temp = heap[(*n)-1];
for(parent = 1;parent*2<=(*n)-1;parent = child){
child = parent*2;
if((child != (*n)-1)&&(heap[child]->data > heap[child+1]->data))
child++;
if(temp->data<=heap[child]->data)
break;
else
heap[parent] = heap[child];
}
heap[parent] = temp;
(*n)--;
return MinItem;
}
void NewInsert(Huffman* P[],int* n,Huffman* k){
Huffman** p = P;
int i = *n;
for(;p[i/2]->data > k->data;i/=2)
p[i] = p[i/2];
p[i] = k;
(*n)++;
}
Huffman* OldInsert(Huffman* p[],int* n,int k){
int i = *n;
Huffman* T;
T = (Huffman*)malloc(sizeof(Huffman));
T->data = k;
T->left = T->right = NULL;
for(;p[i/2]->data>k;i/=2)
p[i] = p[i/2];
p[i] = T;
(*n)++;
return T;
}
int CntChar(char* p){
int cnt = 0;
char* P = p;
while(*(P++)!='\0')
cnt++;
return cnt;
}
int cmp(char* t,char* k){
char* a = t;
char* b = k;
while(*a!='\0'&&*b!='\0'){
if(*a!=*b)
return 0;
a++;
b++;
}
return 1;
}