小G砍树 （换根dp）

小G砍树

给你一棵n个节点的带标号无根树。每次，你可以选择一个度数为1的节点并将它从树上移除。问总共有多少种不同的方式能将这棵树删到只剩 1 个点。两种方式不同当且仅当至少有一步被删除的节点不同。

思路：先考虑以当前根节点的方案数。设d[x]为x这个节点最后被删除有多少种方案数，那么树形dp一次就可以求出。答案是所有的根节点的方案数之和，所以还需要换根dp。
一步一步的来，先考虑怎么进行第一次树形dp，已知子节点y的方案数，怎么求节点x的方案数呢？
可以这样想象，y1这颗子树共sum[y1]个节点，把y1这颗树删空需要操作sum[y1]次，同理，y2这颗树需要操作sum[y2]次。假设删除节点的顺序是固定的，那么删空y1只有一种方法，删空y2也只需要一种方法，但是一起删却不一样了。
问题转化为：
n个男生排成一排，m个女生排成一排，现在想合并两排成一排，男生和女生仍然都保持原来的顺序，有多少种合并方法？
n + m 个位置选出来给男生，剩下来的给女生，那么结果就是：C(n)(n+m)

(m + n)!
---------
 n! * m!

删除节点的顺序并不固定，删空y1有d[y1]种方法，y2同理。所以子树的方案数合并是：d[y1] * d[y2] * (sum[y1] + sum[y2]) ! / ( sum[y1]! * sum[y2]!)。
解决了第一次树形dp，接下来的换根dp也就不难了。

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 100000 + 5, mod = 998244353;
vector<int> v[N];
int f[N], d[N], sum[N];
int p[N];
int n;
int qpow(int x, int n)
{
    if (x == 0) return 1;
    int ret = 1;
    while(n)
    {
        if (n & 1) ret = ret * x % mod;
        x = x * x % mod;
        n >>= 1;
    }
    return ret;
}
void dp(int x, int fa)
{
    d[x] = 1;
    sum[x] = 1;
    int s = 0;
    for (auto i : v[x]) {
        int y = i;
        if (y == fa) continue;
        dp(y, x);
        d[x] = d[x] * d[y] % mod;
        d[x] = d[x] * f[s + sum[y]] % mod * qpow(f[s], mod - 2) % mod * qpow(f[sum[y]], mod - 2) % mod;
        // printf("%lld\n", d[x]);
        sum[x] += sum[y];
        s += sum[y];
    }
}
void dfs(int x, int fa)
{
    for (auto i : v[x]){
        int y = i;
        if (y == fa) continue;
        p[y] = p[x] * f[sum[y]] % mod * f[n - 1 - sum[y]] % mod;
        p[y] = p[y] * qpow(f[n - sum[y]], mod - 2) % mod * qpow(f[sum[y] - 1], mod - 2) % mod;
        dfs(y, x);
    }
}
signed main()
{
    // cout << 6 * qpow(2, mod - 2) % mod * qpow(1, mod - 2) % mod;
    cin >> n;
    for (int i = 1; i <= n - 1; i++) {
        int x, y;
        cin >> x >> y;
        v[x].push_back(y);
        v[y].push_back(x);
    }
    f[0] = 1;
    for (int i = 1; i <= n; i++) f[i] = f[i - 1] * i % mod;
    dp(1, 0);
    p[1] = d[1];
    // cout << d[1] << endl;
    dfs(1, 0);
    int ans = 0;
    for (int i = 1; i <= n; i++) ans = (ans + p[i]) % mod;
    cout << ans;
    return 0;
}