PAT 05-树8 Huffman Codes

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

/*
    Name: 
    Copyright: 
    Author: 
    Date: 07/04/15 11:05
    Description: 
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
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MinData 0

typedef struct TreeNode
{
    int Weight;
    struct TreeNode * Left, * Right;
}HuffmanTree, * pHuffmanTree;
typedef struct HeapStruct
{
    pHuffmanTree Elements;
    int Size;
    int Capacity;
}MinHeap, * pMinHeap;

pMinHeap Create(int MaxSize);
void Insert(pMinHeap pH, HuffmanTree item);
pHuffmanTree Huffman(pMinHeap pH);
pHuffmanTree DeleteMin(pMinHeap pH);
int getWPL(pHuffmanTree pT, int layer, int WPL);

int main()
{
//    freopen("in.txt", "r", stdin); // for test
    int N, i; // get input
    scanf("%d", &N);
    int a[N];
    char ch;
    for(i = 0; i < N; i++)
    {
        getchar();
        scanf("%c", &ch);
        scanf("%d",&a[i]);
    }
    
    int WPL = 0; // build min-heap and Huffman tree
    pMinHeap pH;
    HuffmanTree T;
    pH = Create(N);
    for(i = 0; i < N; i++)
    {
        T.Weight = a[i];
        T.Left = NULL;
        T.Right = NULL;
        Insert(pH, T);    
    }
    pHuffmanTree pT;
    pT = Huffman(pH);
    
    WPL = getWPL(pT, 0, WPL); // compare WPL
    int M, j, k;
    scanf("%d", &M);
    int w[M], flag[M];
    char s[N][N + 2];
    for(i = 0; i < M; i++)
    {
        w[i] = 0;
        flag[i] = 0;
        for(j = 0; j < N; j++)
        {
            getchar();
            scanf("%c", &ch);
            scanf("%s", s[j]);
            w[i] += strlen(s[j]) * a[j];
        }
        if(w[i] == WPL)
        {
            flag[i] = 1;
            for(j = 0; j < N; j++)
            {
                for(k = j + 1; k < N; k++)
                {
                    if(strlen(s[j]) != strlen(s[k]))
                    {
                        if(strlen(s[j]) >strlen(s[k]))
                            if(strstr(s[j], s[k]) == s[j])
                            {
                                flag[i] = 0;
                                break;
                            }
                        else
                            if(strstr(s[k], s[j]) == s[k])
                            {
                                flag[i] = 0;
                                break;
                            }
                    }
                }
            }
        }
    }
    
    for(i = 0; i < M; i++)
    {
        if(flag[i])
            printf("Yes\n");
        else
            printf("No\n");
    }
//    fclose(stdin); // for test
    return 0;
}

pMinHeap Create(int MaxSize)
{
    pMinHeap pH = (pMinHeap)malloc(sizeof(MinHeap));
    pH->Elements = (pHuffmanTree)malloc((MaxSize + 1) * sizeof(HuffmanTree));
    pH->Size = 0;
    pH->Capacity = MaxSize;
    pH->Elements[0].Weight = MinData;
    
    return pH;
}

void Insert(pMinHeap pH, HuffmanTree item)
{
    int i;
    
    i = ++pH->Size;
    for(; pH->Elements[i / 2].Weight > item.Weight; i /= 2)
        pH->Elements[i] = pH->Elements[i / 2];
    pH->Elements[i] = item;
}

pHuffmanTree Huffman(pMinHeap pH)
{
    int i;
    pHuffmanTree pT;
    
    for(i = 1; i < pH->Capacity; i++)
    {
        pT = (pHuffmanTree)malloc(sizeof(HuffmanTree));
        pT->Left = DeleteMin(pH);
        pT->Right = DeleteMin(pH);
        pT->Weight = pT->Left->Weight + pT->Right->Weight;
        Insert(pH, *pT);
    }
    pT = DeleteMin(pH);
    
    return pT;
}

pHuffmanTree DeleteMin(pMinHeap pH)
{
    int Parent, Child;
    pHuffmanTree pMinItem;
    HuffmanTree temp;
    
    pMinItem = (pHuffmanTree)malloc(sizeof(HuffmanTree));
    *pMinItem = pH->Elements[1];
    temp = pH->Elements[pH->Size--];
    for(Parent = 1; Parent * 2 <= pH->Size; Parent = Child)
    {
        Child = Parent * 2;
        if((Child != pH->Size) && (pH->Elements[Child].Weight > pH->Elements[Child + 1].Weight))
            Child++;
        if(temp.Weight <= pH->Elements[Child].Weight)
            break;
        else
            pH->Elements[Parent] = pH->Elements[Child];
    }
    pH->Elements[Parent] = temp;
    
    return pMinItem;
}

int getWPL(pHuffmanTree pT, int layer, int WPL)
{
    if(pT->Left == NULL && pT->Right == NULL)
        WPL += layer * pT->Weight;
    else
    {
        WPL = getWPL(pT->Left, layer + 1, WPL);
        WPL = getWPL(pT->Right, layer + 1, WPL);
    }
    
    return WPL;
}