无根树（无环连通无向图）的Prufer编码

Prufer 数列，可以用来解一些关于无根树计数的问题。
Prufer 数列是一种无根树的编码表示，对于一棵 $n$ 个节点带编号的无根树，对应唯一一串长度为 $n-1$ 的 Prufer 编码。
（1）无根树转化为 Prufer 序列。
首先定义无根树中度数为 $1$ 的节点是叶子节点。
找到编号最小的叶子并删除，序列中添加与之相连的节点编号，重复执行直到只剩下 $2$ 个节点。
如下图的树对应的 $Prufer$ 序列就是3，5，1，3。

具体实现可以用一个 set 搞定，维护度数为 $1$ 的节点。复杂度 $O(nlogn)$。
（2）Prufer序列转化为无根树。
设点集 $V=\{1,2,3,...,n\}$，每次取出 Prufer 序列中最前面的元素u，在V中找到编号最小的没有在 Prufer 序列中出现的元素$v$，给 $u$，$v$ 连边然后分别删除，最后在 $V$ 中剩下两个节点，给它们连边。最终得到的就是无根树。
具体实现也可以用一个 set，维护 Prufer 序列中没有出现的编号。复杂度 $O(nlogn)$。
最后有一个很重要的性质就是* Prufer 序列中某个编号出现的次数就等于这个编号的节点在无根树中的度数-1*。

而这个编码的应用就是对无根树进行计数。一个 $n$ 个节点的无根树唯一地对应了一个长度为 $n-2$ 的编码数列，数列中的每个数都在 $1$ 到 $n$ 的范围内。
1）我们可以直接推出 $n$ 个点的无向完全图的生成树的计数：$n^{(n-2)}$ 即 $n$ 个点的有标号无根树的计数。

2）一个有趣的推广是，$n$ 个节点的度依次为 $D_1, D_2, …, D_n$ 的无根树共有 $\frac{(n-2)!}{(D_1-1)!(D_2-1)!...(D_n-1)!}$ 个，因为此时 Prüfer 编码中的数字 $i$ 恰好出现 $D_i-1$ 次。

即 $n$ 种元素，共 $n-2$ 个，其中第 $i$ 种元素有 $D_i-1$ 个，求排列数。

3）$n$ 个节点的度依次为 $D_1, D_2, …, D_n$，另外有 $m$ 个节点度数未知，求有多少种生成树？(BZOJ1005 明明的烦恼)

令每个已知度数的节点的度数为 $d_i$，有 $n$ 个节点，$m$ 个节点未知度数，$left=(n-2)-(d_1-1)-(d_2-1)-...-(d_{n-m}-1)$

已知度数的节点可能的组合方式如下

$$\frac{(n-2)!}{(d_1-1)!(d_2-1)!...(d_{n-m}-1)!left!}$$

剩余 $left$ 个位置由未知度数的节点随意填补，方案数为 $m^{left}$
于是最后有

$$ans=\frac{(n-2)!m^{left}}{(d_1-1)!(d_2-1)!...(d_{n-m}-1)!left!}$$

BZOJ1211

一个有 $n$ 个结点的树，设它的结点分别为 $v_1, v_2, …, v_n$，已知第 $i$ 个结点vi的度数为 $d_i$，问满足这样的条件的不同的树有多少棵。给定 $n$，$d_1, d_2, …, d_n$，编程需要输出满足 $d(v_i)=d_i$的树的个数。

import java.util.*;
import java.math.*;
public class BZOJ1211 {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int[] vec = new int[n];
        int tot = 0;
        for (int i = 0; i < n; ++i) {
            vec[i] = cin.nextInt();
            tot += vec[i];
            if (vec[i] == 0 && n > 1) {
                System.out.println(0);
                return;
            }
        }
        if (tot != (n-1)*2) {
            System.out.println(0);
            return;
        }
        if (n == 1 && vec[0] > 0) {
            System.out.println(0);
        } else {
            BigInteger up = Fact(n-2);
            BigInteger down = new BigInteger("1");
            for (int i = 0; i < n; ++i) {
                down.multiply(Fact(vec[i]-1));
            }
            System.out.println(up.divide(down));
        }
    }
    public static BigInteger Fact(int n) {
        BigInteger result = new BigInteger("1");
        for (int i = 1; i <= n; ++i) {
            result = result.multiply(BigInteger.valueOf(i));
        }
        return result;
    }
}