05-树9 Huffman Codes（30 分）

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 an non-empty string of no more than 63 '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.

Note: The optimal solution is not necessarily generated by Huffman algorithm. Any prefix code with code length being optimal is considered correct.

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


我的答案

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define MAXN 64
#define Yes 1
#define No  0

typedef struct TreeNode *HuffmanTree;
struct TreeNode {
    int Weight;
    HuffmanTree Left, Right;
};

/* MinHeap function */
#define MinData -1
typedef struct HeapStruct *MinHeap;
struct HeapStruct{
    HuffmanTree Data;
    int Size;
    int Capacity;
};

#define QueueSize 100
struct QNode {
    HuffmanTree Data[QueueSize];
    int rear;
    int front;
};
typedef struct QNode *Queue;

MinHeap CreateMinHeap(int MaxSize);
int MinHeapIsFull(MinHeap H);
void MinHeapInsert(MinHeap H, HuffmanTree item);
int IsEmpty(MinHeap H);
HuffmanTree DeleteMin(MinHeap H);
void PrecDown(MinHeap H, int p);
void BuildMinHeap(MinHeap H);
void PrintMinHeap(MinHeap H);
HuffmanTree Huffman(MinHeap H);
MinHeap ReadData(int num, char *ch, int *cf, MinHeap H);

void AddQ(Queue PtrQ, HuffmanTree item);
HuffmanTree DeleteQ(Queue PtrQ);
int IsEmptyQ(Queue PtrQ);
void LevelOrderTraversal(HuffmanTree HT);

MinHeap CreateMinHeap(int MaxSize)
{
    MinHeap H = (MinHeap)malloc(sizeof(struct HeapStruct));
    H->Data = (HuffmanTree)malloc(sizeof(struct TreeNode)*(MaxSize+1));
    H->Size = 0;
    H->Capacity = MaxSize;
    H->Data[0].Weight = MinData;    //哨兵
    return H;
}

int MinHeapIsFull(MinHeap H)
{
    return (H->Size == H->Capacity);
}

void MinHeapInsert(MinHeap H, HuffmanTree item)
{
    int i;
    if(MinHeapIsFull(H)) {
        printf("Heap full");
        return;
    }
    i = ++H->Size;
    for(;H->Data[i/2].Weight>item->Weight;i=i/2) {
        H->Data[i].Weight = H->Data[i/2].Weight;
        H->Data[i].Left = H->Data[i/2].Left;
        H->Data[i].Right = H->Data[i/2].Right;
    }
    H->Data[i] = *item;
    // free(item);
}

int IsEmpty(MinHeap H)
{
    return (H->Size == 0);
}

HuffmanTree DeleteMin(MinHeap H)
{
    int Parent, Child;
    HuffmanTree MinItem, temp;
    
    MinItem = (HuffmanTree)malloc(sizeof(struct TreeNode));
    temp = (HuffmanTree)malloc(sizeof(struct TreeNode));

    if(IsEmpty(H)) {
        printf("MinHeap Empty");
        return NULL;
    }

    *MinItem = H->Data[1];      //保存最小的元素
    *temp = H->Data[H->Size--]; //从最后一个元素插到顶点来比较
// printf("Size:%d
", H->Size);
    for(Parent=1;Parent*2<=H->Size;Parent=Child) {  //有没有左儿子
        Child = Parent*2;       //有的话比较左儿子
        if((Child!=H->Size)&&(H->Data[Child].Weight>H->Data[Child+1].Weight))   //比较左右儿子那个小
            Child++;
        if(temp->Weight <= H->Data[Child].Weight) break;
        else {
            H->Data[Parent].Weight = H->Data[Child].Weight;
            H->Data[Parent].Left = H->Data[Child].Left;
            H->Data[Parent].Right = H->Data[Child].Right;
        }
    }
    H->Data[Parent] = *temp;
    // free(temp);
    return MinItem;
}

void PrecDown(MinHeap H, int p)
{
    int Parent, Child;
    HuffmanTree temp;

    temp = (HuffmanTree)malloc(sizeof(struct TreeNode));

    *temp = H->Data[p];         /* 取出根结点存放的值 */
    for(Parent=p;Parent*2<=H->Size;Parent=Child) {  //有没有左儿子
        Child = Parent*2;       //有的话比较左儿子
        if((Child!=H->Size)&&(H->Data[Child].Weight>H->Data[Child+1].Weight)) //比较左右儿子那个小
            Child++;
        if(temp->Weight <= H->Data[Child].Weight) break;
        else
            H->Data[Parent].Weight = H->Data[Child].Weight;
    }
    H->Data[Parent] = *temp;
}

void BuildMinHeap(MinHeap H)
{
    int i;
    /* 从最后一个结点的父结点开始，到根结点1 */
    for(i=H->Size/2;i>0;i--)
        PrecDown(H, i);
}

void PrintMinHeap(MinHeap H)
{
    int i;
// printf("MinHeap: ");
    for(i=1;i<=H->Size;i++) {
        printf(" %d", H->Data[i].Weight);
    }
    printf("
");
}

HuffmanTree Huffman(MinHeap H)
{
    /* 假设H->Size个权值已经存在H->Elements[]->Weight里 */
    int i;
    HuffmanTree T;
    BuildMinHeap(H);        /* 将H->Elemnts[]按权值调整为最小堆 */
// PrintMinHeap(H);
    for(i=1;i<H->Size;) {
        T = (HuffmanTree)malloc(sizeof(struct TreeNode));   /* 建立新结点 */
        T->Left = DeleteMin(H);         /* 从最小堆中删除一个结点，作为新T的左子结点 */
        T->Right = DeleteMin(H);        /* 从最小堆中删除一个结点，作为新T的右子结点 */
        T->Weight = T->Left->Weight+T->Right->Weight;   /* 计算新权值 */
        MinHeapInsert(H, T);
// PrintMinHeap(H);
// printf("Huffman:");
// LevelOrderTraversal(T);
// printf("
");
    }
    T = DeleteMin(H);
    return T;
}

void PrintHuffman(HuffmanTree HT)
{
    if(HT) {
        PrintHuffman(HT->Left);
        PrintHuffman(HT->Right);
        printf("%d ", HT->Weight);
    }
}

MinHeap ReadData(int num, char *ch, int *cf, MinHeap H)
{
    int i;
    for(i=0;i<num;i++) {
        if(i==num-1)
            scanf("%c %d", &ch[i], &cf[i]);
        else
            scanf("%c %d ", &ch[i], &cf[i]);
        HuffmanTree T = (HuffmanTree)malloc(sizeof(struct TreeNode));
        T->Weight = cf[i];
        MinHeapInsert(H, T);
    }
    return H;
}

int WPL(HuffmanTree T, int Depth)
{
// printf("T->Weight = %d, T->Left = %p, T->Right =%p
", 
    // T->Weight, T->Left, T->Right);
    int rw=0, lw=0;
    if(!T->Left && !T->Right)
        return (Depth*(T->Weight));
    else {
        if(T->Left) lw = WPL(T->Left, Depth+1);
        if(T->Right) rw = WPL(T->Right, Depth+1);
        return lw+rw;
    }
}

HuffmanTree CreateHuffmanTree()
{
    HuffmanTree T = (HuffmanTree)malloc(sizeof(struct TreeNode));
    T->Weight = 0;
    T->Left = T->Right = NULL;
    return T;
}

void DeleteHuffmanTree(HuffmanTree T)
{
    if(T) {
        DeleteHuffmanTree(T->Left);
        DeleteHuffmanTree(T->Right);
        free(T);
    }
}

int Judge(int N, int CodeLen, char *ch, int *cf)
{
    char s1[MAXN], s2[MAXN];
    int i, j, weight, flag = Yes;
    HuffmanTree T = CreateHuffmanTree();
    HuffmanTree pt = NULL;
    for(i=0;i<N;i++) {
        scanf("%s %s
", s1, s2);
        if(strlen(s2) > N) { flag = No; break; }
        for(j=0;s1[0]!=ch[j];j++)
            if(j==N)  { flag = No; break; }
        weight = cf[j];
        pt = T;
        for(j=0;j<strlen(s2);j++) {
            if(s2[j] == '0') {                      //开始创建树
                if(!pt->Left) pt->Left = CreateHuffmanTree();   //没有就创建
                else if(pt->Left->Weight != 0) {
                    // printf("Exit from pt->Left->Weight == 1
");
                    flag = No;        //是否路过叶子
                } 
                pt = pt->Left;
            } else if(s2[j] == '1') {
                if(!pt->Right) pt->Right = CreateHuffmanTree();
                else if(pt->Right->Weight != 0) {
                    // printf("Exit from pt->Right->Weight == 1
");
                    flag = No;
                }
                pt = pt->Right;
            } else {                                //应该不会发生
                // printf("Exit from not happen
");
                flag = No;
            }
        }
        pt->Weight = weight;                        //叶子标记
        weight = 0;                                 //清空weight
        if(pt->Left || pt->Right) {
            // printf("Exit from pt->Left || pt->Right
");
            flag = No;     //不是叶子也错
        }
    }
    if(flag != No && CodeLen == WPL(T, 0)) {
        return Yes;
    } else {
        // printf("Exit from CodeLen != WPL(T, 0) %d
", WPL(T, 0));
        if(T) DeleteHuffmanTree(T);
        return No;
    }
}

int main()
{
    int N, CodeLen, n, i;          //huffman的叶子结点个数,WPL最优值
    MinHeap H;      //最小堆
    char *ch;       //输入的字符组
    int *cf;
    HuffmanTree T;  //HuffmanTree
    scanf("%d
", &N);
    H = CreateMinHeap(N);
    ch = (char *)malloc(sizeof(char)*N);
    cf = (int *)malloc(sizeof(int)*N);
    H = ReadData(N, ch, cf, H);
    T = Huffman(H);
    CodeLen = WPL(T, 0);
    scanf("%d
", &n);
    for(i=0;i<n;i++) {
        if(Judge(N, CodeLen, ch, cf))
            printf("Yes
");
        else
            printf("No
");
    }
    return 0;
}