HDU1269（强连通分量）

原创于 2021-04-20 15:33:14 发布 · 229 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#dfs #算法 #图论

强连通分量专栏收录该内容

10 篇文章

订阅专栏

本文介绍了解决强连通图问题的两种算法：一种是通过深度优先搜索（DFS）来寻找强连通分量；另一种是Kosaraju算法，它先对原图进行拓扑排序再对反转图进行反向深度优先搜索。文章提供了详细的实现代码及解释。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：要求判断任意两个房间都是不是相互连接的。
求解思路：强连通分量求解：
强连通图：在有向图中，任意节点除法都可以到达其余所有节点，则称为强连通图。
强连通分量：在非强连通图的有向图中，选取部分点为强连通图，该强连通子图称为强连通分量

方法一：
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<vector>
#include<stack>
using namespace std;
const int maxx=10005;
const int inf=0x3f3f3f3f;
int low[maxx];
int dfn[maxx];
int vis[maxx];
int flag[maxx];
int blong[maxx];//记录这个节点属于哪个强连通分量 
int index;
int root;
int ans;//记录强连通分量的个数 
int n,m;
stack<int>s;
vector<int>G[maxx];
void dfs(int u){
	index++;
	low[u]=dfn[u]=index;
	s.push(u);
	vis[u]=1;
	for(int i=0;i<G[u].size();i++){
		int v=G[u][i];
		if(dfn[v]==0){
			dfs(v);
			low[u]=min(low[u],low[v]);
		}else if(vis[v]==1){
			low[u]=min(low[u],dfn[v]);
		}
	}
	if(dfn[u]==low[u]){//找到一个强连通分量 
		int v;
		ans++;
		do{
			v=s.top();
			s.pop();
			vis[v]=0;
			blong[v]=ans;//记录这个节点属于的强连通分量 
		}while(u!=v);
	}
}
void init(){
	ans=0;
	memset(flag,0,sizeof(flag));
	memset(vis,0,sizeof(vis));
	memset(low,0,sizeof(low));
	memset(dfn,0,sizeof(dfn));
	memset(blong,0,sizeof(blong));
	for(int i=0;i<=n;i++){
		G[i].clear();
	}
}
int main(){
	while(scanf("%d %d",&n,&m)!=EOF){
	    init();
	    index=1;root=1;
	    if(n==0&&m==0)break;
		for(int i=1;i<=m;i++){
			int a,b;
			scanf("%d %d",&a,&b);
			G[a].push_back(b);
		}
		for(int i=1;i<=n;i++){
			if(dfn[i]==0){
				dfs(i);
			}
		}
	    if(ans>1){
	    	cout<<"No"<<endl;
		}else{
			cout<<"Yes"<<endl;
		}
	}
	return 0;
}

Kosaraju算法：
算法思路：
步骤1：对正向图（原图）进行dfs求解得到正向图中各节点的拓扑序并且存在数组vs中。
步骤2：得到拓扑序之后，对反向图按照逆拓扑序进行rdfs，每次rdfs都得到一个强连通分量。
注意:在进行第一步的dfs之后，将数组vis清空。

注解：Map数组记录正向图，rMap数组记录反向图，flag数组标记属于哪个连通分量，vis数组标记访问情况，vs数组记录拓扑序。

方法二：Kosaraju算法
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
using namespace std;
const int maxx=10005;
const int inf=0x3f3f3f3f;
vector<int>Map[maxx],rMap[maxx],vs;
int vis[maxx];
int n,m;
int flag[maxx];
void init(){
	memset(vis,0,sizeof(vis));
	memset(flag,0,sizeof(flag));
	for(int i=0;i<=n;i++){
		rMap[i].clear();
		Map[i].clear();
	}
	vs.clear();
}
void dfs(int v){
	vis[v]=1;
	for(int i=0;i<Map[v].size();i++){
		int t=Map[v][i];
		if(vis[t]==0){
			dfs(t);
		}
	}
	vs.push_back(v);
}
void rdfs(int v,int k){
	vis[v]=1;
	flag[v]=k;//代表属于k这个连通分量 
	for(int i=0;i<rMap[v].size();i++){
		int t=rMap[v][i];
		if(vis[t]==0){
			rdfs(t,k);
		}
	}
}
int solve(){
	for(int i=1;i<=n;i++){
		if(vis[i]==0){
			dfs(i);
		}
	}
	memset(vis,0,sizeof(vis));
	int k=0;
	for(int i=vs.size()-1;i>=0;i--){
		if(vis[vs[i]]==0){
			rdfs(vs[i],k++);
		}
	}
	return k;
}
int main(){
	while(scanf("%d %d",&n,&m)!=EOF){
		if(n==0&&m==0)break;
		init();
		for(int i=1;i<=m;i++){
			int a,b;
			scanf("%d %d",&a,&b);
			Map[a].push_back(b);
			rMap[b].push_back(a);
		}
		int k=solve();
		if(k==1){
			cout<<"Yes"<<endl;
		}else{
			cout<<"No"<<endl;
		}
	}
	return 0;
}