【luogu CF917D】Stranger Trees（二项式反演）（树形DP）（Cayley 公式）

Stranger Trees

题目链接：luogu CF917D

题目大意

给你一棵 n 个点的树，然后要你对于每个 k=0~n-1，回答有多少种 n 个点的树恰好有给出树的 k 条边。

思路

我们考虑在原树上有 $x$ 条边在这棵树上，对于原树它就被分成了 $n-x$ 个连通块。
那就变成求有多少个分发可以分成 $k$ 个连通块。

然后考虑容斥，设 $F_i$ 为至少分成 $k$ 个连通块的方案数。
然后恰好是 $G_i$，那 $F_i=\sum _{j=i}^n\left(\genfrac{}{}{0ex}{}{j}{i}\right)G_j$。
那我们可以用二项式反演，得到 $G_i=\sum _{j=i}^n(-1{)}^{j-i}(\genfrac{}{}{0ex}{}{j}{i})G_j$。
（就可以直接暴力 $O(n^2)$ 求）

这里多说一下，如果是 $F_i=\sum _{j=0}^i\left(\genfrac{}{}{0ex}{}{i}{j}\right)G_j$。
那它的二项式反演就是 $G_i=\sum _{j=0}^i(-1{)}^{i-j}(\genfrac{}{}{0ex}{}{i}{j})G_j$。

然后问题就是如何求 $F_i$。
考虑用扩展 Cayley 公式：
Cayley 公式：一个完全图有 $n^{n-2}$ 棵无根生成树，这个可以用 prufer 序列证明。
（长度是 $n-2$ 的 prufer 序列任意一个位置不一样都会造成树形态的不同）

扩展 Cayley 公式：被确定分成 $a_1,a_2,...a_k$ 大小的连通块，那就有 $n^{k-2}\prod _{i=1}^k{a}_i$ 棵生成树。
这个也可以用 prufer 序列或者矩阵树之类的证明。

然后问题就是 $\prod _{i=1}^k{a}_i$。
考虑用树形 DP 解决，设 $f_{i,j,k}$ 为处理好 $i$ 的子树，已经有 $j$ 个连通块，然后 $i$ 所在的连通块大小是 $k$ 的权值。（这样子就是 $O(n^3)$）

但其实第三维可以变成 $0/1$ 表示 $i$ 这个点用了吗。
然后大概就是这样转移：
$f_{u,j,0}{f}_{v,k,1}\to f_{u,j+k,0}$
$f_{u,j,1}{f}_{v,k,1}\to f_{u,j+k,1}$
（这些是不连接的）
$f_{u,j,0}{f}_{v,k,0}\to f_{u,j+k-1,0}$
$f_{u,j,0}{f}_{v,k,1}+f_{u,j,1}{f}_{v,k,0}\to f_{u,j+k-1,1}$
（这些是连接的）

然后我们要的就是 $f_{rt,x,1}$，把它翻转（就从连通块变成重合边树）就可以二项式定理搞输出答案了。

代码

#include<cstdio>
#include<algorithm>
#define ll long long
#define mo 1000000007

using namespace std;

struct node {
    
    
	int to, nxt;
}e[201];
int n, x, y, le[101], KK;
int sz[201];
ll f[201][201][2], G[201], tmp[201][201][2], F[201];

void add(int x, int y) {
    
    
	e[++KK] = (node){
    
    y, le[x]}; le[x] = KK;
	e[++KK] = (node){
    
    x, le[y]}; le[y] = KK;
}

void dfs(int now, int father) {
    
    //树形DP
	f[now][1][0] = f[now][1][1] = 1; sz[now] = 1;
	for (int i = le[now]; i; i = e[i].nxt)
		if (e[i].to != father) {
    
    
			dfs(e[i].to, now);
			
			for (int j = 1; j <= sz[now]; j++)
				for (int k = 1; k <= sz[e[i].to]; k++) {
    
    
					tmp[now][j + k][0] = (tmp[now][j + k][0] + f[now][j][0] * f[e[i].to][k][1] % mo) % mo;
					tmp[now][j + k][1] = (tmp[now][j + k][1] + f[now][j][1] * f[e[i].to][k][1] % mo) % mo;
					tmp[now][j + k - 1][0] = (tmp[now][j + k - 1][0] + f[now][j][0] * f[e[i].to][k][0] % mo) % mo;
					tmp[now][j + k - 1][1] = (tmp[now][j + k - 1][1] + (f[now][j][0] * f[e[i].to][k][1] % mo + f[now][j][1] * f[e[i].to][k][0] % mo) % mo) % mo;
				}
			
			sz[now] += sz[e[i].to];
			
			for (int j = 1; j <= sz[now]; j++) {
    
    
				f[now][j][0] = tmp[now][j][0], f[now][j][1] = tmp[now][j][1];
				tmp[now][j][0] = tmp[now][j][1] = 0;
			}
		}
}

ll jc[201], inv[201];

ll C(int n, int m) {
    
    
	return jc[n] * inv[m] % mo * inv[n - m] % mo;
}

ll ksm(ll x, ll y) {
    
    
	ll re = 1;
	while (y) {
    
    
		if (y & 1) re = re * x % mo;
		x = x * x % mo;
		y >>= 1;
	}
	return re;
}

void get_ans() {
    
    
	jc[0] = 1;
	for (int i = 1; i <= n; i++) jc[i] = jc[i - 1] * i % mo;
	inv[0] = inv[1] = 1;
	for (int i = 2; i <= n; i++) inv[i] = inv[mo % i] * (mo - mo / i) % mo;
	for (int i = 1; i <= n; i++) inv[i] = inv[i - 1] * inv[i] % mo;
	
	for (int i = 1; i <= n; i++)//扩展Cayley公式
		if (i != 1) F[i] = f[1][i][1] * ksm(n, i - 2) % mo;
			else F[1] = 1;
	reverse(F, F + n + 1);
	
	ll zt;
	for (int i = 0; i < n; i++) {
    
    //二项式反演
		for (int j = i; j <= n; j++) {
    
    
			if ((j - i) & 1) zt = -1;
				else zt = 1;
			G[i] = (G[i] + zt * C(j, i) * F[j] % mo + mo) % mo;
		}
		printf("%lld ", G[i]);
	}
}

int main() {
    
    
	scanf("%d", &n);
	for (int i = 1; i < n; i++) {
    
    
		scanf("%d %d", &x, &y);
		add(x, y);
	}
	
	dfs(1, 0);
	
	get_ans();
	
	return 0;
}