7-4 哈夫曼编码

给定一段文字，如果我们统计出字母出现的频率，是可以根据哈夫曼算法给出一套编码，使得用此编码压缩原文可以得到最短的编码总长。然而哈夫曼编码并不是唯一的。例如对字符串"aaaxuaxz"，容易得到字母 'a'、'x'、'u'、'z' 的出现频率对应为 4、2、1、1。我们可以设计编码 {'a'=0, 'x'=10, 'u'=110, 'z'=111}，也可以用另一套 {'a'=1, 'x'=01, 'u'=001, 'z'=000}，还可以用 {'a'=0, 'x'=11, 'u'=100, 'z'=101}，三套编码都可以把原文压缩到 14 个字节。但是 {'a'=0, 'x'=01, 'u'=011, 'z'=001} 就不是哈夫曼编码，因为用这套编码压缩得到 00001011001001 后，解码的结果不唯一，"aaaxuaxz" 和 "aazuaxax" 都可以对应解码的结果。本题就请你判断任一套编码是否哈夫曼编码。

输入格式：

首先第一行给出一个正整数 N（2≤N≤63），随后第二行给出 N 个不重复的字符及其出现频率，格式如下：

c[1] f[1] c[2] f[2] ... c[N] f[N]

其中c[i]是集合{'0' - '9', 'a' - 'z', 'A' - 'Z', '_'}中的字符；f[i]是c[i]的出现频率，为不超过 1000 的整数。再下一行给出一个正整数 M（≤1000），随后是 M 套待检的编码。每套编码占 N 行，格式为：

c[i] code[i]

其中c[i]是第i个字符；code[i]是不超过63个'0'和'1'的非空字符串。

输出格式：

对每套待检编码，如果是正确的哈夫曼编码，就在一行中输出"Yes"，否则输出"No"。

注意：最优编码并不一定通过哈夫曼算法得到。任何能压缩到最优长度的前缀编码都应被判为正确。

输入样例：

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

输出样例：

Yes
Yes
No
No

解题思路： 首先，先了解哈夫曼树是什么

当用 n 个结点（都做叶子结点且都有各自的权值）试图构建一棵树时，如果构建的这棵树的带权路径长度最小，称这棵树为最优二叉树，有时也叫哈夫曼树。

然后还需要知道一点，什么是带权的路径长度wpl

树的带权路径长度为树中所有叶子结点的带权路径长度之和，也就是一个叶子节点经过的边数*叶子节点的权值

好了，以上其实就是解题的关键

通过读题可以发现，首先给定的c和f数组，其实就是哈夫曼树定义的n个节点，我们使用贪心的思想，我们想要让带权的路径长度最小，那么小的值一定离根节点最远。

那么下来一定就是解决如何计算的问题

 

如果给定这样的一个图，显然

 WPL = 7 * 1 + 5 * 2 + 2 * 3 + 4 * 3

因此我们可以发现，当我们知道每一个节点的权值的时候，每一次选取数组中最小的两个加和后，放回数组中，然后继续重复上面的操作，直到内部只剩下一个值的时候，显然这个值就是根（经过的边数是0不用计算）。

可以看出这使用的数据结构是优先队列小根堆，然后就可以解决wpl的问题

第二个问题就是

如何判断一个串是否是合法的哈夫曼编码

第一个 需要满足的条件
观察yes的情况
A 00000 len = 5
B 00001 len = 5
C 0001 len = 4
D 001 len = 3
E 01 len = 2
F 10 len = 2
G 11 len = 2
某一个节点经过的边数就是这个01串的长度

第二个 需要满足的条件
再观察no的情况
A 00000
B 00001
C 0001
D 001
E 00
F 10
G 11
可以发现只有E和yes的情况不同
还可以发现结果
E在上面的01串中的前缀出现过
因此 总结
是一个正确的哈夫曼编码满足的条件有两条
（1）总共经过的边数 = 哈夫曼树的路径总和
（2）一个01串从未在别的串中的前缀串中出现过（len(cur串) = len(判断)）

通过上面的分析，可以得到代码

c++（满分）

#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<unordered_map>

using namespace std;
const int N = 100;
int n , m;
priority_queue<int , vector<int> , greater<int>>hasp;
unordered_map<char , int>mp1;
int wpl = 0;

bool cmp(pair<int , string> a , pair<int , string> b)
{
    return a.first < b.first;
}

bool check(vector< pair<int , string> >&v)
{
    int n = v.size();
    for(int i = 0;i < n;i ++)
    {
        string s = v[i].second;
        for(int j = i + 1;j < n;j ++)
        {
            string str = v[j].second;
            str = str.substr(0 , (int)s.size());
            if(s == str) return false;
        }
    }
    return true;
}

int main()
{
    cin >> n;
    for(int i = 0;i < n;i ++)
    {
        char ch;
        int num;
        cin >> ch >> num;
        mp1[ch] = num;
        hasp.push(num);
    }
    
    while(hasp.size() > 1)
    {
        int a = hasp.top(); hasp.pop();
        int b = hasp.top(); hasp.pop();
        //cout << a << " " << b << endl;
        wpl += a + b;
        hasp.push(a + b);
    }
    
    cin >> m;
    //cout << wpl << endl;
    
    while(m --)
    {
        vector< pair<int , string> >v;
        bool res = true;
        int sum = 0;
        for(int i = 0;i < n;i ++)
        {
            char ch;
            string str;
            cin >> ch >> str;
            v.push_back({(int)str.size() , str});
            sum += (int)str.size() * mp1[ch];
        }
        if(sum != wpl) res = false;
        
        sort(v.begin() , v.end() , cmp);
        if(!check(v)) res = false;
        
        if(res) puts("Yes");
        else puts("No");
    }
    
    return 0;
}

python3（测试点3 超时 直接n和m直接拉满，直接超时）（不知道为什么没有高亮）

import functools
from queue import PriorityQueue

def check(l) -> bool:
    for i in range(len(l)):
        s0 = l[i]
        for j in range(i + 1 , len(l) , 1):
            s1 = l[j][0 : len(s0)]
            if s1 == s0:
                return True
    return False
    

def compare(a , b):
    if len(a) < len(b):
        return -1
    else :
        return 1


hasp = PriorityQueue()
n = int(input())
s = input()
val = s.split()
mp = {}
wpl = 0
for i in range(0 , len(val) , 2):
    ch = val[i]
    num = int(val[i + 1])
    mp[ch] = num
    hasp.put(num)
    
while hasp.qsize() > 1:
    a = hasp.get()
    b = hasp.get()
    wpl += a + b
    hasp.put(a + b)
    
    
m = int(input())
for i in range(m):
    res = True
    sum = 0
    l = []
    for j in range(n):
        s1 , s2 = input().split()
        l.append(s2)
        sum += len(s2) * mp[s1]
    
    l.sort(key = functools.cmp_to_key(compare))
    if sum != wpl or check(l):
        res = False
    if res:
        print("Yes")
    else:
        print("No")