hdu 1053 Entropy------霍夫曼树

今天遇到这道题，和以往一样题目能读懂，怎么实现又蒙了圈。。。百度别人的题解发现是当年大二数据结构课上讲过的霍夫曼编码。。。背后的数据结构正是霍夫曼树。看着百度温习了一下构建霍夫曼树的算法。就觉得好像也不难，历经各种修改第一次提交AC了，这是我第一次有这种体验，我能想到怎么做，并且去实现了。哎，我知道我还很渣！我还没有看其它大神的代码，当然写完自己的第一份题解我也还是会虚心地学习他们的代码。

Entropy

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 311 Accepted Submission(s): 183

Problem Description An entropy encoder is a data encoding method that achieves lossless data compression by encoding a message with “wasted” or “extra” information removed. In other words, entropy encoding removes information that was not necessary in the first place to accurately encode the message. A high degree of entropy implies a message with a great deal of wasted information; english text encoded in ASCII is an example of a message type that has very high entropy. Already compressed messages, such as JPEG graphics or ZIP archives, have very little entropy and do not benefit from further attempts at entropy encoding. English text encoded in ASCII has a high degree of entropy because all characters are encoded using the same number of bits, eight. It is a known fact that the letters E, L, N, R, S and T occur at a considerably higher frequency than do most other letters in english text. If a way could be found to encode just these letters with four bits, then the new encoding would be smaller, would contain all the original information, and would have less entropy. ASCII uses a fixed number of bits for a reason, however: it’s easy, since one is always dealing with a fixed number of bits to represent each possible glyph or character. How would an encoding scheme that used four bits for the above letters be able to distinguish between the four-bit codes and eight-bit codes? This seemingly difficult problem is solved using what is known as a “prefix-free variable-length” encoding. In such an encoding, any number of bits can be used to represent any glyph, and glyphs not present in the message are simply not encoded. However, in order to be able to recover the information, no bit pattern that encodes a glyph is allowed to be the prefix of any other encoding bit pattern. This allows the encoded bitstream to be read bit by bit, and whenever a set of bits is encountered that represents a glyph, that glyph can be decoded. If the prefix-free constraint was not enforced, then such a decoding would be impossible. Consider the text “AAAAABCD”. Using ASCII, encoding this would require 64 bits. If, instead, we encode “A” with the bit pattern “00”, “B” with “01”, “C” with “10”, and “D” with “11” then we can encode this text in only 16 bits; the resulting bit pattern would be “0000000000011011”. This is still a fixed-length encoding, however; we’re using two bits per glyph instead of eight. Since the glyph “A” occurs with greater frequency, could we do better by encoding it with fewer bits? In fact we can, but in order to maintain a prefix-free encoding, some of the other bit patterns will become longer than two bits. An optimal encoding is to encode “A” with “0”, “B” with “10”, “C” with “110”, and “D” with “111”. (This is clearly not the only optimal encoding, as it is obvious that the encodings for B, C and D could be interchanged freely for any given encoding without increasing the size of the final encoded message.) Using this encoding, the message encodes in only 13 bits to “0000010110111”, a compression ratio of 4.9 to 1 (that is, each bit in the final encoded message represents as much information as did 4.9 bits in the original encoding). Read through this bit pattern from left to right and you’ll see that the prefix-free encoding makes it simple to decode this into the original text even though the codes have varying bit lengths. As a second example, consider the text “THE CAT IN THE HAT”. In this text, the letter “T” and the space character both occur with the highest frequency, so they will clearly have the shortest encoding bit patterns in an optimal encoding. The letters “C”, “I’ and “N” only occur once, however, so they will have the longest codes. There are many possible sets of prefix-free variable-length bit patterns that would yield the optimal encoding, that is, that would allow the text to be encoded in the fewest number of bits. One such optimal encoding is to encode spaces with “00”, “A” with “100”, “C” with “1110”, “E” with “1111”, “H” with “110”, “I” with “1010”, “N” with “1011” and “T” with “01”. The optimal encoding therefore requires only 51 bits compared to the 144 that would be necessary to encode the message with 8-bit ASCII encoding, a compression ratio of 2.8 to 1.

Input The input file will contain a list of text strings, one per line. The text strings will consist only of uppercase alphanumeric characters and underscores (which are used in place of spaces). The end of the input will be signalled by a line containing only the word “END” as the text string. This line should not be processed.

Output             For each text string in the input, output the length in bits of the 8-bit ASCII encoding, the length in bits of an optimal prefix-free variable-length encoding, and the compression ratio accurate to one decimal point.

Sample Input AAAAABCD THE_CAT_IN_THE_HAT END

Sample Output 64 13 4.9 144 51 2.8

Source Greater New York 2000

题目如上，大家可以读懂核心思想还是让你构造一段字符串的霍夫曼编码，然后输出ASCII码用几位，霍夫曼编码用几位，以及二者的比例。实现霍夫曼编码就要用到霍夫曼树，那么，如何构造霍夫曼树呢？一开始给定一些具有一定权值的节点，把它们看做一整个森林，每棵树的根节点是各个节点本身，然后只要森林里还有树，选根节点权值最小的两棵树形成一棵新树，新树有新的根节点，新的根节点的左右子树分别为之前选择的根节点权值最小的那两棵树，而其权值则为其左右子树根节点的权值之和。当你拿出森林里的最后两棵树构成的新的树就是Huffman Tree啦。

在这道题目中，我们编码的思想就是统计字符出现的频树并作为字符的权，利用上方的构建方法构建出Huffman Tree，可以发现权值越高（出现频率越高）的字母离根节点越近，其编码的长度也会越短，从而缩短整个字符串的编码长度。至于编码的方式嘛，你可以认为从根节点开始，向左为0，向右为1，由根节点到那个代表字母的点的路径就可以代表它的编码啦。但这道题我们并不在乎每个字母怎么去编码，我们只在乎它编码的长度恩恩。。。

以下给出AC代码

#include <iostream>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <list>
#include <stdlib.h>

using namespace std;


struct Node{//霍夫曼树的节点
    int weight;//权值
    Node *left;//指向左子树的指针
    Node *right;//指向右子树的指针
    char letter;//该节点代表的字母
    //特别说明的是，题目中说到输入的字符串全部由大写字母和下划线组成
    //因此我们用小写字母n代表这个节点是非叶子节点
};

int cmp(Node *a,Node *b){//既然每次要在森林里找出根权值最小的两棵树，不如按根的权值排序，取前两个就好
    return a->weight < b->weight;
}

list<Node*> q;//森林
list<Node*>::iterator it;
int sum;//sum用来记有多少个字符


void create(){//构造霍夫曼树
    if(q.size() == 1){//单独考虑字符串只有一种字符的情况
        Node *tmp = (Node *)malloc(sizeof(Node));
        tmp->left = q.front();
        q.pop_front();
        tmp->right = NULL;
        tmp->letter = 'n';
        tmp->weight = sum;
        q.push_back(tmp);
    }
    while(!q.empty()){
        Node *t1 = q.front();
        if(t1->weight == sum){
            break;
        }
        q.pop_front();
        Node *t2 = q.front();
        q.pop_front();
        Node *tmp = (Node *)malloc(sizeof(Node));
        tmp->left = t1;
        tmp->right = t2;
        tmp->letter = 'n';
        tmp->weight = t1->weight+t2->weight;
        q.push_back(tmp);
        q.sort(cmp);
    }
    return;
}

int f(Node *root,int i){//统计霍夫曼编码用多少位，i代表它的霍夫曼编码长度
    int result = 0;
    if(root->letter != 'n'){
        return (root->weight) * i;
    }else{
        if(root->left != NULL){
            result += f(root->left,i+1);
        }
        if(root->right != NULL){
            result += f(root->right,i+1);
        }
        return result;
    }

}

int main(){
    char str[1000];
    int i,j;
    while(scanf("%s",str)&&strcmp(str,"END") != 0){
        sum = strlen(str);
        for(i = 0;i < sum;i++){
            for(it = q.begin();it != q.end();it++){
                if((**it).letter == str[i]){
                    (**it).weight++;
                    break;
                }
            }
            if(it == q.end()){
                Node *tmp = (Node *)malloc(sizeof(Node));
                tmp->left = NULL;
                tmp->right = NULL;
                tmp->letter = str[i];
                tmp->weight = 1;
                q.push_back(tmp);
            }
        }
        q.sort(cmp);
        create();
        i = f(q.front(),0);
        j = sum * 8;
        double ans = (1.0)*j/i;
        printf("%d %d %.1lf\n",j,i,ans);
        q.clear();
    }
    return 0;
}