HDU 5378 树形dp转化为线性 计数转化为概率

这道题如果无脑dp的话，复杂度应该至少在(n^3)这个级别，而且转移的式子好像十分容易出错? 

也许从计数的角度上来说根本列不出来? 因为两棵子树的方案会互相影响!!!       

重点①: 首先计数可以转化为概率，当然不能用浮点，因为%质数，所以采用逆元

重点②: 给出的是一棵树，但不能掉进思维陷进，处理完树的一些节点信息后，可以用线性的dp做!!!(第一次做到这样的题目)

本题的状态: dp[i][j]表示       在 [1,i] 这 i 棵subtree中，以自己的根节点为leader的树有j棵的概率

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <stack>
#include <cctype>
#include <cmath>
#include <vector>
#include <sstream>
#include <bitset>
#include <deque>
#include <iomanip>
using namespace std;
#define pr(x) cout << #x << " = " << x << endl;
#define bug cout << "bugbug" << endl;
#define ppr(x, y) printf("(%d, %d)\n", x, y);
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define SQR(a) ((a)*(a))
#define PCUT puts("\n---------------")

typedef long long ll;
typedef double DBL;
typedef pair<int, int> P;
typedef unsigned int uint;
const int MOD = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 1e3 + 4;
const int maxm = 1e4 + 4;
const double pi = acos(-1.0);

ll quickpow(ll num, int p = MOD - 2){
	ll ret = 1;
	while(p){
		if (p & 1)	{
			ret *= num;
			ret %= MOD;
		}
		num *= num;
		num %= MOD;
		p >>= 1;
	}
	return ret;
}
ll inv[maxn], fac[maxn], dp[maxn][maxn];
vector<int> G[maxn];
int n = 0, K, sz[maxn];
void dfs(int u, int f){
	sz[u] = 1;
	for (int v : G[u]){
		if (v == f) continue;
		dfs(v, u);
		sz[u] += sz[v];
	}
	return;
}
int main(){
//必须编译过才能交
	int ik, i, j, k, kase;
	fac[1] = 1;
	for (i = 2; i < maxn; ++i) fac[i] = fac[i-1] * i % MOD;
	for (i = 0; i < maxn; ++i) inv[i] = quickpow(i);
	scanf("%d", &kase);
	for (ik = 1; ik <= kase; ++ik){
		scanf("%d%d", &n, &K);
		for (i = 0; i <= n; ++i) G[i].clear();
		for (i = 1; i < n; ++i){
			int u, v;
			scanf("%d%d", &u, &v);
			G[u].push_back(v);
			G[v].push_back(u);
		}
		dfs(1, 0);
		memset(dp, 0, sizeof dp);
		dp[0][0] = 1;
//		pr(dp[2][2])
		for (i = 1; i <= n; ++i)
			for (j = 0; j <= i; ++j)
				if (j == 0) dp[i][j] = (dp[i-1][j] * (sz[i] - 1) % MOD * inv[sz[i]] % MOD) % MOD;
				else dp[i][j] = (dp[i-1][j] * (sz[i] - 1) % MOD * inv[sz[i]] % MOD + dp[i-1][j-1] * inv[sz[i]] % MOD) % MOD;
		printf("Case #%d: %d\n", ik, int(dp[n][K] * fac[n] % MOD));
	}
	return 0;
}

在赛上想出来的人实在太神了！