原文链接 https://www.cnblogs.com/cly-none/p/ZJOI2017cactus.html

给出一个\(n\)个点\(m\)条边的无向连通图，求有多少种加边方案，使得加完后得到一个仙人掌。

\(n \leq 5 \times 10^5, \ m \leq 10^6\)

首先，判定无解后，我们可以把每个环删掉，那么答案就是剩下的若干树的加边方案的乘积。

于是就考虑一棵树怎么做。

sol1

令\(dp_i\)表示在结点\(i\)的子树中的答案。考虑如何转移。

注意到，假如我们把\(i\)和它子树中的某个点\(v\)连一条边，那么这样得到的方案数就与\(i\)到\(v\)的链有关。对于链上最后一个点即\(v\)，它能产生\(dp_v\)的贡献；否则，对于链上的点\(a\)，若它在链上的下一个（深度较大的）点是\(b\)，那么\(a\)能产生的贡献就是\(a\)删掉\(b\)这个子树后的dp值。整条链能产生的方案数就是所有贡献的乘积。

于是我们令\(sdp_i\)表示在\(i\)的子树中，以\(i\)为一段的所有链的方案数之和。这记录的是这个子树的所有向\(i\)的父亲连边的方案数。（不连边其实就是\(i\)向外连）

再考虑一棵子树向外连边有两种情况，一是直接连到当前的根上，二是和另一颗子树配对。

所以我们令\(g_i\)表示\(i\)个元素，每个元素都能任意配对也能不配对（即连到根上）的方案数。那么就有\(dp_i = \prod_{v \in child_i} sdp_v g_{|child_i|}\)。其中\(child_i\)表示结点\(i\)的所有孩子构成的集合。

考虑如何计算\(g_n\)。我们可以枚举元素\(n\)的状态。有两种可能：

• 不匹配。即\(g_{n-1}\)。
• 匹配。那么枚举它和哪个元素匹配。即\((n-1)g_{n-2}\)。

于是就能计算出所有\(g_n\)了。

用类似的方法也能算出\(sdp_i\)。可以用前缀积和后缀积来避免计算逆元，做到\(O(n)\)复杂度。

下面代码是\(O(n \log n)\)的，\(\log n\)在计算逆元上。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
#define fir first
#define sec second
#define rep(i,a,b) for (int i = (a) ; i <= (b) ; ++ i)
#define rrp(i,a,b) for (int i = (a) ; i >= (b) ; -- i)
#define gc() getchar()
template <typename tp>
inline void read(tp& x) {
  x = 0; char tmp; bool key = 0;
  for (tmp = gc() ; !isdigit(tmp) ; tmp = gc())
    key = (tmp == '-');
  for ( ; isdigit(tmp) ; tmp = gc())
    x = (x << 3) + (x << 1) + (tmp ^ '0');
  if (key) x = -x;
}

const int N = 500010, M = 1000010, MOD = 998244353;
int power(int a,int b) {
  int ret = 1;
  while (b) {
    if (b & 1) ret = 1ll * ret * a % MOD;
    a = 1ll * a * a % MOD;
    b >>= 1;
  }
  return ret;
}
inline void Add(int& x,int y) {
  x = x + y >= MOD ? x + y - MOD : x + y;
}
struct edge {
  int la,b;
} con[M << 1];
int tot,fir[N],n,m,ans;
void add(int from,int to) {
  con[++tot] = (edge) {fir[from], to};
  fir[from] = tot;
}
int dfn[N], low[N], col[N], sta[N], top, ecnt, ccnt;
pii edg[M];
void dfs(int pos,int fa) {
  sta[low[pos] = dfn[pos] = ++ top] = pos;
  for (int i = fir[pos] ; i ; i = con[i].la) {
    if (con[i].b == fa) continue;
    if (dfn[con[i].b]) low[pos] = min(low[pos], dfn[con[i].b]);
    else {
      dfs(con[i].b, pos);
      low[pos] = min(low[pos], low[con[i].b]);
      if (low[con[i].b] >= dfn[pos]) {
        if (low[con[i].b] > dfn[pos])
          edg[++ecnt] = pii(pos, con[i].b);
        else ++ ccnt;
        top = dfn[pos];
      }
    }
  }
}
int dp[N], sdp[N], sz[N], jc[N], inv[N], vis[N];
void fsd(int pos,int fa) {
  vis[pos] = 1;
  dp[pos] = 1;
  sz[pos] = 1;
  int num = 0;
  for (int i = fir[pos] ; i ; i = con[i].la) {
    if (con[i].b == fa) continue;
    fsd(con[i].b, pos);
    sz[pos] += sz[con[i].b];
    dp[pos] = 1ll * sdp[con[i].b] * dp[pos] % MOD;
    ++ num;
  }
  int tmp = 0, tmp1 = 0;
  for (int k = 0, ipw2 = 1 ; k * 2 <= num ; ++ k) {
    Add(tmp,1ll * jc[num] * inv[k] % MOD * inv[num - 2 * k] % MOD * ipw2 % MOD);
    ipw2 = 1ll * ipw2 * (MOD + 1) / 2 % MOD;
  }
  -- num;
  for (int k = 0, ipw2 = 1 ; k * 2 <= num ; ++ k) {
    Add(tmp1,1ll * jc[num] * inv[k] % MOD * inv[num - 2 * k] % MOD * ipw2 % MOD);
    ipw2 = 1ll * ipw2 * (MOD + 1) / 2 % MOD;
  }
  for (int i = fir[pos] ; i ; i = con[i].la) {
    if (con[i].b == fa) continue;
    Add(sdp[pos], 1ll * dp[pos] * power(sdp[con[i].b], MOD-2) % MOD * tmp1 % MOD * sdp[con[i].b] % MOD);
  }
  dp[pos] = 1ll * dp[pos] * tmp % MOD;
  Add(sdp[pos], dp[pos]);  
}
void init() {
  memset(fir,0,sizeof(int) * (n + 5));
  memset(dfn,0,sizeof(int) * (n + 5));
  tot = ecnt = ccnt = top = 0;
  ans = 1;
  memset(dp,0,sizeof(int) * (n + 5));
  memset(sdp,0,sizeof(int) * (n + 5));
  memset(vis,0,sizeof(int) * (n + 5));
}
void solve() {
  read(n), read(m);
  init();
  jc[0] = 1;
  rep (i, 1, n) jc[i] = 1ll * jc[i-1] * i % MOD;
  inv[n] = power(jc[n], MOD - 2);
  rrp (i, n-1, 0) inv[i] = 1ll * inv[i+1] * (i+1) % MOD;
  for (int i = 1, x, y ; i <= m ; ++ i) {
    read(x), read(y);
    add(x,y);
    add(y,x);
  }
  rep (i, 1, n) if (!dfn[i]) dfs(i, 0);
  if (n - 1 + ccnt != m) {
    puts("0");
    return;
  }
  tot = 0;
  memset(fir,0,sizeof(int) * (n + 5));
  rep (i, 1, ecnt) {
    add(edg[i].fir, edg[i].sec);
    add(edg[i].sec, edg[i].fir);
  }
  rep (i, 1, n) {
    if (vis[i]) continue;
    fsd(i, 0);
    ans = 1ll * dp[i] * ans % MOD;
  }
  ans = (ans % MOD + MOD) % MOD;
  printf("%d\n", ans);
}
int main() {
  int T;
  read(T);
  while (T --)
    solve();
  return 0;
}

---

sol2

上面做法对链的分析太复杂了，于是我们考虑直接用组合意义计算\(sdp_i\)。

分两种情况：

• 让结点\(i\)负责向上连边。那么答案就是\(\prod_{v \in child_i} sdp_v g_{|child_i|}\)。
• 让\(i\)的某个孩子内的结点向上连边。我们就枚举这是哪个孩子内的结点。即\(|child_i| \times \prod_{v \in child_i} sdp_v g_{|child_i|-1}\)。

这样就简单多了。

小结：这道题的巧妙之处在于对一些组合意义的运用，比较常规，且直接大力分析也能解决。