Newcoder 26 C.手铐（边双连通分量+树形DP）

Description

给你一个连通无向图，保证每个点最多属于一个简单环，每个点度数最多为 $3$ ，求这个图有多少“手铐图形个数”

其中“手铐图形个数”，定义为三元组 $(x,y,S)$ ，其中 $x$ 和 $y$ 表示图上的两个点， $S$ 表示一条 $x$ 到 $y$ 的简单路径，而且必须满足：

1. $x$ 和 $y$ 分别在两个不同的简单环上

2. $x$ 所在的简单环与路径 $S$ 的所有交点仅有 $x，y$ 所在的简单环与路径 $S$ 的所有交点仅有 $y$ 。

$ (x,y,S) $与$ (y,x,S)$算同一个手铐

如果你无法理解，可以参考样例。

Input

第一行两个数 $n$ 和 $m$

之后 $m$ 行，每行两个数 $x,y$ 表示 $x$ 和 $y$ 之间有一条边。

$(n\le 10^6,m\le 2\cdot 10^6)$

Output

输出一个数，表示手铐的个数对 $19260817$ 取模的结果

Sample Input

11 12
1 2
2 3
3 4
4 5
5 1
4 6
6 7
7 8
8 9
9 10
10 11
11 7

Sample Output

Solution

$tarjan$ 求出边双连通分量之后该连通无向图即转化为一棵树，且任意两个点数超过 $1$ 的块构成一个“手铐”，但是注意到假设两个点数超过 $1$ 的块之间有 $x$ 个点数超过 $1$ 的块，那么两个块之间的路径有 $2^x$ 种选择

考虑 $u$ 的所有子树中点数超过 $1$ 的块走到 $u$ 的方案数 $dp[u]$ ，以此考虑 $u$ 的儿子，对于第一个儿子 $v$ ，若 $u$ 也是点大于 $1$ 的块，那么第一个儿子中点数大于 $1$ 的点到 $u$ 构成的手铐对答案的贡献就是 $dp[v]$ ，对于其他儿子，可以经过 $u$ 点与之前考虑的儿子中点数大于 $1$ 的点构成手铐，此时对答案的贡献就是 $dp[u]\cdot dp[v]$ ，而对于 $dp[u]$ 的维护，如果 $u$ 点数大于 $1$ ，那么 $dp[u]+=2\cdot dp[v]$ ，否则 $dp[u]+=dp[v]$ ，时间复杂度 $O(n+m)$

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
#define maxn 1000005
#define maxm 4000005
struct Edge
{
 	int to,next;
 	bool flag;//标记是否是桥
}edge[maxm];
int head[maxn],tot;
int low[maxn],dfn[maxn],stack[maxn],belong[maxn];//belong数组的值是1~block
int Index,top;
int block;//边双连通块数
bool instack[maxn];
int bridge;//桥的数目
int n,m;
void add_edge(int u,int v)
{
 	edge[tot].to=v,edge[tot].next=head[u],edge[tot].flag=0;
 	head[u]=tot++;
}
void Tarjan(int u,int pre)
{	
 	int v;
 	low[u]=dfn[u]=++Index;
 	stack[top++]=u;
 	instack[u]=1;
 	for(int i=head[u];~i;i=edge[i].next)
 	{
		v=edge[i].to;
		if(v==pre)continue;
		if(!dfn[v])
		{
			Tarjan(v,u);
			if(low[u]>low[v])low[u]=low[v];
			if(low[v]>dfn[u])
			{
				bridge++;
				edge[i].flag=1;
				edge[i^1].flag=1;
			}
		}
		else if(instack[v]&&low[u]>dfn[v])
			low[u]=dfn[v];
	}
	if(low[u]==dfn[u])
	{
		block++;
		do
		{
			v=stack[--top];
			instack[v]=0;
			belong[v]=block;
		}
		while(v!=u);
	 }
}
void init()
{
 	tot=0;
 	memset(head,-1,sizeof(head));
}
void solve()
{
 	memset(dfn,0,sizeof(dfn));
 	memset(instack,0,sizeof(instack));
 	Index=top=block=0;
 	Tarjan(1,0);
}
#define mod 19260817
int add(int x,int y)
{
	x+=y;
	if(x>=mod)x-=mod;
	return x;
}
int mul(int x,int y)
{
	ll z=1ll*x*y;
	return z-z/mod*mod;
}
vector<int>g[maxn];
int num[maxn],dp[maxn],ans;
void dfs(int u,int fa)
{
	int t=1;
	if(num[u]>1)dp[u]=1,t=2;
	int first=1;
	for(int i=0;i<g[u].size();i++)
	{
		int v=g[u][i];
		if(v==fa)continue;
		dfs(v,u);
		if(!first)ans=add(ans,mul(dp[u],dp[v]));
		else if(t==2)ans=add(ans,dp[v]);
		dp[u]=add(dp[u],mul(t,dp[v]));
		first=0;
	}
}
int main()
{
	init();
	scanf("%d%d",&n,&m);
	while(m--)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		add_edge(u,v),add_edge(v,u);
	}
	solve();
	for(int i=1;i<=n;i++)num[belong[i]]++;
	int cnt=0;
	for(int i=1;i<=block;i++)
		if(num[i]>1)cnt++;
	for(int u=1;u<=n;u++)
		for(int i=head[u];~i;i=edge[i].next)
		{
			int v=edge[i].to;
			if(belong[u]!=belong[v])g[belong[u]].push_back(belong[v]);
		}
	ans=0;
	for(int i=1;i<=block;i++)
		if(num[i]>1)
		{
			dfs(i,0);
			break;
		}
	printf("%d\n",ans);
	return 0;
}

Newcoder 26 C.手铐（边双连通分量+树形DP）

猜你喜欢