哈夫曼树以及哈夫曼编码
一、问题描述
构造一颗包含\(n\)个叶子节点的\(k\)叉树，其中第\(i\)个叶子节点带有权值\(w_i\)，要求最小化\(\sum w_i*l_i\)，其中\(l_i\)表示第\(i\)个叶子节点到根节点的距离。
二、算法描述
运用贪心的思想，权值大的叶子结点的深度一定要小。
先考虑\(k=2\)的情况：
我们不难想出一种贪心算法。
1.建立一个小根堆，插入这\(n\)个叶子节点的权值。
2.从堆中取出最小的两个权值\(w_1\)和\(w_2\)，令\(ans+=w_1+w_2\)。
3.建立一个新的节点\(p\)，权值为\(w_1+w_2\)，令\(p\)成为取出的两个节点的父亲。
4.在堆中插入权值\(w_1+w_2\)。
5.重复上述\(2\)到\(4\)步，直到堆得大小为\(1\)。
Luogu P1090 合并果子
点击查看代码
import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.Scanner;
/**
* @author dongyudeng
*/
public class BinaryHuffmanTree {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
ArrayList<Integer> values = new ArrayList<>();
for (int i = 0; i < num; i++) {
values.add(scanner.nextInt());
}
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(values);
Integer ans = 0;
while (priorityQueue.size() > 1) {
Integer value1 = priorityQueue.poll(), value2 = priorityQueue.poll();
ans += value1 + value2;
priorityQueue.add(value1 + value2);
}
System.out.println(ans);
}
}
接着再扩展到\(k>2\)的情况：
我们的第一个想法必定是套用上述贪心算法，只是改为每次从堆中取出最小的\(k\)个值。但是在最后一轮循环中，堆的大小在\(2~k-1\)之间，根节点的子节点数小于\(k\)，显然不是最优解，因此我们补加一些权值为\(0\)的叶子节点，使得叶子节点的个数\(n\)满足\((n-1)\mod (k-1)=0\)，这么做是为了让子节点数小于\(k\)的情况出现在最底层（权值为\(0\)的叶子结点显然是在最底层的），从而保证正确性。
注：
\((n-1)\mod (k-1)=0\)推导：
设度为\(k\)的节点数为\(m\)，总节点数为\(l\)。
补了权值为\(0\)的节点后，除了叶子结点外的所有节点都满度，所以\(n+m=l\)。
又因为\(l-1=k*m\)（入边\(=\)出边），可得\(n-1=(k-1)m\)，得证。
哈夫曼树的应用：哈夫曼编码
Luogu P2168 荷马史诗
本题所构建的即为哈夫曼编码，我们将\(n\)个值作为叶子结点的权值，求出哈夫曼树，将每个节点的出边标上\(0\)到\(k-1\)，即可构成一颗\(trie\)树。
观察这颗\(trie\)树，单词\(i\)的编码为从根节点到叶子结点\(i\)的路径，又因为单词都是叶子结点，恰好满足了一个单词不是另一个的前缀。
此外，本题要求\(trie\)的深度最小，我们在合并时优先合并已合并次数最少的节点即可。
点击查看代码
import java.util.ArrayList;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Scanner;
/**
* @author dongyudeng
* Luogu P2168 荷马史诗
*/
public class HuffmanTree {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt(), k = scanner.nextInt();
ArrayList<Long> values = new ArrayList<>();
for (int i = 0; i < num; i++) {
values.add(scanner.nextLong());
}
while ((num - 1) % (k - 1) != 0) {
values.add(0L);
num++;
}
PriorityQueue<TreeNode> priorityQueue = new PriorityQueue<>();
for (Long value : values) {
priorityQueue.add(new TreeNode(0, value));
}
long ans = 0;
while (priorityQueue.size() >= k) {
TreeNode[] nodes = new TreeNode[k];
for (int i = 0; i < k; i++) nodes[i] = priorityQueue.poll();
int maxCnt = 0;
long value = 0;
for (TreeNode node : nodes) {
value += node.getValue();
maxCnt = Math.max(maxCnt, node.getCnt());
}
ans += value;
priorityQueue.add(new TreeNode(maxCnt + 1, value));
}
System.out.println(ans);
int maxCnt = 0;
for (TreeNode node : priorityQueue) maxCnt = Math.max(maxCnt, node.getCnt());
System.out.println(maxCnt);
}
}
class TreeNode implements Comparable<TreeNode> {
private int cnt;
private long value;
public TreeNode(int cnt, long value) {
this.cnt = cnt;
this.value = value;
}
public int getCnt() {
return cnt;
}
public void setCnt(int cnt) {
this.cnt = cnt;
}
public long getValue() {
return value;
}
public void setValue(long value) {
this.value = value;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TreeNode treeNode = (TreeNode) o;
return cnt == treeNode.cnt && value == treeNode.value;
}
@Override
public int hashCode() {
return Objects.hash(cnt, value);
}
@Override
public int compareTo(TreeNode o) {
//equal
if (this.value == o.value && this.cnt == o.cnt) return 0;
//less or greater
boolean isLess = this.value < o.value || (this.value == o.value && this.cnt < o.cnt);
if (isLess) return -1;
else return 1;
}
}
扩展：
关于Luogu P6033 合并果子（加强版）：
桶排序+队列模拟（java过不了）。
代码地址：
码云
