2019徐州网络赛 J Random Access Iterator

题意

给出一颗有n个节点，以1号节点为根的树。现从1号节点开始，每次等概率地访问当前节点 u 的儿子中的一个节点 v，并赋予其深度 $d[v]=d[u]+1$， 对每个节点共执行 K 次这样的操作( K = 当前节点儿子的数量 ）。
问：用这种方式统计出的该树的最大深度 $ma{x}_{i=1}^n(d[i])$ 等于该树实际最大深度的概率。

分析

树形dp。
定义：

• d[u]表示从u开始以上述方式，访问其子树上的节点，能够取得正确深度的概率。

状态转移：

• $dp[u]=1-(1-\frac{sum}{k}{)}^k,sum={\sum }_{v=son[u]}dp[v]$ —— u非叶子节点
• $dp[u]=1$ —— u是叶子节点，且深度最大
• $dp[u]=0$ —— 其余叶子节点

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 1e6 + 10;
const LL mod = 1e9 + 7;

vector<int> G[maxn];

int max_dep = 0, dep[maxn], son[maxn];
LL dp[maxn];

LL extgcd(LL a, LL b, LL &x, LL & y) {
    LL d = a;
    if (b != 0) {
        d = extgcd(b, a % b, y, x);
        y -= (a / b) * x;
    } else {
        x = 1; y = 0;
    }
    return d;
}
LL mod_inverse(LL a, LL m) {
    LL x, y;
    extgcd(a, m, x, y);
    return (m + x % m) % m;
}

void add_edge(int u, int v)
{
    G[u].push_back(v); G[v].push_back(u);
}

void dfs(int u, int p)
{
    dep[u] = dep[p] + 1;
    max_dep = max(max_dep, dep[u]);
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (v == p) continue;
        dfs(v, u);
        son[u]++;
    } 
}

LL fast(LL x, LL k)
{
    if (k == 0) return 1;
    if (k == 1) return x;
    LL ret = fast(x, k / 2);
    if (k & 1) return x*ret%mod*ret%mod;
    else return ret*ret%mod;
}
LL calc(LL k, LL sum)
{
    LL m = (k - sum + mod) % mod, mi = mod_inverse(k, mod);
    LL f = fast(m * mi % mod, k);
    return (1 - f + mod) % mod;
}
void fuck(int u, int p)
{
    if (son[u] == 0) {
        dp[u] = (dep[u] == max_dep);
        return;
    }
    LL sum = 0;
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (v == p) continue;
        fuck(v, u);
        sum += dp[v];
    }
    dp[u] = calc((LL)son[u], sum);
}
int main()
{
    freopen("J.in","r",stdin);
    int n;
    cin >> n;
    for (int i = 0; i < n-1; i++) {
        int u, v;
        cin >> u >> v;
        add_edge(u, v);
    }
    dfs(1, 0);
    fuck(1, 0);
 /*   for (int i = 1; i <= n; i++)
        cout << dp[i] << ' '; */
 //   cout << endl;
    cout << dp[1] << endl;
}