【题解】HNOI-2018毒瘤

Problem

洛谷 & pdf题面

题目概述：

给定一张$n$个点$m$条边的无向图，求独立集数量

$n\leq 100000,m-n\leq 10$

Thoughts

话说在考场上居然没开$long~long$，直挂$25$分

一开始看题面，观察特殊数据，发现如果这个图是一棵树，可以树型Dp，方程：

$f[x][0]=\prod (f[son][0]+f[son][1])$
$f[x][1]=\prod f[son][0]$

观察到数据$m-n\leq 10$，意味着树之外最多有$11$条边，明显可以暴力枚举这些边的两端节点的选取与否（有三种状态：$(1,0),(0,0),(0,1)$）

复杂度$O(3^{m-n+1}n)$，预期得分$55$分，实际得分$65$分，蒟蒻爆$long~long$，得分……

发现其实只要限制其中一个点时，$(0,0)$与$(0,1)$可以同时转移，所以对于每条边只有两种情况

复杂度$O(2^{n-m+1}n)$，预期得分$80$分，实际得分$80$~$100$分，蒟蒻爆$long~long$，得分……

Solution

正解是虚树Dp，蒟蒻不会……

虚树部分：

实际上就是将剩下的这$m-n+1$条边的两端的点作为关键点，同时为了保证这棵树的整体状态不变，我们还要选取其中任意两个点的$lca$，为了降低复杂度，我们将这些点根据$dfs$序排序，只要选取相邻两个的$lca$即可，用一个栈可以实现

Dp部分：

先减除冗杂部分（即仅与一个关键节点相连的子树），我们考虑先将虚树之外的贡献设为$g[x][0/1]$，转移方程和上面一样，只不过只有在子树不属于虚树时要转移

其次，为了使虚树中压缩的路径得以体现，我们采用对系数进行$Dp$，提前预处理出虚树上每一条边的转移系数，可以采用树型$Dp$解决

一定要时刻提醒自己因$long~long$翻的车

Code

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rg register

template <typename _Tp> inline _Tp read(_Tp&x){
    char c11=getchar(),ob=0;x=0;
    while(c11^'-'&&!isdigit(c11))c11=getchar();if(c11=='-')c11=getchar(),ob=1;
    while(isdigit(c11))x=x*10+c11-'0',c11=getchar();if(ob)x=-x;return x;
}

const int N=101000,p=998244353;
int lx[N],rx[N],dfn[N],vis[N],is[N],head[N],Head[N];
int f[N][2],g[N][2],shall[N][2];
int n,m,ans,dfc,tot,_,__;

struct Par{
    int x,y;
    Par(){}
    Par(const int&Ax,const int&By){x=Ax,y=By;}
    inline Par operator + (const Par&bb) const {return Par((x+bb.x)%p,(y+bb.y)%p);}
    inline Par operator * (const int bb) const {return Par(int(1ll*x*bb%p),int(1ll*y*bb%p));}
    inline void operator += (const Par&bb) {*this=*this+bb;}
    inline void operator *= (const int&bb) {*this=*this*bb;}
}k[N][2];

struct Edge{int v,nxt;}a[N<<1];
struct vEdge{int v,nxt;Par a,b;}e[2000];

inline void add(int u,int v){a[++_].v=v,a[_].nxt=head[u],head[u]=_;}

inline void add2(int u,int v,Par a,Par b){e[++__].v=v,e[__].a=a,e[__].b=b,e[__].nxt=Head[u],Head[u]=__;}

inline int build(int x){
    g[x][0]=g[x][1]=1;
    int son=0;vis[x]=1;
    for(int i=head[x];i;i=a[i].nxt)
        if(!vis[a[i].v]){
            int to=build(a[i].v);
            if(!to){
                g[x][0]=1ll*g[x][0]*(g[a[i].v][0]+g[a[i].v][1])%p;
                g[x][1]=1ll*g[x][1]*g[a[i].v][0]%p;
            }else if(is[x])add2(x,to,k[a[i].v][0]+k[a[i].v][1],k[a[i].v][0]);
            else k[x][0]=k[a[i].v][0]+k[a[i].v][1],k[x][1]=k[a[i].v][0],son=to;
        }
    if(is[x])k[x][0]=Par(1,0),k[x][1]=Par(0,1);
    else k[x][0]*=g[x][0],k[x][1]*=g[x][1];
    return is[x]?x:son;
}

inline int dfs(int x,int las){
    dfn[x]=++dfc;
    int cnt=0;
    for(int i=head[x];i;i=a[i].nxt)
        if(a[i].v!=las)
            if(!dfn[a[i].v])cnt+=dfs(a[i].v,x);
            else {
                is[x]=1;
                if(dfn[x]<dfn[a[i].v])lx[++tot]=x,rx[tot]=a[i].v;
            }
    if(cnt>1)is[x]=1;
    return cnt||is[x];
}

inline void dp(int x){
    if(shall[x][1])f[x][0]=0;else f[x][0]=g[x][0];
    if(shall[x][0])f[x][1]=0;else f[x][1]=g[x][1];
    for(rg int i=Head[x];i;i=e[i].nxt){
        dp(e[i].v);
        f[x][0]=1ll*f[x][0]*(1ll*e[i].a.x*f[e[i].v][0]%p+1ll*e[i].a.y*f[e[i].v][1]%p)%p;
        f[x][1]=1ll*f[x][1]*(1ll*e[i].b.x*f[e[i].v][0]%p+1ll*e[i].b.y*f[e[i].v][1]%p)%p;
    }
}

int main(){
    read(n);read(m);int x,y;
    for(rg int i=0;i<m;++i)read(x),read(y),add(x,y),add(y,x);
    dfs(1,0);is[1]=1;build(1);
   for(rg int S=0;S<(1<<tot);++S){
        for(rg int i=1;i<=tot;++i)
            if(S&(1<<(i-1)))
                shall[lx[i]][1]=shall[rx[i]][0]=1;
            else shall[lx[i]][0]=1;
        dp(1);ans=(ans+(f[1][1]+f[1][0])%p)%p;
        for(rg int i=1;i<=tot;++i)
            if(S&(1<<(i-1)))
                shall[lx[i]][1]=shall[rx[i]][0]=0;
            else shall[lx[i]][0]=0;
    }
    printf("%d\n",ans);
    return 0;
}