哈夫曼树以及哈夫曼编码

一、问题描述

构造一颗包含 $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;
    }
}