贪心算法 problem I(1009)

一.简明题意

哈夫曼树对输入的内容进行编码，求出一个字符串的最小字节数，输出原来的字节数，现在的字节数，以及两个的比例

二。解题思路

构建哈夫曼树，对输入的字符串用优先队列进行排序，算出各个字符出现的频率，然后给予新的编码

三.感想

让我们提前学习了哈夫曼树的知识

四.AC代码

#include<iomanip>
#include<iostream>
#include<string>
#include<string.h>
using namespace std;
struct {
    int lc, rc, fa;
}tree[64];
string str;
int fre[60];
int best;
void bm(int n, int dep)
{
    if (fre[n] == 0) return;
    if (n <= 26) best += fre[n] * dep;
    else
    {
        bm(tree[n].lc, ++dep);
        bm(tree[n].rc, dep);
    }
}
int main()
{
    int i, j, left, right;
    while (cin >> str)
    {
        if (str == "END") break;
        int len = str.length();
        for (i = 0; i <= 60; i++)
            tree[i].fa = -1;
        memset(fre, 0, sizeof(fre));
        for (i = 0; i<len; i++)
        {
            if (str[i] == '_') fre[26]++;
            else fre[str[i] - 'A']++;
        }
        int node = 26;
        while (1)
        {
            int min = 1000;
            for (j = 0; j <= node; j++)
            {
                if (tree[j].fa == -1)
                {
                    if (min>fre[j] && fre[j])
                    {
                        min = fre[j];
                        left = j;
                    }

                }
            }
            min = 1000;
            for (i = 0; i <= node; i++)
            {
                if (tree[i].fa == -1)
                {
                    if (min>fre[i] && i != left && fre[i])
                    {
                        min = fre[i];
                        right = i;
                    }
                }
            }
            if (min == 1000) break;
            fre[++node] = fre[left] + fre[right];
            tree[node].lc = left;
            tree[node].rc = right;
            tree[node].fa = -1;
            tree[left].fa = node;
            tree[right].fa = node;
        }
        best = 0;
        if (node == 26) best = len;
        else bm(node, 0);
        len=len*8;
        cout<<len<<" "<<best<<" " << setiosflags(ios::fixed) << setprecision(1) <<len*1.0 / best<<endl;
    }
    return 0;
}