bzoj4784 [Zjoi2017]仙人掌

Description

如果一個無自環無重邊無向連通圖的任意一條邊最多屬於一個簡單環，我們就稱之為仙人掌。所謂簡單環即不經過重復的結點的環。

現在九條可憐手上有一張無自環無重邊的無向連通圖，但是她覺得這張圖中的邊數太少了，所以她想要在圖上連上一些新的邊。同時為了方便的存儲這張無向圖，圖中的邊數又不能太多。經過權衡，她想要加邊后得到的圖為一棵仙人掌。不難發現合法的加邊方案有很多，可憐想要知道總共有多少不同的加邊方案。兩個加邊方案是不同的當且僅當一個方案中存在一條另一個方案中沒有的邊。

Input

多組數據，第一行輸入一個整數T表示數據組數。

每組數據第一行輸入兩個整數n,m，表示圖中的點數與邊數。

接下來m行，每行兩個整數u,v(1≤u,v≤n,u!=v)表示圖中的一條邊。保證輸入的圖聯通且沒有自環與重邊

Sigma(n)<=5*10^5,m<=10^6,1<=m<=n*(n-1)/2

Output

對於每組數據，輸出一個整數表示方案數，當然方案數可能很大，請對998244353取模后輸出。

Sample Input

2
3 2
1 2
1 3
5 4
1 2
2 3
2 4
1 5

Sample Output

2
8
對於第一組樣例合法加邊的方案有 {}, {(2,3)}，共 2 種。

 

正解：仙人掌$DP$

這題好難啊。。我看題解都看了好久才看懂。。

先給兩個博客：http://blog.csdn.net/akak__ii/article/details/65935711

ljh2000：http://www.cnblogs.com/ljh2000-jump/p/6613829.html

首先特判不是仙人掌的情況，只要判每個點到達根的路徑是否大於$2$條就行了。

然后我們可以先把環拆掉，也就是把環邊和對應的那個點與它父親斷開，因為環是不會對答案造成貢獻的。然后這個仙人掌就會變成一個森林。於是我們就成功地把仙人掌$DP$變成了樹形$DP$。我們單獨考慮每棵樹的答案，乘法原理一下就好。

然后就是對於每棵樹統計答案了。

對於一個點$x$，我們設$f[x]$表示$x$這棵子樹連邊形成仙人掌的方案數。我們發現，可以分為兩種情況：

1，$x$這棵子樹一定不與祖先連邊，這個是根的情況。

2，$x$這棵子樹可能與祖先連邊，這個是除了根以外其他點的情況。

對於第1種情況，我們把$x$所有的兒子$f[v]$都乘起來，並且我們計算一下$x$的兒子互相連邊的情況，再乘起來就行了。

對於$x$的兒子互相連邊的情況，我們可以找到一個規律。我們設$g[i]$表示$i$個兒子互相連邊的合法方案數，那么$g[i]=g[i-1]+(i-1)*g[i-2]$。

這是怎么來的呢？我們考慮一下，如果第$i$個點不與其他點連邊，那么方案數就是$g[i-1]$，否則，第$i$個點與第$j$個點連邊，那么第$j$個點肯定不能與其他點連邊，所以方案數是$g[i-2]$，總共有$i-1$種情況，所以$g[i]=g[i-1]+(i-1)*g[i-2]$。那么我們設$x$有$tot$個兒子，於是$f[x]=\prod f[v]*g[tot]$。

那么現在我們只要考慮第二種情況了。其實仔細想想，就是$x$的所有兒子$f[v]$相乘，再乘上$g[tot+1]$就行了。因為這就是$tot+1$個點互相連邊的情況。於是$f[x]=\prod f[v]*g[tot+1]$。

於是這道題我們就完美地解決了。

 

//It is made by wfj_2048~
#include <algorithm>
#include <iostream>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define rhl (998244353)
#define inf (1<<30)
#define M (1000010)
#define N (500010)
#define il inline
#define RG register
#define ll long long
#define File(s) freopen(s".in","r",stdin),freopen(s".out","w",stdout)

using namespace std;

struct edge{ int nt,to; }G[2*M];
struct node{ int i,d; }a[N];

int head[N],fa[N],dfn[N],dep[N],lu[N],n,m,cnt;
ll f[N],g[N],ans;

il int gi(){
    RG int x=0,q=1; RG char ch=getchar();
    while ((ch<'0' || ch>'9') && ch!='-') ch=getchar();
    if (ch=='-') q=-1,ch=getchar();
    while (ch>='0' && ch<='9') x=x*10+ch-48,ch=getchar();
    return q*x;
}

il void insert(RG int from,RG int to){
    G[++cnt]=(edge){head[from],to},head[from]=cnt; return;
}

il int cmpd(const node &a,const node &b){ return a.d<b.d; }

il void pre(){ //預處理g數組
    g[0]=g[1]=1;
    for (RG int i=2;i<=500000;++i) g[i]=(g[i-1]+(i-1)*g[i-2])%rhl;
    return;
}

il void dfs(RG int x,RG int p){
    fa[x]=p,dfn[x]=++cnt,dep[x]=dep[p]+1;
    for (RG int i=head[x],v;i;i=G[i].nt){
    v=G[i].to; if (dfn[v]) continue;
    dfs(v,x);
    }
    return;
}

il void dp(RG int x,RG int rt){
    lu[x]=-1,f[x]=1; RG int tot=0,v;
    for (RG int i=head[x];i;i=G[i].nt){
    v=G[i].to; if (v==fa[x] || lu[v]!=1) continue;
    tot++; dp(v,0); f[x]=f[x]*f[v]%rhl;
    }
    if (!rt) f[x]=f[x]*g[tot+1]%rhl;
    else f[x]=f[x]*g[tot]%rhl;
    return;
}

il void work(){
    n=gi(),m=gi(),cnt=1;
    for (RG int i=1;i<=n;++i) lu[i]=fa[i]=dep[i]=dfn[i]=head[i]=0;
    for (RG int i=1,u,v;i<=m;++i) u=gi(),v=gi(),insert(u,v),insert(v,u);
    cnt=0; dfs(1,0);
    for (RG int i=1,u,v;i<=m;++i){ //統計每個點到根的路徑數
    u=G[i<<1].to,v=G[i<<1|1].to;
    if (dfn[u]<dfn[v]) swap(u,v);
    while (u!=v){
        if (lu[u]==2){ printf("0\n"); return; }
        lu[u]++,u=fa[u];
    }
    }
    for (RG int i=1;i<=n;++i) a[i].i=i,a[i].d=dep[i];
    sort(a+1,a+n+1,cmpd); ans=1;
    for (RG int i=1,x;i<=n;++i){
    x=a[i].i; if (lu[x]==-1) continue;
    dp(x,1); ans=ans*f[x]%rhl;
    }
    printf("%lld\n",ans); return;
}

int main(){
    File("cactus");
    pre(); RG int T=gi();
    while (T--) work();
    return 0;
}