[HNOI2018]毒瘤

Description

从前有一名毒瘤。

毒瘤最近发现了量产毒瘤题的奥秘。考虑如下类型的数据结构题：给出一个数组，要求支持若干种奇奇怪怪的修改操作（比如区间加一个数，或者区间开平方），并支持询问区间和。毒瘤考虑了\(n\)个这样的修改操作，并编号为\(1\sim n\)。当毒瘤要出数据结构题的时候，他就将这些修改操作中选若干个出来，然后出成一道题。

当然了，这样出的题有可能不可做。通过精妙的数学推理，毒瘤揭露了这些修改操作的关系：有\(m\)对“互相排斥”的修改操作，第\(i\)对是第\(u_i\)个操作和第\(v_i\)个操作。当一道题同时含有\(u_i\)和\(v_i\)这两个操作时，这道题就会变得不可做。另一方面，一道题中不包含任何“互相排斥”的修改操作时，这个题就是可做的。此外，毒瘤还发现了一个规律：\(m-n\)是一个很小的数字，且任意两个修改操作都是连通的。两个修改操作\(a,b\)是连通的，当且仅当存在若干操作\(t_0,t_1,...,t_l\)，使得\(t_0=a,t_l=b\)，且对\(1\leqslant i\leqslant l\)，\(t_{i-1}\)和\(t_i\)都是“互相排斥”的修改操作。

一堆“互相排斥”的修改操作称为互斥对。现在毒瘤想知道，给定值\(n\)和\(m\)个互斥对，他共能出出多少道可做的不同的数据结构题。两道数据结构题是不同的，当且仅当有一个修改操作在其中一道题中存在，而在另一道题中不存在。

Input

第一行为正整数\(n,m\)。

接下来\(m\)行，每行两个正整数\(u,v\)，代表一对“互相排斥”的修改操作。

Output

输出一行一个整数，代表毒瘤可以出的可做的不同的“互相排斥”的修改操作的个数。这个数可能很大，所以只输出模998244353后的值。

Sample Input 1

3 2

1 2

2 3

Sample Output 1

5

Sample Input 2

6 8

1 2

1 3

1 4

2 4

3 5

4 5

4 6

1 6

Sample Output 2

16

Sample Input 3

12 18

12 6

3 11

8 6

2 9

10 4

1 8

6 2

11 5

10 6

12 2

9 3

7 6

2 7

3 2

7 3

5 6

2 11

12 1

Sample Output 3

248

HINT

---

首先考虑\(m=n-1\)的情况，我们直接做一遍tree dp，设\(f[u][0/1]\)表示点\(u\)选或不选的方案数，转移即为$$\begin{cases}f[u][0]=\prod\limits_{u\rightarrow v}(f[v][0]+f[v][1])\f[u][1]=\prod\limits_{u\rightarrow v}f[v][0]\end{cases}$$

这样我们可以得到10pts的好成绩，那么多出来的非树边如何处理？因为最多只有11条非树边，暴力枚举端点状态，只有\((1,0),(0,0),(0,1)\)三种，但其实只要枚举一个点选或不选，\((0,0)\)和\((0,1)\)可以合并起来，复杂度\(O(2^{m-n+1}n)\)，可以得到75pts的好成绩

如何拿满分？我们发现上面的算法重复计算了很多状态，我们把非树边影响的点取出来，记为关键点，影响dp值的只有这些点，我们把这些关键点（至多22个）建立一棵虚树，dp方程可以转化为$$\begin{cases}f[u][0]=\prod\limits_{u\rightarrow v}k_{u\rightarrow v,0,0}\times f[v][0]+k_{u\rightarrow v,0,1}\times f[v][1]\f[u][1]=\prod\limits_{u\rightarrow v}k_{u\rightarrow v,1,0}\times f[v][0]+k_{u\rightarrow v,1,1}\times f[v][1]\end{cases}$$

其实可以发现，\(k_{u\rightarrow v,0/1,0/1}\)是不会变化的，那么我们就先预处理出系数，如何求？\(v\)在原树上暴力向上跳，累计统计系数即可，记得统计的时候不能重复统计

这样转移的复杂度是\(O(n)\)的，对于虚树上的边我们暴力枚举状态，然后转移，记\(s\)为关键点数，则复杂度为\(O(n+s2^s)\)

/*program from Wolfycz*/
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define Fi first
#define Se second
#define MK make_pair
#define inf 0x7f7f7f7f
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef pair<int,int> pii;
typedef unsigned long long ull;
inline char gc(){
	static char buf[1000000],*p1=buf,*p2=buf;
	return p1==p2&&(p2=(p1=buf)+fread(buf,1,1000000,stdin),p1==p2)?EOF:*p1++;
}
inline int frd(){
	int x=0,f=1; char ch=gc();
	for (;ch<'0'||ch>'9';ch=gc())	if (ch=='-')	f=-1;
	for (;ch>='0'&&ch<='9';ch=gc())	x=(x<<3)+(x<<1)+ch-'0';
	return x*f;
}
inline int read(){
	int x=0,f=1; char ch=getchar();
	for (;ch<'0'||ch>'9';ch=getchar())	if (ch=='-')	f=-1;
	for (;ch>='0'&&ch<='9';ch=getchar())	x=(x<<3)+(x<<1)+ch-'0';
	return x*f;
}
inline void print(int x){
	if (x<0)	putchar('-'),x=-x;
	if (x>9)	print(x/10);
	putchar(x%10+'0');
}
const int N=1e5,Mod=998244353;
struct S1{
	int x,y;
	S1(){x=y=0;}
	void insert(int _x,int _y){x=_x,y=_y;}
}NT[15];//Not in Tree
int NT_cnt,dfn[N+10];
bool cmp(int x,int y){return dfn[x]<dfn[y];}
struct S2{
	int pre[(N<<1)+10],now[N+10],child[(N<<1)+10],tot,Time;
	int fa[N+10],size[N+10],deep[N+10],Rem[N+10],top[N+10],f[N+10][2];
	bool vis[N+10];
	void join(int x,int y){pre[++tot]=now[x],now[x]=tot,child[tot]=y;}
	void insert(int x,int y){join(x,y),join(y,x);}
	void dfs(int x){
		deep[x]=deep[fa[x]]+1,size[x]=1;
		for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){
			if (son==fa[x])	continue;
			fa[son]=x,dfs(son);
			size[x]+=size[son];
			if (size[Rem[x]]<size[son])	Rem[x]=son;
		}
	}
	void build(int x){
		if (!x)	return;
		dfn[x]=++Time;
		top[x]=Rem[fa[x]]==x?top[fa[x]]:x;
		build(Rem[x]);
		for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){
			if (son==fa[x]||son==Rem[x])	continue;
			build(son);
		}
	}
	int LCA(int x,int y){
		while (top[x]!=top[y]){
			if (deep[top[x]]<deep[top[y]])	swap(x,y);
			x=fa[top[x]];
		}
		return deep[x]<deep[y]?x:y;
	}
	void dp(int x){//在原树上dp一次，处理出原本的dp系数f
		f[x][0]=f[x][1]=1;
		for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){
			if (son==fa[x])	continue;
			dp(son);
			f[x][1]=1ll*f[x][1]*f[son][0]%Mod;
			f[x][0]=1ll*f[x][0]*(f[son][0]+f[son][1])%Mod;
		}
	}
	int work(int x,int y,int xv,int yv){//deep[x]<deep[y]
        //暴力上跳，求出边的系数
		static int tmp[2];
		tmp[yv]=1,tmp[yv^1]=0;
		while (x!=y){
			vis[y]=1;
			for (int p=now[y],son=child[p];p;p=pre[p],son=child[p]){
				if (son==fa[y]||vis[son])	continue;
				tmp[1]=1ll*tmp[1]*f[son][0]%Mod;
				tmp[0]=1ll*tmp[0]*(f[son][0]+f[son][1])%Mod;
			}
			swap(tmp[0],tmp[1]);
			tmp[0]=(tmp[0]+tmp[1])%Mod;
			//f[x][1]=f[son][0];
			//f[x][0]=f[son][0]+f[son][1];
            //向上跳一次要按如上方法转移，所以tmp数组需要按如上方法处理
			y=fa[y];
		}
		return tmp[xv];
	}
	pii work(int x){//处理关键点在虚树上应有的值
		static int tmp[2];
		tmp[0]=tmp[1]=1;
		for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){
			if (son==fa[x]||vis[son])	continue;
			vis[son]=1;
			tmp[1]=1ll*tmp[1]*f[son][0]%Mod;
			tmp[0]=1ll*tmp[0]*(f[son][0]+f[son][1])%Mod;
		}
		return MK(tmp[0],tmp[1]);
	}
}HLD;//Heavy Light Decomposition
const int M=22;
struct S3{
	int pre[(M<<2)+10],now[N+10],child[(M<<2)+10],tot,m;
	int V[(M<<2)+10][2][2];//V[p][i][j]: p:u->v i:u(0/1) j:v(0/1)
	int vis[N+10];//special point(0/1); normal point(-1)
	int f[N+10][2],g[N+10][2],A[M+10];
	void join(int x,int y){pre[++tot]=now[x],now[x]=tot,child[tot]=y;}
	void insert(int x,int y){join(x,y),join(y,x);}
	void rebuild(){
		static int stack[(M<<1)+10],top=0;
		for (int i=1;i<=NT_cnt;i++)	A[++m]=NT[i].x,A[++m]=NT[i].y;
		sort(A+1,A+1+m);
		m=unique(A+1,A+1+m)-A-1;
		stack[++top]=1;
		sort(A+1,A+1+m,cmp);
		for (int i=1;i<=m;i++){
			int x=A[i],lca=HLD.LCA(x,stack[top]);
			if (x==1)	continue;
			if (lca==stack[top]){
				stack[++top]=x;
				continue;
			}
			while (true){
				int y=stack[top-1];
				if (dfn[y]>=dfn[lca])	insert(stack[top--],y);
				else{
					if (lca==stack[top])	break;
					insert(stack[top],lca);
					stack[top]=lca; break;
				}
			}
			stack[++top]=x;
		}
		while (top>1){
			insert(stack[top-1],stack[top]);
			top--;
		}
	}
	void prepare(int x,int fa){
		for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){
			if (son==fa)	continue;
			prepare(son,x);
			for (int i=0;i<2;i++)
				for (int j=0;j<2;j++)
					V[p][i][j]=HLD.work(x,son,i,j);
		}
        //求出每个点本身应有的dp值，边的系数只考虑边，不考虑端点
		pii tmp=HLD.work(x);
		g[x][0]=tmp.Fi,g[x][1]=tmp.Se;
	}
	void dp(int x,int fa){
		if (vis[x]==-1)	f[x][0]=g[x][0],f[x][1]=g[x][1];
		else	f[x][vis[x]]=g[x][vis[x]],f[x][vis[x]^1]=0;
		for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){
			if (son==fa)	continue;
			dp(son,x);
			f[x][1]=1ll*f[x][1]*(1ll*f[son][0]*V[p][1][0]%Mod+1ll*f[son][1]*V[p][1][1]%Mod)%Mod;
			f[x][0]=1ll*f[x][0]*(1ll*f[son][0]*V[p][0][0]%Mod+1ll*f[son][1]*V[p][0][1]%Mod)%Mod;
		}
	}
	void work(){
		rebuild();
		prepare(1,0);
		memset(vis,255,sizeof(vis));
		int Ans=0;
		for (int sta=0;sta<1<<m;sta++){
			for (int i=1;i<=m;i++)	vis[A[i]]=(sta>>(i-1))&1;
			bool flag=1;
			for (int i=1;i<=NT_cnt;i++){
				if (vis[NT[i].x]&&vis[NT[i].y]){
					flag=0;
					break;
				}
			}
			if (!flag)	continue;
			dp(1,0);
			Ans=(Ans+(f[1][0]+f[1][1])%Mod)%Mod;
		}
		printf("%d\n",Ans);
	}
}VT;//Virtual Tree
struct S4{
	int fa[N+10];
	S4(){for (int i=1;i<=N;i++)	fa[i]=i;}
	int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
}DSU;//Disjoint Set Union
int main(){
	int n=read(),m=read();
	for (int i=1;i<=m;i++){
		int x=read(),y=read(),fx,fy;
		if ((fx=DSU.find(x))!=(fy=DSU.find(y))){
			DSU.fa[fx]=fy;
			HLD.insert(x,y);
		}else	NT[++NT_cnt].insert(x,y);
	}
	HLD.dfs(1),HLD.build(1),HLD.dp(1);
	VT.work();
	return 0;
}