【BZOJ5033】【JSOI2014】强连通图

最新推荐文章于 2021-08-05 20:04:34 发布
最新推荐文章于 2021-08-05 20:04:34 发布
阅读量441 收藏
点赞数
分类专栏： 【OJ】BZOJ 【类型】做题记录 【算法】Tarjan算法 【算法】构造与证明
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39972971/article/details/80077553
版权

【题目链接】

【思路要点】

  • 第一问本质上是问图中最大的强连通分量的大小，Tarjan算法即可。
  • 对于第二问，我们先将图缩点，显然答案有下界\(max\{cntin,cntout\}\)，其中\(cntin\)为入度为0的点的个数，\(cntout\)为出度为0的点的个数。
  • 题目中的两个样例均满足答案恰好为下界，因此我们猜测答案始终为下界，并试图构造一组解。
  • 我们将所有入度为0的点排在一边，出度为0的点排在另一边（如果一个点入度、出度均为0，我们将其同时排在两边），若一个入度为0的点\(A\)可以到达一个出度为零的点\(B\)，连边\(A\Rightarrow B\)，这将构成一张二分图。
  • 显然如果我们连接若干条边使得该二分图强联通，那么一定对应了一种使原图联通的方案。
  • 由于保证了答案在1000以内，根据答案的下界，这张二分图两边的点数一定在1000以内。
  • 这张二分图满足性质：每个点的度数均非0。
  • 我们找到这张二分图的一个极大的匹配（不一定要最大，只需要极大即可），将匹配上的\(x\)个点对按顺序连接，形成一个环，这将需要增加\(x\)条边。
  • 考虑剩余的没有被连接入环的点，由于这是这张二分图的一个极大的匹配，并且这张二分图上每个点的度数均非0，每个不在环上的入度为0的点一定能够到达环上，每一个不在环上的出度为0的点一定能够从环上到达，否则我们显然能够加一条边，构造出更大的匹配。
  • 因此，我们每次找到一对不在环上的入/出度为0的点\(x\)、\(y\)，连边\(y\Rightarrow x\)，即可使得\(x\)、\(y\)与环强联通。还可能会剩下一些不在环上的入/出度为0的点中的一种，将每个点用一条边与环相接即可。
  • 至此，我们共用了\(max\{cntin,cntout\}\)条边。
  • BZOJ没有SPJ，无法正确评测本题，以下代码由笔者本人测试通过。
  • 时间复杂度\(O(\frac{NM}{w}+Ans^2)\)（其中\(w=64\)）。
  • 另附上本题的SPJ，运行前请保证同一目录下存在“scg.in”、“scg.out”、“scg.ans”三个文件。

【附本题的SPJ】

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<string>
#include<algorithm>
#include<fstream>
#include<sstream>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<deque>
#include<cassert>
#include<complex>
using namespace std;

const int MaxN = 10000 + 10;

const char* inFile = "scg.in";
const char* outFile = "scg.out";
const char* ansFile = "scg.ans";
const char* logFile = "check.txt";

int grade(int s = 0, string msg = string("Wrong Answer!")) {
	FILE * file = fopen(logFile, "w");
	if(s == 0) {
		fprintf(file, "%s\n0\n", msg.c_str());
		return 0;
	}
	fprintf(file, "FC:\n%d\n%s\n",s,msg.c_str());
	return 0;
}

vector<int> adj[MaxN], rev[MaxN];
int N, M;
bool vis[MaxN];
int Q[MaxN], n;
void dfs1(int u) {
	vis[u] = true;
	for(int i=0;i<adj[u].size();++i)
		if(!vis[adj[u][i]])
			dfs1(adj[u][i]);
	Q[n ++] = u;
}
void dfs2(int u) {
	vis[u] = true;
	for(int i=0;i<rev[u].size();++i)
		if(!vis[rev[u][i]])
			dfs2(rev[u][i]);
}
bool check() {
	fill(vis, vis + 1 + N, 0);
	for(int i=1;i<=N;++i)
		if(!vis[i])
			dfs1(i);
	fill(vis, vis + 1 + N, 0);
	dfs2(Q[n - 1]);
	for(int i=1;i<=N;++i)
		if(!vis[i]) return false;
	return true;
}

int A, C, user_A, user_C;

int loadInput(FILE* inf) {
	if(fscanf(inf, "%d %d", &N, &M) != 2 || N < 3 || N > 10000 || M < 0 || M > 200000)
		return 0;
	for(int i=0;i<M;++i) {
		int x, y;
		if(fscanf(inf, "%d %d", &x, &y) != 2 || min(x,y) < 1 || max(x,y)>N) {
			
			cerr << "error on line #"<<i+2<<" < "<<x<<" , "<<y<<">"<<endl;
			
			return 0;
		}
		adj[x].push_back(y);
		rev[y].push_back(x);
	}
	return 1;
}

int loadAnswer(FILE *inf) {
	if(fscanf(inf, "%d", &C) != 1 || C < 1 || C > N) return 0;
	if(fscanf(inf, "%d", &A) != 1 || A < 0 || A > N || A > 1000) return 0;
	return 1;
}


const int FullScore = 10;
const int LoScore = 2;
const int MidScore = 4;


void loadOutput(FILE* inf) {
	if(fscanf(inf, "%d", &user_C) != 1) {
		fclose(inf);
		exit(grade(0, "Format Error!"));
	}
	if(user_C != C) {
		fclose(inf);
		exit(grade(0, "Wrong Answer!"));
	}

	if(fscanf(inf, "%d", &user_A) != 1) {
		fclose(inf);
		exit(grade(LoScore, "<C> Correct but <A> not found! "));
	}
	if(user_A != A) {
		fclose(inf);
		exit(grade(LoScore, "<C> Correct but <A> Wrong!"));
	}
	
	int x, y;
	for(int i=0;i<A;++i) {
		if(fscanf(inf, "%d %d", &x, &y) != 2 || min(x, y) < 1 || max(x, y) > N) {
			fclose(inf);
			exit(grade(MidScore, "<C> and <A> Correct! Solution Format Error!"));
		}
		adj[x].push_back(y);
		rev[y].push_back(x);
	}
	fclose(inf);
	
	if(check()) 
		grade(10, "Correct!");
	else
		grade(MidScore, "<C> and <A> Correct but Wrong Solution!");
	
	exit(0);
}

int main() {
	grade(0, "Internal Error!");

	FILE *file = fopen(inFile, "r");
	if(file == NULL) exit(grade(0, "No Input File!"));
	if(!loadInput(file)) {
		fclose(file);
		exit(grade(0, "Input File Format Error!"));
	}
	fclose(file);
	
	file = fopen(ansFile, "r");
	if(file == NULL) exit(grade(0, "No Answer File!"));
	if(!loadAnswer(file)){
		fclose(file);
		exit(grade(0, "Answer File Format Error!"));
	}
	fclose(file);
	
	file = fopen(outFile, "r");
	if(file == NULL) exit(grade(0, "No Output File!"));
	loadOutput(file);
}

【本题的Lemon版SPJ】

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<string>
#include<algorithm>
#include<fstream>
#include<sstream>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<deque>
#include<cassert>
#include<complex>
using namespace std;

const int MaxN = 10000 + 10;

char* inFile;
char* outFile;
char* ansFile;
char* logFile;
char* scoreFile;

int grade(int s = 0, string msg = string("Wrong Answer!")) {
	FILE * file = fopen(logFile, "w");
	FILE * score = fopen(scoreFile, "w");
	fprintf(score, "%d\n", s);
	if(s == 0) {
		fprintf(file, "%s\n0\n", msg.c_str());
		return 0;
	}
	fprintf(file, "FC:\n%d\n%s\n",s,msg.c_str());
	return 0;
}

vector<int> adj[MaxN], rev[MaxN];
int N, M;
bool vis[MaxN];
int Q[MaxN], n;
void dfs1(int u) {
	vis[u] = true;
	for(int i=0;i<adj[u].size();++i)
		if(!vis[adj[u][i]])
			dfs1(adj[u][i]);
	Q[n ++] = u;
}
void dfs2(int u) {
	vis[u] = true;
	for(int i=0;i<rev[u].size();++i)
		if(!vis[rev[u][i]])
			dfs2(rev[u][i]);
}
bool check() {
	fill(vis, vis + 1 + N, 0);
	for(int i=1;i<=N;++i)
		if(!vis[i])
			dfs1(i);
	fill(vis, vis + 1 + N, 0);
	dfs2(Q[n - 1]);
	for(int i=1;i<=N;++i)
		if(!vis[i]) return false;
	return true;
}

int A, C, user_A, user_C;

int loadInput(FILE* inf) {
	if(fscanf(inf, "%d %d", &N, &M) != 2 || N < 3 || N > 10000 || M < 0 || M > 200000)
		return 0;
	for(int i=0;i<M;++i) {
		int x, y;
		if(fscanf(inf, "%d %d", &x, &y) != 2 || min(x,y) < 1 || max(x,y)>N) {
			
			cerr << "error on line #"<<i+2<<" < "<<x<<" , "<<y<<">"<<endl;
			
			return 0;
		}
		adj[x].push_back(y);
		rev[y].push_back(x);
	}
	return 1;
}

int loadAnswer(FILE *inf) {
	if(fscanf(inf, "%d", &C) != 1 || C < 1 || C > N) return 0;
	if(fscanf(inf, "%d", &A) != 1 || A < 0 || A > N || A > 1000) return 0;
	return 1;
}


const int FullScore = 10;
const int LoScore = 2;
const int MidScore = 4;


void loadOutput(FILE* inf) {
	if(fscanf(inf, "%d", &user_C) != 1) {
		fclose(inf);
		exit(grade(0, "Format Error!"));
	}
	if(user_C != C) {
		fclose(inf);
		exit(grade(0, "Wrong Answer!"));
	}

	if(fscanf(inf, "%d", &user_A) != 1) {
		fclose(inf);
		exit(grade(LoScore, "<C> Correct but <A> not found! "));
	}
	if(user_A != A) {
		fclose(inf);
		exit(grade(LoScore, "<C> Correct but <A> Wrong!"));
	}
	
	int x, y;
	for(int i=0;i<A;++i) {
		if(fscanf(inf, "%d %d", &x, &y) != 2 || min(x, y) < 1 || max(x, y) > N) {
			fclose(inf);
			exit(grade(MidScore, "<C> and <A> Correct! Solution Format Error!"));
		}
		adj[x].push_back(y);
		rev[y].push_back(x);
	}
	fclose(inf);
	
	if(check()) 
		grade(10, "Correct!");
	else
		grade(MidScore, "<C> and <A> Correct but Wrong Solution!");
	
	exit(0);
}

int main(int argc,char *argv[]) {
	inFile = argv[1];
	outFile = argv[2];
	ansFile = argv[3];
	scoreFile = argv[5];
	logFile = argv[6];
	grade(0, "Internal Error!");

	FILE *file = fopen(inFile, "r");
	if(file == NULL) exit(grade(0, "No Input File!"));
	if(!loadInput(file)) {
		fclose(file);
		exit(grade(0, "Input File Format Error!"));
	}
	fclose(file);
	
	file = fopen(ansFile, "r");
	if(file == NULL) exit(grade(0, "No Answer File!"));
	if(!loadAnswer(file)){
		fclose(file);
		exit(grade(0, "Answer File Format Error!"));
	}
	fclose(file);
	
	file = fopen(outFile, "r");
	if(file == NULL) exit(grade(0, "No Output File!"));
	loadOutput(file);
}

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 10005;
const int MAXM = 200005;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
bitset <MAXN> arr[MAXN];
vector <int> a[MAXN], sub[MAXN];
int n, m, top, Max, Stack[MAXN];
int timer, low[MAXN], dfn[MAXN];
int tot, belong[MAXN];
int x[MAXM], y[MAXM];
bool instack[MAXN];
vector <int> inpos, outpos;
bool inused[MAXN], outused[MAXN];
bool inp[MAXN], outp[MAXN];
void getarr(int pos) {
	arr[pos].set(pos);
	for (unsigned i = 0; i < sub[pos].size(); i++) {
		int point = sub[pos][i];
		for (unsigned j = 0; j < a[point].size(); j++) {
			int tmp = belong[a[point][j]];
			if (arr[tmp][tmp] == true) arr[pos] |= arr[tmp];
			else {
				getarr(tmp);
				arr[pos] |= arr[tmp];
			}
		}
	}
}
void work(int pos) {
	dfn[pos] = low[pos] = ++timer;
	instack[pos] = true;
	Stack[++top] = pos;
	for (unsigned i = 0; i < a[pos].size(); i++)
		if (dfn[a[pos][i]] == 0) {
			work(a[pos][i]);
			chkmin(low[pos], low[a[pos][i]]);
		} else if (instack[a[pos][i]]) chkmin(low[pos], dfn[a[pos][i]]);
	if (low[pos] == dfn[pos]) {
		tot++;
		int cnt = 0, tmp = 0;
		while (tmp != pos) {
			cnt++;
			tmp = Stack[top--];
			belong[tmp] = tot;
			sub[tot].push_back(tmp);
			instack[tmp] = false;
		}
		chkmax(Max, cnt);
	}
}
int main() {
	read(n), read(m);
	for (int i = 1; i <= m; i++) {
		read(x[i]), read(y[i]);
		a[x[i]].push_back(y[i]);
	}
	for (int i = 1; i <= n; i++)
		if (dfn[i] == 0) work(i);
	writeln(Max);
	for (int i = 1; i <= m; i++)
		if (belong[x[i]] != belong[y[i]]) {
			outp[belong[x[i]]] = true;
			inp[belong[y[i]]] = true;
		}
	int cntin = 0, cntout = 0;
	for (int i = 1; i <= tot; i++) {
		if (outp[i] == false) {
			cntout++;
			outpos.push_back(i);
		}
		if (inp[i] == false) {
			cntin++;
			inpos.push_back(i);
		}
		arr[i].reset();
	}
	writeln(max(cntin, cntout));
	if (max(cntin, cntout) == 0) return 0;
	for (int i = 1; i <= tot; i++)
		if (arr[i][i] == false) getarr(i);
	int last = -1;
	for (unsigned i = 0; i < inpos.size(); i++)
	for (unsigned j = 0; j < outpos.size(); j++) {
		if (!inused[i] && !outused[j] && arr[inpos[i]][outpos[j]]) {
			inused[i] = outused[j] = true;
			if (last != -1) printf("%d %d\n", sub[outpos[last]][0], sub[inpos[i]][0]);
			last = j;
		}
	}
	printf("%d %d\n", sub[outpos[last]][0], sub[inpos[0]][0]);
	for (unsigned i = 0; i < inpos.size(); i++)
	for (unsigned j = 0; j < outpos.size(); j++) {
		if (!inused[i] && !outused[j]) {
			inused[i] = outused[j] = true;
			printf("%d %d\n", sub[outpos[j]][0], sub[inpos[i]][0]);
		}
	}
	int PointOnCircle = sub[inpos[0]][0];
	for (unsigned i = 0; i < inpos.size(); i++)
		if (!inused[i]) printf("%d %d\n", PointOnCircle, sub[inpos[i]][0]);
	for (unsigned i = 0; i < outpos.size(); i++)
		if (!outused[i]) printf("%d %d\n", sub[outpos[i]][0], PointOnCircle);
	return 0;
}

cz_xuyixuan
关注
专栏目录
连通图（强连通图）详解
数据结构和算法教程（C语言版）
11-08 1332
可以这样说，连通图是在无向图的基础上对图中顶点之间的连通做了更高的要求，而强连通图是在有向图的基础上对图中顶点的连通做了更高的要求。当前阅读的是整套数据结构和算法教程中的一节内容，想系统学习数据结构和算法的读者，可以前往教程目录页面系统的学习，也可以猛击这里去我的个人门户网站学习，想购买教程的读者加我 q（834937624）领取教程的 PDF 电子版。
【bzoj 2208】 连通数 【Jsoi2010】
TLECODE的博客
08-20 289
Description Input 输入数据第一行是图顶点的数量，一个正整数N。 接下来N行，每行N个字符。第i行第j列的1表示顶点i到j有边，0则表示无边。 Output 输出一行一个整数，表示该图的连通数。 Sample Input 3 010 001 100 Sample Output 9 HINT   对于100%的数据，N不超过2000。 这道题貌似标解和暴力...
洛谷P7251 [JSOI2014] 强连通图 (tarjan)
Jay_fearless的博客
03-10 239
原题地址 题目描述 JYY 最近痴迷于图的强连通性，所以对于任何有向图，JYY 都希望增加一些边使得这个图变成强连通图。JYY现在得到了一个 n 个点 m 条边的有向图，所有点从 1 到 n 编号。 JYY 想知道： 在给定的图中，最多能选出多少个点，使得这些点在原图中两两可达？ 在给定的图中，最少增加多少条边，可以使得这个图变成强连通图？ 其中，一个有向图$ G(V,E)是强连通的，当且仅当任意顶点a,b是强连通的，当且仅当任意顶点 a,b是强连通的，当且仅当任意顶点a,b\in$ V,a≠\neq​=
图之强连通、强连通图、强连通分量 Tarjan算法
热门推荐
心之所向
08-20 3万+
一、解释在有向图G中，如果两个顶点间至少存在一条互相可达路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。 求解有向图的强连通分量算法有很多，例如Kosaraju，Gabow和Tarjan算法，其中Gabow和Tarja
强连通图
GROWING
06-18 1380
点击打开链接
强连通图＜一＞
weixin_45323349的博客
08-05 409
//大致思路：利用vector存图，同时把反图存好，接着利用深搜把后序的序列得到 //接着是按照后序的顺序深搜反图，并且在该点被走过的前提下将土中可以一次性可以走的点放入数组 //存放 也就是用数组f[x] = y x是每次遍历到的点，具体的值是第一个点的值，这样该图的所有强连通图都得到了 题目连接 # include <iostream> # include <queue> # include <string.h> # include <vector> #
[BZOJ2208][Jsoi2010]连通数（dfs||tarjan+拓扑序+dp）
zyf2000
11-01 924
题目描述传送门题解看范围很小，O(n2)O(n^2)暴力就可以做啊= =BZOJ上跑到10s+的比比皆是，事实证明很多人都这样水掉了，而且这样的暴力是卡不掉的。 其实还有一种更高级的做法，就是tarjan+拓扑序+dp。首先将整个图缩点，同一个强连通分量中的点两两互达，所以答案统计为size2isize_i^2。对于不在一个强连通分量里的点，反向连边然后按照拓扑序dp，状态表示为f(i,j)当前到
BZOJ2208 [Jsoi2010]连通数 【图的遍历】
Mychael的无声乐章
12-26 310
题目输入格式输入数据第一行是图顶点的数量，一个正整数N。 接下来N行，每行N个字符。第i行第j列的1表示顶点i到j有边，0则表示无边。输出格式输出一行一个整数，表示该图的连通数。输入样例3 010 001 100 输出样例9提示对于100%的数据，N不超过2000。题解今晚水的题有点多。。。【明天要会考涨涨信心】 N才2000，可以O(n2)O(n^2) 那从每个点出发跑一遍bfs看看能到哪些点
bzoj4479: [Jsoi2013]吃货jyy 欧拉回路+状态压缩Dp
maxtir的博客
06-05 553
bzoj4479: [Jsoi2013]吃货jyy Description 【故事背景】 作为JSOI的著名吃货，JYY的理想之一就是吃遍全世界的美食。要走遍全 世界当然需要不断的坐飞机了。而不同的航班上所提供的餐食是很不一样的：比 如中国的航班会提供中餐，英国的航班有奶茶和蛋糕，澳大利亚的航班有海鲜， 新加坡的航班会有冰激凌……JYY选出了一些他特别希望品尝餐食的航班，希望 制定一...
【AHOI2013】【BZOJ3237】连通图
CreationAugust is 14 years old forever
03-14 1593
Description Input Output Sample Input4 51 22 33 44 12 431 52 2 32 1 2Sample OutputConnectedDisconnectedConnected HINTN<=100000 M<=200000 K<=100000一开始以为是LCT,后来发现其实cdq+并查集就可做 其实LCT也可以. 考虑一个询问
构造强连通图
abcdefghijk0987的博客
03-28 401
　　 　　我们知道，要把一个非边双连通图构造成一个边双连通图，只需把这个图化简（边双连通分量缩点）成一个树，然后 找出叶子节点个数leaf，(leaf+1)/2就是要新添加的边数。 　　现在，对与有向图来说，我们需要求加最少的边，使得一个非强连通图变成一个强连通图，最少的边数是多少？ 　　同样的，我们需要把他化简（强连通分量缩点）成一个DAG图（有向无环图），然后找出入度为0...
[C++图论] 强连通
fsy的博客
06-05 3741
文章目录概念 概念 在一个有向图中，如果说有两个点互相可达，那么这两个点就可说是 强连通。当然，官方语言（度娘解释）是这样的： 强连通（Strongly Connected）是指一个有向图（Directed Graph）中任意两点v1、v2间存在v1到v2的路径（path）及v2到v1的路径。 那么有了 强连通 这个概念，既然就会有 强连通图 了。当然，这个其实也可以举一反三： 就是在一个有...
强连通图的介绍
小嘟的博客
01-06 5716
注：强连通图说的是有向图，连通图说的是无向图，路径的意思是能到就行，其中间可以有中转站，也就是允许经过其他结点 问题一：强连通图任意两个顶点存在一条有向路径还是a到b到a都得互相有路径？ 解：互相有路径，也就是顺着箭头的方向走， 既可以从a走到b，也可以从b走到a 问题二：啥是极大强连通子图？ 解：1.为什么叫做极大？ 极大是因为如果此时加入任何一个...
​数据结构-图之强连通
weixin_34209406的博客
06-26 1267
2019独角兽企业重金招聘Python工程师标准>>> ...
【算法】图 (5) 强连通图
ysugarr
05-18 6697
如何判断一个图是强连通图？ 强连通图（strongly connected）：在一个图中，任意两点x,y，都可以互相到达（可以借助其他点作为中转）； 1 简单方法 对每个结点进行DFS或者BFS搜索，如果每次搜索的结果，使得每个点的state都标记为“Processed”，则表示该图为强连通图，时间复杂度为，其中是DFS的时间复杂度； 2 通过hub来判断强连通图 先验知识： 2.1 图的转置 图中所有的点不变，但是所有的边的方向都反向 输入样例： graph_string = ""
BZOJ1016 [JSOI2008]最小生成树计数
守望、御神木
10-17 6352
题意：给定一张n 思路：首先我们将不同的权值从小到大分开考虑。 我们证明以下定理：一个无向图所有的最小生成树中某种权值的边的数目均相同。 开始时，每个点单独构成一个集合。 首先只考虑权值最小的边，将它们全部添加进图中，并去掉环，由于是全部尝试添加，那么只要是用这种权值的边能够连通的点，最终就一定能在一个集合中。 那么不管添加的是哪些边，最终形成的集合数都是一定的，且集合的
bzoj2208 [Jsoi2010]连通数 强连通分量缩点+拓扑排序+bitset
olahiuj的博客
01-07 379
Description 对于100%的数据，N不超过2000。 Solution 容易想到要tarjan缩点按拓扑序递推，但是去重的步骤不好弄 C++STL中有bitset，用这个当成二进制按位状压即可 一开始错是没有给每个连通分量标记自己包含的点，这样就只算了相同连通分量的贡献。奈何拍的数据太弱，浪费了1h Code #include #include
强连通图------（1）通过两次DFS或BFS判断是不是强连通图
qq_40691051的博客
11-16 3130
一、定义： 强连通图（Strongly Connected Graph）是指在有向图G中，如果对于每一对vi、vj，vi≠vj，从vi到vj和从vj到vi都存在路径，则称G是强连通图。 二、判断是不是强连通图的算法： 下面是Kosaraju基于DFS的简单算法，这算法对图进行了两次DFS遍历： 1) 将所有顶点初始化为未访问。 2）从任意顶点v开始进行图的DFS遍历。如果DFS遍历没有访问完所有顶...
强连通图 Tarjan算法
07-30 117
算法学习：https://blog.csdn.net/qq_16234613/article/details/77431043 http://www.cnblogs.com/chenchengxun/p/4718698.html 题目链接：https://vjudge.net/contest/219056#problem/B 为了训练小希的...
判断强连通图
xueyingxue001的专栏
10-27 2万+
本总结是是个人为防止遗忘而作，不得转载和商用。 什么是强连通图          对一个有向图，如果每个节点都存在到达其他任何节点的路径，那么就称它是强连通的。 如何判断强连通图          任取有向图G的某结点S，从S开始进行深度优先搜索，若可以遍历G的所有结点，则将G的所有边反向，再次从S开始进行深度优先搜索，如果再次能够遍历G的所有结点，则G是强连通图，两次搜索有一次无法遍历所
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值