05-树9 Huffman Codes（30 分）

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

---

这一题看似复杂实际上要做两件事：
1. 计算出哈夫曼编码WPL
2. 计算学生方案的WPL
3. 比较，不合格就滚，合格再判断是否是前缀码。

我的码一直不太清楚priority_queue 怎么用在建立哈夫曼树上，所以自建了一些轮子，略长：

#include <iostream>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
#include <cstdlib>

//#define LOCAL
//#include <vector>

typedef struct {
    int weight;//权重  
    int parent;//父节点  
    int lchild;//左孩子  
    int rchild;//右孩子  
}HTNode, *HuffmanTree;

int Min(HuffmanTree HT, int k)
{
    int i = 0;
    int min;        //存weight最小且parent为-1的元素的序号  
    int min_weight; //存weight最小且parent为-1的元素的weight值  

    //先将第一个parent为-1的元素的weight值赋给min_weight,留作以后比较用。  
    //注意，这里不能按照一般的做法，先直接将HT[0].weight赋给min_weight，  
    //因为如果HT[0].weight的值比较小，那么在第一次构造二叉树时就会被选走，  
    //而后续的每一轮选择最小权值构造二叉树的比较还是先用HT[0].weight的值来进行判断，  
    //这样又会再次将其选走，从而产生逻辑上的错误。  
    while (HT[i].parent != -1)
        i++;
    min_weight = HT[i].weight;
    min = i;

    //选出weight最小且parent为-1的元素，并将其序号赋给min  
    for (;i<k;i++)
    {
        if (HT[i].weight<min_weight && HT[i].parent == -1)
        {
            min_weight = HT[i].weight;
            min = i;
        }
    }

    //选出weight最小的元素后，将其parent置1，使得下一次比较时将其排除在外。  
    HT[min].parent = 1;

    return min;
}

void select_minium(HuffmanTree HT, int k, int &min1, int &min2)
{
    min1 = Min(HT, k);
    min2 = Min(HT, k);
}

HuffmanTree Create_tree(int wet[], int n) {
    int total = 2 * n - 1;
    HuffmanTree ht = (HuffmanTree)malloc(sizeof(HTNode)*(2 * n - 1));
    //ht[0]```ht[n-1]存放叶结点
    int i;
    for (i = 0; i<n; ++i) {
        ht[i].parent = -1;
        ht[i].lchild = -1;
        ht[i].rchild = -1;
        ht[i].rchild = -1;
        ht[i].weight = *wet++;
    }
    //n```2n-2为其他
    for (;i<total;i++)
    {
        ht[i].parent = -1;
        ht[i].lchild = -1;
        ht[i].rchild = -1;
        ht[i].weight = 0;
    }
    int min1, min2;
    // priority_queue<int, vector<int>, greater<int> > q;
    // for(int i=0; i<n; ++i) {
    //     q.push(ht[i].weight);
    // }
    for (int i = n; i<total; ++i) {
        select_minium(ht, i, min1, min2);
        ht[min1].parent = i;
        ht[min2].parent = i;
        ht[i].lchild = min1;
        ht[i].rchild = min2;
        ht[i].weight = ht[min1].weight + ht[min2].weight;
    }
    return ht;
}

int find_bits(HuffmanTree HT, int n) {
    int bits = 0;
    for (int i = 0; i<n; ++i) {
        int now = i;
        while (HT[now].parent != -1) {
            now = HT[now].parent;
            bits += HT[i].weight;
        };
    }
    return bits;
}

bool isLeagal(std::vector<std::string> v) {
    for (auto i = v.cbegin(); i != v.cend(); ++i) {
        //std::cout << *i << '\n';
        for (auto j = v.cbegin(); j != v.cend(); ++j) {
            if (i == j) continue;
            if ((*j).find((*i)) == 0) {
                //std::cout << *j << " " << *i;
                return false;
            }
        }
    }
    return true;
}

int main()
{
// #ifdef LOCAL
//  freopen("test.txt", "r", stdin);
// #endif

    int n, bits;
    scanf("%d", &n);
    getchar();
    std::map<char, int> char_wei;
    // char data[n];
    //int weight[n];
    int* weight = (int *)malloc(sizeof(int)*n);
    for (int i = 0; i<n; ++i) {
        char tmp1;
        int tmp2;
        scanf("%c %d", &tmp1, &tmp2);
        weight[i] = tmp2;
        char_wei[tmp1] = tmp2;
        getchar();
    }
    HuffmanTree tree = Create_tree(weight, n);
    bits = find_bits(tree, n);
    int m;
    scanf("%d", &m);
    std::vector<std::string> allCode;
    getchar();
    while (m--) {
        char tmpc;
        std::string code;
        int sbits = 0;
        for (int i = 0; i<n; ++i) {
            scanf("%c", &tmpc);
            std::cin >> code;
            allCode.push_back(code);
            sbits += code.length() * char_wei[tmpc];
            getchar();
        }
        /*printf("%d\n", bits);
        printf("%d\n", sbits);*/

        if (sbits == bits && isLeagal(allCode)) printf("Yes\n");
        else printf("No\n");
        allCode.resize(0);
    } 
    //for (int i = 0; i < 2*n-1; ++i) {
    //  printf("%d %d  ",i, tree[i].parent);
    //}
    return 0;
}

第一次没把LOCAL变量删除，所以全错，导致心态爆炸，没继续看了。。。