【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\limits_{j=i}^n\binom{j}{i} G_j\)。
那我们可以用二项式反演，得到 \(G_i=\sum\limits_{j=i}^n(-1)^{j-i}\binom{j}{i} G_j\)。
（就可以直接暴力 \(O(n^2)\) 求）

这里多说一下，如果是 \(F_{i}=\sum\limits_{j=0}^i\binom{i}{j} G_j\)。
那它的二项式反演就是 \(G_i=\sum\limits_{j=0}^i(-1)^{i-j}\binom{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\limits_{i=1}^k a_i\) 棵生成树。
这个也可以用 prufer 序列或者矩阵树之类的证明。

然后问题就是 \(\prod\limits_{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}\rightarrow f_{u,j+k,0}\)
\(f_{u,j,1}f_{v,k,1}\rightarrow f_{u,j+k,1}\)
（这些是不连接的）
\(f_{u,j,0}f_{v,k,0}\rightarrow f_{u,j+k-1,0}\)
\(f_{u,j,0}f_{v,k,1}+f_{u,j,1}f_{v,k,0}\rightarrow 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;
}