圖的強聯通分量算法

最新推荐文章于 2022-06-19 19:44:04 发布
最新推荐文章于 2022-06-19 19:44:04 发布
阅读量2.5k 收藏
点赞数
分类专栏： 图论 算法學習
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sasuke__/article/details/55535570
版权

Tarjan:

             學習資料:傳送門

             通俗易懂版:傳送門

kosaraju:

              傳送門

 

 

POJ 2186

题意：A认为B厉害， B认为C厉害， 则A认为C厉害， 求有多少个牛被其他n-1个牛都认为厉害

首先给定的图没有保证一定连通、所以我们开始处理是不是有多个连通块、

如果只有一个连通块那么缩点后的图就是个DAG图， 如果其中出度为0的点有且只有一个那么答案就是那个点的个数

如果存在两个，很显然那两个点是不互达的

DAG图至少存在一个入度为0的点

Tarjan算法直接求 注意是多组数据

 

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
using namespace std;

#define LL long long
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define REP(i, x, n)	for(int i = x; i < n; ++i)
const int qq = 1e5;
const int INF = 1e9;
int fa[qq];
int dfn[qq];
int low[qq];
int Stack[qq];
int belong[qq];
int num[qq];
int deg[qq];
bool instack[qq];
int n, m, Bcnt, top, Index;
vector <int> vt[qq];
map<pill, bool> mp;
int Find(int x){
	return fa[x] == -1 ? x : fa[x] = Find(fa[x]);
}
void Tarjan(int u){
	low[u] = dfn[u] = ++Index;
	instack[u] = true;
	Stack[top++] = u;
	int sz = (int)vt[u].size();
	REP(i, 0, sz){
		int v = vt[u][i];
		if(!dfn[v]){
			Tarjan(v);
			low[u] = min(low[u], low[v]);
		}else if(instack[v]){
			low[u] = min(low[u], dfn[v]);
		}
	}
	int v;
	if(low[u] == dfn[u]){
		++Bcnt;
		do{
			v = Stack[--top];
			instack[v] = false;
			belong[v] = Bcnt;
			num[Bcnt]++;
		}while(v != u);
	}
}
int main(){
	
	while(scanf("%d%d", &n, &m) != EOF){
		memset(fa, -1, sizeof(fa));
		memset(num, 0, sizeof(num));
		memset(dfn, 0, sizeof(dfn));
		memset(deg, 0, sizeof(deg));
		memset(instack, false, sizeof(instack));
		mp.clear();
		for(int i = 0; i <= n; ++i)
			vt[i].clear();
		int a, b;
		REP(i, 0, m){
			scanf("%d%d", &a, &b);
			if(mp[mk(a, b)])	continue;
			mp[mk(a, b)] = true;
			vt[a].pb(b);
			int x = Find(a), y = Find(b);
			if(x == y)	continue;
			fa[y] = x;
		}
		int p = 0;
		for(int i = 1; i <= n; ++i)
			if(fa[i] == -1)	p++;
		if(p > 1){
			printf("0\n");
			return 0;
		}
		Bcnt = top = Index = 0;
		for(int i = 1; i <= n; ++i) {
            if (!dfn[i])    Tarjan(i)
        }
		for(int i = 1; i <= n; ++i){
			for(int j = 0; j < (int)vt[i].size(); ++j){
				if(belong[i] == belong[vt[i][j]])	continue;
				deg[belong[i]]++;
			}
		}
		int cnt = 0, id;
		for(int i = 1; i <= Bcnt; ++i){
			if(deg[i] == 0)	cnt++, id = i;
		}
		if(cnt == 1)	printf("%d\n", num[id]);
		else	printf("0\n");
	}
	return 0;
}

 

 

 

POJ1236

题意：有一个图， SubA是问至少传送软件给几个学校能使的所有学校能得到软件（得到软件的学校会把软件传给它所有能达到的学校）， SubB是问至少需要添加几条边能使得传送软件给任意一个学校， 其他所有学校都能得到软件。

首先SubA很容易能分析出来是求缩点后入度为0的点的个数， SubB呢？ 我一开始以为是算出度为0的个数，其实不然，

基于有向无环图（DAG）的考虑，我们知道一条有向边能贡献一个入度和一个出度（不同顶点）， 而我们知道强连通图的所有顶点的入度和出度都不为0， 所以我们可以这样考虑，一条边能贡献一个入度和一个出度，那么我们只要把所有入度和出度都填满了，整个图就是个强连通图，需要多少条边呢？ 就是入度为0的个数 ， 出度为0的个数中的最大值。

 

#include <cstdio>
#include <cmath>
#include <cstring>
#include <cctype>
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <utility>
#include <stack>
#include <queue>
#include <string>
#include <vector>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define REP(i, x, n)	for(int i = x; i < n; ++i)
const int qq = 100 + 10;
vector<int> v[qq], rv[qq];
int fa[qq], belong[qq], num[qq], deg[qq];
bool vis[qq];
int n, Bcnt;
stack<int> st;
int find(int x){
	return fa[x] == -1 ? x : fa[x] = find(fa[x]);
}
void dfs(int u){
	vis[u] = true;
	REP(i, 0, (int)v[u].size())if(!vis[v[u][i]]){
		dfs(v[u][i]);
	}
	st.push(u);
}
void rdfs(int u){
	vis[u] = true;
	belong[u] = Bcnt;
	num[Bcnt]++;
	REP(i, 0, (int)rv[u].size())if(!vis[rv[u][i]]){
		rdfs(rv[u][i]);
	}
}
int main(){
	while(scanf("%d", &n) != EOF){
		int x;
		memset(fa, -1, sizeof(fa));
		while(!st.empty())	st.pop();
		REP(i, 0, n + 1)	v[i].clear(), rv[i].clear();
		REP(i, 0, n){
			while(true){
				scanf("%d", &x);
				if(x == 0)	break;
				int a = find(x), b = find(i + 1);
				if(a != b)	fa[b] = a;
				v[i + 1].pb(x);
				rv[x].pb(i + 1);
			}
		}
		int cnt = 0;
		for(int i = 1; i <= n; ++i)
			if(fa[i] == -1)	cnt++;
		memset(vis, false, sizeof(vis));
		for(int i = 1; i <= n; ++i)if(!vis[i]){
			dfs(i);
		}
		memset(vis, false, sizeof(vis));
		memset(num, 0, sizeof(num));
		Bcnt = 0;
		for(int i = st.size() - 1; i >= 0; --i){
			int u = st.top();	st.pop();
			if(!vis[u])	++Bcnt, rdfs(u);
		}
		if(Bcnt == 1){
			printf("1\n0\n");
			return 0;
		}
		memset(deg, 0, sizeof(deg));
		int SubA = 0;
		for(int i = 1; i <= n; ++i)
			for(int j = 0; j < (int)v[i].size(); ++j){
				if(belong[i] == belong[v[i][j]])	continue;
				deg[belong[v[i][j]]]++;
			}
		for(int i = 1; i <= Bcnt; ++i)
			if(deg[i] == 0)	SubA++;
		int SubB = 0;
		memset(deg, 0, sizeof(deg));
		for(int i = 1; i <= n; ++i)
			for(int j = 0; j < (int)v[i].size(); ++j){
				if(belong[i] == belong[v[i][j]])	continue;
				deg[belong[i]]++;
			}
		for(int i = 1; i <= Bcnt; ++i)
			if(deg[i] == 0)	SubB++;
		printf("%d\n%d\n", SubA, max(SubA, SubB));
	}
	return 0;
}


 

POJ2553

题意：给出n，m代表点的个数和边的条数， 然后a b代表a到b有一条有向边， 要统计sink点的个数。

何为sink点呢， 就是如果有一条u->到v的路径一定存在一条v-›u的路径 这样u就是sink点。

如果是一个连通图，我们知道缩点后的图是个DAG图（有向无环图）那么对于有出度的点，那么这个点一定不是sink点，DAG图是无环的。

所以答案就是统计缩点后的图中出度为0的点、是不是连通图都没关系

 

#include <cstdio>
#include <cmath>
#include <cstring>
#include <cctype>
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <utility>
#include <stack>
#include <queue>
#include <string>
#include <vector>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define REP(i, x, n)	for(int i = x; i < n; ++i)
const int qq = 5005;
vector<int> vt[qq], rvt[qq], Ver[qq], order;
int belong[qq], deg[qq];
bool vis[qq];
int Scc, n, m;
stack<int> st;
void Init(){
	Scc = 0;
	memset(vis, false, sizeof(vis));
	memset(deg, 0, sizeof(deg));
	for(int i = 0; i <= n; ++i)
		vt[i].clear(), rvt[i].clear(), Ver[i].clear();
	order.clear();
}
void Dfs(int u){
	vis[u] = true;
	REP(i, 0, (int)vt[u].size())if(!vis[vt[u][i]]){
		Dfs(vt[u][i]);
	}
	st.push(u);
}
void Rdfs(int u){
	vis[u] = true;
	belong[u] = Scc;
	Ver[Scc].pb(u);
	REP(i, 0, (int)rvt[u].size())if(!vis[rvt[u][i]]){
		Rdfs(rvt[u][i]);
	}
}
int main(){
	while(scanf("%d", &n) != EOF){
		if(n == 0)	break;
		Init();
		scanf("%d", &m);
		int a, b;
		REP(i, 0, m){
			scanf("%d%d", &a, &b);
			vt[a].pb(b);
			rvt[b].pb(a);
		}
		for(int i = 1; i <= n; ++i)
			if(!vis[i])	Dfs(i);
		memset(vis, false, sizeof(vis));
		for(int i = st.size() - 1; i >= 0; --i){
			int u = st.top();	st.pop();
			if(!vis[u])	++Scc, Rdfs(u);
		}
		for(int i = 1; i <= n; ++i)
			for(int j = 0; j < (int)vt[i].size(); ++j){
				int u = vt[i][j];
				if(belong[i] == belong[u])	continue;
				deg[belong[i]]++;
			}
		for(int i = 1; i <= Scc; ++i){
			if(deg[i] == 0){
				for(int j = 0; j < (int)Ver[i].size(); ++j)
					order.pb(Ver[i][j]);
			}
		}
		sort(order.begin(), order.end());
		for(int i = 0; i < (int)order.size() - 1; ++i)
			printf("%d ", order[i]);
		printf("%d\n", order[(int)order.size() - 1]);
	}
	return 0;
}

 

 

 

 

 

 

POJ3177

题意：给定一个无向图， 问你再加多少条边能使的任意对顶点之间有两条不同的路径可以到达，Routes are considered separate if they use none of the same paths, even if they visit the same intermediate field along the way. 

这是题目关于不同路径的原话。 个人觉得实际上是针对这样的数据

2 2

1 2

2 1

这数据的答案是0及我们要考虑重边的情况

对于无向图， 我们可以求出边双连通分量然后缩点， 然后根据叶子节点的数目即可求出答案

对于处理重边我们可以用一个标志变量来完成

 

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cctype>
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <utility>

using namespace std;
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define LL long long
#define REP(i, x, n)	for(int i = x; i < n; ++i)
const int qq = 1e5 + 10;
int n, m;
int low[qq], dfn[qq], belong[qq], deg[qq], pre[qq], Stack[qq];
int Index, Bcnt, top;
vector<int> vt[qq];
map<pill, bool> mp;
void Tarjan(int u, int fa){
	low[u] = dfn[u] = ++Index;
	Stack[top++] = u;
	pre[u] = fa;
	int sz = (int)vt[u].size();
	int k = 0;
	REP(i, 0, sz){
		int v = vt[u][i];
		if(v == fa && !k){
			++k;
			continue;
		}
		if(!dfn[v]){
			Tarjan(v, u);
			low[u] = min(low[u], low[v]);
		}else{
			low[u] = min(low[u], dfn[v]);
		}
	}
	int v;
	if(dfn[u] == low[u]){
		++Bcnt;
		do{
			v = Stack[--top];
			belong[v] = Bcnt;
			instack[v] = false;
		}while(v != u);
	}
}
int main(){
	scanf("%d%d", &n, &m);
	int a, b;
	REP(i, 0, m){
		scanf("%d%d", &a, &b);
		if(a > b)	swap(a, b);
		if(mp[mk(a, b)])	continue;
		mp[mk(a, b)] = true;
		vt[a].pb(b), vt[b].pb(a);
	}
	Index = Bcnt = top = 0;
	Tarjan(1, -1);
	for(int i = 1; i <= n; ++i){
		int u = pre[i];
		if(belong[i] != belong[u]){
			deg[belong[i]]++, deg[belong[u]]++;
		}
	}
	int cnt = 0;
	for(int i = 1; i <= Bcnt; ++i){
		if(deg[i] == 1)	cnt++;
	}
	printf("%d\n", (cnt + 1) / 2);
	return 0;
}

 

 

 

 

 

这题我之前的做法是直接去重边可以过、

但仔细想想确实会有如上的情况出现、

Yokile_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】连通图、连通分量与强连通图、强连通分量—区别在于强，强强在哪里？
四季轮换叶，一路招摇胜
06-14 2万+
如果 G 是有向图，那么连接 i 和 j 的路径中所有的边都必须同向。如果图中任意两点都是连通的，那么图被称作连通图。如果此图是有向图，则称为强连通图（注意：需要双向都有路径）。今天叶子为大家分享的是【连通图、连通分量与强连通图、强连通分量】...
图的连通分量
最新发布
nameofcsdn的博客
08-29 1万+
。。
【图论】—— 有向图的强连通分量
forever_bryant的博客
06-19 2854
【图论】—— 有向图的强连通分量
强连通分量(Tarjan算法) 图解
qq_25930891的博客
03-01 6393
最详细的tarjan图解！
强连通分量算法学习笔记
531 の 流 水 线
02-12 595
强连通分量 更好阅读体验请点击此链接 先推荐几道综合性较强的题目，详细题解我写了，持续更新中。 我的博客：整理 + 题解 P2341 [USACO03FALL][HAOI2006]受欢迎的牛 G P2272 [ZJOI2007]最大半连通子图 强连通分量（ strongly connected components ），可以理解为存在一条回路使得初始点又能回到初始点。 有两种算法， 这里分享的是 Tarjan （我用前向星存图）。 1. 基本概念： Tarjan 基于对图深搜的算法，每个强连通分量为搜
Tarjan 的强连通分量算法的Python实现
06-08
）图作为输入，并以拓扑顺序返回其强连通分量作为输出 循环依赖 在各种情况下，依赖关系可能是循环的，并且必须同时执行一组相互依赖的操作。同时执行成本高昂的情况并不少见。使用 Tarjan 算法，可以确定执行相互...
【老生谈算法】matlab实现求图的连通分量算法.doc
07-03
"matlab实现求图的连通分量算法" 该算法实现了使用MATLAB语言对图的连通分量的求解。连通分量是指图中的一组节点和边，它们之间存在连接关系，而与其他节点和边之间不存在连接关系。在本算法中，我们首先生成一个...
求有向图的强连通分量(scc)Tarjan算法.docx
05-06
"有向图的强连通分量（scc）Tarjan算法" Tarjan算法是基于深度优先搜索的算法，...Tarjan算法是解决有向图强连通分量问题的有效算法，具有快速、准确的特点，广泛应用于网络拓扑结构、社交网络分析、数据挖掘等领域。
强连通分量的Kosaraju算法实现
04-14
2. 用Kosaraju算法实现了强连通分量的求解。其中data中包含的GoolNodes测试集为Google提供的网页之间的连接经转化而来，每一个结点均代表一个网页。 3. 缺点：为了使用以前的CGraph类，强行添加了结点文件，其中第一...
有向图的强连通分量课程设计报告.docx
07-05
本课程设计报告主要针对有向图的强连通分量进行深入研究，通过算法分析和系统设计，实现求解有向图强连通分量的程序。 1. 算法分析 1.1 条件分析 在有向图中，强连通分量是指图中任意两个顶点都可以相互到达的...
强连通分量
weixin_30578677的博客
02-11 376
https://www.cnblogs.com/31415926535x/p/10363253.html 概述 图的连通性是图论中的一个基础知识点，算法很简单，但是所所涉及的基础知识点也很多，后悔当初离散数学没有好好的学，QAQ，，， 这篇主要是记录一下两种方法求强连通分量的算法，Tarjan和Kosaraju的模板， 算法 （具体的算法的证明和相关的内容来自这篇博客以及红书上的内容） 强连通分量...
强连通分量的个数（Kosaraju）
FKJDASOI的博客
01-14 2998
【题目描述】 求一个有向图中强连通分量的个数。 【解题思路】 先解释一下强连通分量的定义： 一个有向图中，如果每两个点都相互连接（可以不直达），那么这个图就是一个强连通，我们可以把一个有向图分解成若干个强连通分量。 那么我们应该怎么做呢？ 首先，从任意一个点开始遍历，记录每个点出栈的顺序。 原理，但我们对一个图进行dfs遍历的时候，我们从最深层开始出栈，如果我们把一个点的出度看作是通往下一层的话，那么我们最先出栈的肯定就是没有出度的了，当一个点的所有出度的点全部出栈了，那么我们也可以看作这个点的出度
【算法】图 (5) 强连通图
ysugarr
05-18 6519
如何判断一个图是强连通图？ 强连通图（strongly connected）：在一个图中，任意两点x,y，都可以互相到达（可以借助其他点作为中转）； 1 简单方法 对每个结点进行DFS或者BFS搜索，如果每次搜索的结果，使得每个点的state都标记为“Processed”，则表示该图为强连通图，时间复杂度为，其中是DFS的时间复杂度； 2 通过hub来判断强连通图 先验知识： 2.1 图的转置 图中所有的点不变，但是所有的边的方向都反向 输入样例： graph_string = ""
（转）求有向图的强连通分量个数（kosaraju算法）
weixin_30391339的博客
04-09 1808
有向图的连通分量的求解思路 kosaraju算法 逛了很多博客，感觉都很难懂，终于找到一篇能看懂的，摘要记录一下 原博客https://www.cnblogs.com/nullzx/p/6437926.html 关于连通分量是什么自行百度，这里主要说明连通分量的求解方法 基本思路：第一次DFS得出顶点的顺序，根据顶点顺序进行第二次DFS，也就是逆后序遍历（手动...
迷宫城堡 Tarjan求出强联通分量的个数
风华绝代
02-10 1054
迷宫城堡 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 5897    Accepted Submission(s): 2592 Problem Description 为了训练小希的方向感，Gardon建立了一座大城堡
数据结构之图-连通分量
机器不学习
04-23 7701
连通分量的定义： 在无向图中，如果从顶点vi到顶点vj有路径，则称vi和vj连通。如果图中任意两个顶点之间都连通，则称该图为连通图，否则，称该图为非连通图，则其中的极大连通子图称为连通分量，这里所谓的极大是指子图中包含的顶点个数极大。在有向图中，如果对于每一对顶点vi和vj，从vi到vj和从vj到vi都有路径，则称该图为强连通图；否则，将其中的极大强连通子图称为强连通分量。 在有向图G
找出一个图中所有的强连通子图
zzran的专栏
05-17 8490
如果一个有向图中的没对顶点都可以从通过路径可达，那么就称这个图是强连通的。一个 strongly connected component就是一个有向图中最大的强连通子图。下图中就有三个强连通子图： 应用kosaraju算法，可以在O（v+e）的时间内找到强连通子图。下面是kosaraju算法的具体步骤： 1，创建一个stack，对图进行深度优先遍历。对于每一个节点，当应用DFS遍历其所
（2）source和sink详解
热门推荐
qq_18522601的博客
07-19 3万+
前面第一小节也提到了，Structured Streaming会增量的从source中读取数据，映射成一张表，对该表进行增量的查询分析，然后组合中间状态，再把结果输出到结果表，然后刷到外部存储系统sink。 本小节主要是详细讲解source 和sink。 1. source 目前支持的内置source有： 1） File Source 从给定的目录读取数据，目前支持的格式有text...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值