poj 1521 Entropy

 /*
 题意:给出一个字符串，默认每个字符用8位二进制数（ASCII编码）表示，
 求以前缀不重复编码压缩后表示字符串所需的最少二进制数位数。
 其实就是Huffman编码的思路，只需要构建出一颗哈夫曼树，然后计算原字符串节点的带权路径长度即可。
 构建哈夫曼树的算法是：
 首先把 n 个叶子结点看做 n 棵树（仅有一个结点的二叉树），把它们看做一个森林。
 在森林中把权值最小和次小的两棵树合并成一棵树，该树根结点的权值是两棵子树权值之和。
 这时森林中还有 n-1 棵树。重复直到森林中只有一棵为止。此树就是哈夫曼树

 */

#include <iostream>        // Huffman树
#include <queue>
#include <string>
using namespace std;
struct Node
{
    int id;    // 节点编号
    int num;    // 该节点代表的字符出现的次数
    int parent;    // 父亲节点编号
    bool operator<(const Node& other) const        //根据字符出现频率从小到大排序
    {
        return num>other.num;        
    }
};
int main()
{
    string str;
    while(cin>>str&&str!="END")
    {
        int i;
        Node node[100] = {0};
        // 获取节点数目
        for (i=0;i<str.size();++i)
        {
            int j;
            if (str[i]=='_')
                j=26;
            else
                j=str[i]-'A';
            node[j].num++;    //字符出现次数
            node[j].id = node[j].parent = j;    //根结点,所以父亲结点是本身
        }
        priority_queue<Node> q;
        for(i=0;i<=26;++i)
        {
            if(node[i].num>0)        
            {
                q.push(node[i]);    // 入队
            }
        }
        if(q.size()==1)    //只有一种字符,可以编码为0或1,而原始编码规定每个字符为8位表示,所以压缩比例就为8.0
        {
            printf("%d %d 8.0\n",8*str.size(),str.size());    
            continue;
        }
        int n = 27;    // 新增节点起始编号
        while (q.size()>1)     // 不断合并频率最小的两个码元直到只剩最后一个码元
        {
            Node a = q.top();
            q.pop();
            Node b = q.top();
            q.pop();
            node[n].num = a.num + b.num;
            node[n].id = node[n].parent = n;
            node[a.id].parent = n;    //更新父亲结点编号
            node[b.id].parent = n;
            q.push(node[n]);
            n++;
        }
        int res = 0;
        for(i=0;i<=26;++i)
        {
            if(node[i].num>0)        // 计算节点的路径长度
            {
                int height=0;
                Node tmp=node[i];
                while(tmp.parent!=tmp.id)
                {
                    tmp=node[tmp.parent];
                    height++;
                }
                res+=node[i].num*height;    //字符出现的频率乘以路径长度
            }
        }
        printf("%d %d %.1lf\n",8*str.size(),res,8.0*str.size()/res);
    }
    return 0;
}