05-树8. Huffman Codes

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;
}