2021ICPC沈阳L（树形dp+容斥）

题目大意：

$2\ast n$个顶点的完全图，从中删除$2\ast n-1$条边，这$2\ast n-1$条边构成一颗树，从剩下的边中有多少种选出$n$条边的方法，这$n$条边没有点的交集

解题思路：

• 题目希望我们在完全图上求出有多少种方案，方案不包含删除的边，这不就典型的容斥吗…求任何k个条件即k条边一定选其他边任选的方案数

• $$\begin{gathered} Ans=(从树上选0条边的方案数)\ast (剩下2n个点的完全图选n条边的方案数)- \\ (从树上选1条边的方案数)\ast (剩下2n-2个点的完全图任选n-1条边的方案数)+ \\ (从树上选2条边的方案数)\ast (剩下2n-4个点的完全图任选n-2条边的方案数)-... \end{gathered}$$

• 对于树上选$k$条边的方案数，要满足这$k$条边不会有公共顶点，树形$dp$即可（选与不选嘛），设$dp[i][j][0/1]$为以$i$为根的子树下选了j条边匹配，且第$i$个点在其中出现$or$不出现

• 对于$2\ast n$完全图选的方案数为$fac[2\ast n]/(fac[n]\ast 2^n)$，即两两为一组，先全排列，再除去$n$组全排列，因为顺序无关，再除去$2^n$，因为每组中两个的顺序也无关

AC代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 998244353;
const int maxn = 4005;
int n;
bool vis[maxn][maxn];
vector <int> G[maxn];
ll fac[maxn], rfac[maxn], inv2[maxn];
ll dp[maxn][2005][2];
int sz[maxn];
ll qpow(ll a, ll b) {
    ll res = 1;
    a %= mod;
    while (b) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}
inline ll C(int n, int m) {
    if (n >= m) return fac[n] * rfac[m] % mod * rfac[n - m] % mod;
    else return 0;
}
void init() {
    scanf("%d", &n);
    for (int i = 1, u, v; i < 2 * n; i++) {
        scanf("%d %d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    fac[0] = 1;
    for (int i = 1; i < maxn; i++) fac[i] = fac[i - 1] * i % mod;
    rfac[maxn - 1] = qpow(fac[maxn - 1], mod - 2);
    for (int i = maxn - 2; i >= 0; i--) rfac[i] = rfac[i + 1] * (i + 1) % mod;
    ll mod2 = qpow(2, mod - 2);
    inv2[0] = 1;
    for (int i = 1; i < maxn; i++) inv2[i] = inv2[i - 1] * mod2 % mod;
}
void dfs(int u, int fu) {
    dp[u][0][0] = 1;
    sz[u] = 1;
    for (auto v : G[u]) { //常见树形dp，子树合并到根节点上，再更新新的合并后子树与遍历到的不同子树
        if (v == fu) continue;
        dfs(v, u);
        for (int i = sz[u] / 2; i >= 0; i--)
            for (int j = sz[v] / 2; j >= 0; j--) { //从后往前就不用另开一个数组来存储更新值了
                if (j) {
                    dp[u][i + j][0] = (dp[u][i + j][0] + dp[u][i][0] * (dp[v][j][1] + dp[v][j][0]) % mod) % mod;
                    dp[u][i + j][1] = (dp[u][i + j][1] + dp[u][i][1] * (dp[v][j][1] + dp[v][j][0]) % mod) % mod;                    
                }
                //(u,v)被选了
                dp[u][i + j + 1][1] = (dp[u][i + j + 1][1] + dp[u][i][0] * dp[v][j][0] % mod) % mod;
            }
        sz[u] += sz[v];
    }
}
int main() {
    init();
    dfs(1, 0);
    ll ans = 0;
    for (int i = 0; i <= n; i++) {
        ll x = 2 * n - 2 * i;
        ll res = (dp[1][i][0] + dp[1][i][1]) % mod;
        res = res * (fac[x] * rfac[x / 2] % mod * inv2[x / 2] % mod) % mod;
        if (i & 1) ans = (ans - res) % mod;
        else ans = (ans + res) % mod;
    }
    ans = (ans % mod + mod) % mod;
    printf("%lld\n", ans);
}