强连通分量Kosaraju算法

最新推荐文章于 2023-07-03 10:47:11 发布
最新推荐文章于 2023-07-03 10:47:11 发布
阅读量125 收藏
点赞数 1
分类专栏： 算法导论(图论)C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45349225/article/details/104815764
版权

参考阅读：https://blog.csdn.net/lhl1124281072/article/details/79699870
如何理解Kosaraju算法？ - 简致的回答 - 知乎
https://www.zhihu.com/question/58926821/answer/583402591
Kosaraju算法步骤：

  1. 用DFS后序遍历原图的反转图，得到后序遍历顺序
  2. 用得到的后序遍历顺序对原图DFS
    代码实现
    栈和图的定义
const int MaxV = 100;

/*定义栈*/
typedef struct SNode{
	string *Data;
	int Top;
	int MaxSize;
} * Stack;

/*定义边*/
typedef struct ENode{
	int v1, v2;
	string va, vb;
} * Edge;

/*定义邻接点*/
struct AdjVNode{
	int AdjV;	//顶点int型编号
	AdjVNode *Next;
};

/*定义邻接表头*/
typedef struct VNode{
	AdjVNode *EdgeFirst;
	string Data;
	bool tag;
} AdjList[MaxV];

/*定义图*/
typedef struct GNode{
	int Nv, Ne;
	AdjList L;
} * LGraph;

对栈需要的操作

/*创造一个新的栈*/
Stack CreateStack(int MaxSize)
{
	Stack S = new SNode;
	S->Data = new string[MaxSize];
	S->MaxSize = MaxSize;
	S->Top = -1;
	return S;
}

/*将x压入栈*/
void Push(Stack S, string x)
{
	S->Data[++S->Top] = x;
}

/*返回元素x是否在栈中位置, 若不在返回-1*/
int FindS(Stack S, string x)
{
	for (int i = S->Top; i >= 0; i--)
		if(S->Data[i] == x)
			return i;
	return -1;
}

/*将边由string型加入对应的int型顺序编号*/
void Edge_Code(Edge E, Stack S)
{
	int k = FindS(S, E->va);
	if(k < 0)	//如果顶点不在栈中, 压入栈
	{
		Push(S, E->va);
		E->v1 = S->Top;	//得到新的v1的编号
	}
	else
		E->v1 = k;		//得到已有v1的编号
	k = FindS(S, E->vb);
	if (k < 0) //如果顶点不在栈中, 压入栈
	{
		Push(S, E->vb);
		E->v2 = S->Top; //得到新的v2的编号
	}
	else
		E->v2 = k; //得到已有v2的编号
}

图的操作

/*创造新的无边图*/
LGraph CreateGraph(int Nv)
{
	LGraph G = new GNode();
	G->Nv = Nv;
	return G;
}

/*边的插入*/
void InsertEdge(LGraph G, Edge E)
{
	AdjVNode *V = new AdjVNode;
	V->AdjV = E->v2;
	V->Next = G->L[E->v1].EdgeFirst;
	G->L[E->v1].EdgeFirst = V;
}

/*键入建立图*/
LGraph BuildGraph()
{
	int Nv;
	cin >> Nv;
	LGraph G = CreateGraph(Nv);
	cin >> G->Ne;
	Edge E = new ENode;
	Stack S = CreateStack(G->Nv);
	//使用栈来储存顶点数据，每输入一个顶点, 判断之前有没有输入过, 没有就压入栈返回栈顶下标, 有就返回在栈中的元素的位置下标
	for (int i = 0; i < G->Ne; i++)
	{
		cin >> E->va >> E->vb;
		Edge_Code(E, S);	//由string得到int编号
		InsertEdge(G, E);	//插入边
		G->L[E->v1].Data = E->va;	//顶点存的数据为字符编号
		G->L[E->v2].Data = E->vb;
	}
	delete E;
	delete[] S->Data;
	delete S;
	return G;
}

/*删除图*/
void DeleteGraph(LGraph G)
{
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
	{
		while (G->L[i].EdgeFirst)
		{
			V = G->L[i].EdgeFirst;
			G->L[i].EdgeFirst = V->Next;
			delete V;
		}
	}
	delete G;
}

输出图的物理结构

/*遍历输出图的邻接表图的物理结构*/
void ShowGraph(LGraph G)
{
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
	{
		V = G->L[i].EdgeFirst;
		cout << G->L[i].Data << "->";
		while (V)
		{
			cout << G->L[V->AdjV].Data << "->";
			V = V->Next;
		}
		cout << "NULL" << endl;
	}
}

得到图G的倒置图Gr

/*返回图G的倒置图Gr*/
LGraph ReverseGraph(LGraph G)
{
	LGraph Gr = CreateGraph(G->Nv);
	Edge E = new ENode;
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
	{
		Gr->L[i].Data = G->L[i].Data;	//先复制顶点的string数据
		V = G->L[i].EdgeFirst;
		E->v2 = i;
		while (V)
		{
			E->v1 = V->AdjV;
			InsertEdge(Gr, E);
			V = V->Next;
		}
	}
	delete E;
	return Gr;
}

Kosaraju算法

/*找出字符x在图G中的编号*/
int FindG(LGraph G, string x)
{
	for (int i = 0; i < G->Nv; i++)
		if (G->L[i].Data == x)
			return i;
	return -1;
}
void DFS(LGraph G, int u, Stack S)
{
	G->L[u].tag = true;
	AdjVNode *V = G->L[u].EdgeFirst;
	while (V)
	{
		if(!G->L[V->AdjV].tag)
			DFS(G, V->AdjV, S);
		V = V->Next;
	}
	Push(S, G->L[u].Data);
}

void Kosaraju(LGraph G)
{
	Stack S;
	int *reverse = new int[G->Nv];
	/*这里得到Gr图, 并输出原图和倒置图的物理结构*/
	LGraph Gr = ReverseGraph(G);
	cout << "原图: " << endl;
	ShowGraph(G);
	cout << "倒置图" << endl;
	ShowGraph(Gr);
	S = CreateStack(Gr->Nv);		//建立新栈, 用于储存DFS后序遍历顺序

	for (int i = 0; i < Gr->Nv; i++)	//对Gr进行DFS得出后序遍历，标记一下
		if(!Gr->L[i].tag)
			DFS(Gr, i, S);

	for (int i = 0; i < Gr->Nv; i++)
		reverse[i] = FindG(Gr, S->Data[i]);

	delete[] S->Data;
	delete S;

	int start = 0;
	S = CreateStack(G->Nv);
	cout << "该图包含以下强连通分量:" << endl;
	for (int i = G->Nv - 1; i >= 0; i--)
	{
		if (!G->L[reverse[i]].tag)	//对每个顶点DFS，都会把该顶点所在的强连通分量遍历完才退出DFS
		{
			DFS(G, reverse[i], S);
			for (int i = start; i <= S->Top; i++)
				cout << S->Data[i] << " ";
			cout << endl;
			//cout << S->Data[S->Top] << endl;
			start = S->Top + 1;
		}
	}
	DeleteGraph(G);
	DeleteGraph(Gr);
	delete[] reverse;
	delete[] S->Data;
	delete S;
}

程序运行
输入
在这里插入图片描述

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

运行结果
在这里插入图片描述
完整代码

#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cstring>
using namespace std;
const int MaxV = 100;

/*定义栈*/
typedef struct SNode{
	string *Data;
	int Top;
	int MaxSize;
} * Stack;

/*定义边*/
typedef struct ENode{
	int v1, v2;
	string va, vb;
} * Edge;

/*定义邻接点*/
struct AdjVNode{
	int AdjV;	//顶点int型编号
	AdjVNode *Next;
};

/*定义邻接表头*/
typedef struct VNode{
	AdjVNode *EdgeFirst;
	string Data;
	bool tag;
} AdjList[MaxV];

/*定义图*/
typedef struct GNode{
	int Nv, Ne;
	AdjList L;
} * LGraph;

/*创造一个新的栈*/
Stack CreateStack(int MaxSize)
{
	Stack S = new SNode;
	S->Data = new string[MaxSize];
	S->MaxSize = MaxSize;
	S->Top = -1;
	return S;
}

/*将x压入栈*/
void Push(Stack S, string x)
{
	S->Data[++S->Top] = x;
}

/*返回元素x是否在栈中位置, 若不在返回-1*/
int FindS(Stack S, string x)
{
	for (int i = S->Top; i >= 0; i--)
		if(S->Data[i] == x)
			return i;
	return -1;
}

/*将边由string型加入对应的int型顺序编号*/
void Edge_Code(Edge E, Stack S)
{
	int k = FindS(S, E->va);
	if(k < 0)	//如果顶点不在栈中, 压入栈
	{
		Push(S, E->va);
		E->v1 = S->Top;	//得到新的v1的编号
	}
	else
		E->v1 = k;		//得到已有v1的编号
	k = FindS(S, E->vb);
	if (k < 0) //如果顶点不在栈中, 压入栈
	{
		Push(S, E->vb);
		E->v2 = S->Top; //得到新的v2的编号
	}
	else
		E->v2 = k; //得到已有v2的编号
}

/*创造新的无边图*/
LGraph CreateGraph(int Nv)
{
	LGraph G = new GNode();
	G->Nv = Nv;
	return G;
}

/*边的插入*/
void InsertEdge(LGraph G, Edge E)
{
	AdjVNode *V = new AdjVNode;
	V->AdjV = E->v2;
	V->Next = G->L[E->v1].EdgeFirst;
	G->L[E->v1].EdgeFirst = V;
}

/*键入建立图*/
LGraph BuildGraph()
{
	int Nv;
	cin >> Nv;
	LGraph G = CreateGraph(Nv);
	cin >> G->Ne;
	Edge E = new ENode;
	Stack S = CreateStack(G->Nv);
	//使用栈来储存顶点数据，每输入一个顶点, 判断之前有没有输入过, 没有就压入栈返回栈顶下标, 有就返回在栈中的元素的位置下标
	for (int i = 0; i < G->Ne; i++)
	{
		cin >> E->va >> E->vb;
		Edge_Code(E, S);	//由string得到int编号
		InsertEdge(G, E);	//插入边
		G->L[E->v1].Data = E->va;	//顶点存的数据为字符编号
		G->L[E->v2].Data = E->vb;
	}
	delete E;
	delete[] S->Data;
	delete S;
	return G;
}

/*遍历输出图的邻接表图的物理结构*/
void ShowGraph(LGraph G)
{
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
	{
		V = G->L[i].EdgeFirst;
		cout << G->L[i].Data << "->";
		while (V)
		{
			cout << G->L[V->AdjV].Data << "->";
			V = V->Next;
		}
		cout << "NULL" << endl;
	}
}

/*删除图*/
void DeleteGraph(LGraph G)
{
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
	{
		while (G->L[i].EdgeFirst)
		{
			V = G->L[i].EdgeFirst;
			G->L[i].EdgeFirst = V->Next;
			delete V;
		}
	}
	delete G;
}

/*返回图G的倒置图Gr*/
LGraph ReverseGraph(LGraph G)
{
	LGraph Gr = CreateGraph(G->Nv);
	Edge E = new ENode;
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
	{
		Gr->L[i].Data = G->L[i].Data;	//先复制顶点的string数据
		V = G->L[i].EdgeFirst;
		E->v2 = i;
		while (V)
		{
			E->v1 = V->AdjV;
			InsertEdge(Gr, E);
			V = V->Next;
		}
	}
	delete E;
	return Gr;
}

/*找出字符x在图G中的编号*/
int FindG(LGraph G, string x)
{
	for (int i = 0; i < G->Nv; i++)
		if (G->L[i].Data == x)
			return i;
	return -1;
}
void DFS(LGraph G, int u, Stack S)
{
	G->L[u].tag = true;
	AdjVNode *V = G->L[u].EdgeFirst;
	while (V)
	{
		if(!G->L[V->AdjV].tag)
			DFS(G, V->AdjV, S);
		V = V->Next;
	}
	Push(S, G->L[u].Data);
}

void Kosaraju(LGraph G)
{
	Stack S;
	int *reverse = new int[G->Nv];
	/*这里得到Gr图, 并输出原图和倒置图的物理结构*/
	LGraph Gr = ReverseGraph(G);
	cout << "原图: " << endl;
	ShowGraph(G);
	cout << "倒置图" << endl;
	ShowGraph(Gr);
	S = CreateStack(Gr->Nv);		//建立新栈, 用于储存DFS后序遍历顺序

	for (int i = 0; i < Gr->Nv; i++)	//对Gr进行DFS得出后序遍历，标记一下
		if(!Gr->L[i].tag)
			DFS(Gr, i, S);

	for (int i = 0; i < Gr->Nv; i++)
		reverse[i] = FindG(Gr, S->Data[i]);

	delete[] S->Data;
	delete S;

	int start = 0;
	S = CreateStack(G->Nv);
	cout << "改图包含以下强连通分量:" << endl;
	for (int i = G->Nv - 1; i >= 0; i--)
	{
		if (!G->L[reverse[i]].tag)	//对每个顶点DFS，都会把该顶点所在的强连通分量遍历完才退出DFS
		{
			DFS(G, reverse[i], S);
			for (int i = start; i <= S->Top; i++)
				cout << S->Data[i] << " ";
			cout << endl;
			//cout << S->Data[S->Top] << endl;
			start = S->Top + 1;
		}
	}
	delete[] reverse;
	delete[] S->Data;
	delete S;
}

int main()
{
	LGraph G = BuildGraph();
	Kosaraju(G);

	system("pause");
	return 0;
}
不导翁
关注
专栏目录
强连通分量——[Kosaraju算法]
20164225的博客
01-19 321
思路：[Kosaraju算法] Kosaraju是基于对有向图及其逆图两次DFS的方法，其时间复杂度也是O(N+M)。kosaraju算法的步骤如下：(1)在有向图G上，从某个顶点出发进行DFS，并按其所有邻接点的搜索都完成(即退出DFS函数)的顺序将顶点排列起来。(2)在有向图G上，从最后完成搜索的顶点出发，在图G的逆图G’上进行DFS，若此次遍历不能访问到有向图中所有顶点，则从余下的顶点中最后
理解强连通分量Kosaraju算法的正确性
罗先森何其有幸的博客
03-26 5701
1.基本概念    在看《算法》的有向图章节时，对于Kosaraju算法的理解花了很多时间，为了让更多人不在这个算法的理解上面耗费过多时间，特地把自己理解该算法的过程记录下来，分享给有需要的各位。    Kosaraju算法是计算有向图中强连通分量的经典算法。下面简要补充几个基本概念：1.1 有向图    在有向图中，边是单向的：每条边所连接的两个顶点都是一个有序对。如下图所示：    有向图的数...
强连通分量之Kosaraju算法
sinat_22510827的博客
10-20 446
今天学习了强连通分量的Kosaraju算法，网上写的人也不多，但是跟着视频教程讲解，还有去网上搜了博客，感觉他们的讲解都存在一定的问题，我在学习的时候碰到的一些困惑，他们并没有讲的清楚明白，当然，他们说的大致的思路是正确的。 算法思想： 先说说什么是强连通分量 强连通分量是针对有向图定义的，为了区别无向图的联通分量的概念。在一个强连通分量中，任意两点都相互可达。 这个图中就存在三个强连通分量，分别{0}、{1}、{2}，因为这三个点相互不可达，但是自己到自己还是可到达的。 上图就是一个联通分量，应为在这
强连通分量 的 Kosaraju算法
杰哥的专栏
04-14 2561
1. 定义 在有向图G中，如果两个顶点vi，vj有一条从vi到vj的有向路径，同时还有一条从vj到vi的路径，则称两个顶点强连通。如果有向图G中的每对顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量。 2. 求解  (1) 按照深度优先（DFS）遍历图G。遍历时图中每个顶点获得一个记录“x/y”，其中x表示第一次访问到该顶点时的序号，y表示从该顶点离开时的序号。 (
强连通分量（Kosaraju算法）
swineherd的博客
08-05 260
算法思想： 在一个有向图中，我们一定可以找到这样一个合理顺序，使得我们只需要按照这个顺序进行dfs遍历，那么每一次的dfs就可以使我们得到一个scc。合理顺序参考https://www.cnblogs.com/nullzx/p/6437926.html 经过简单的分析我们可以知道，那样的一个合理顺序就是scc图的拓扑顺序的逆序。 所以Kosaraju算法的核心思想就是如何找到scc图的拓扑顺...
强连通分量的Kosaraju算法实现
04-14
2. 用Kosaraju算法实现了强连通分量的求解。其中data中包含的GoolNodes测试集为Google提供的网页之间的连接经转化而来，每一个结点均代表一个网页。 3. 缺点：为了使用以前的CGraph类，强行添加了结点文件，其中第一...
强连通分量 Kosaraju算法
sysubo的专栏
10-24 606
强连通分量 Kosaraju算法  伪代码(摘自Introduction to Algorithm 3rd Edition)： Strongly_connected_components( G ) 1. call DFS(G) to compute finishing time u.f for each vertex u 2. compute GT 3. call DFS(GT), bu
Kosaraju算法证明
最新发布
qq_56071472的博客
07-03 302
关于Kosaraju的详细证明。如有问题，请在评论区指出。
kosaraju求强连通分量
01-25 153
在了解kosaraju算法之前我们先了解一下什么是强连通分量，在有向图中如果两个定点vi,ui存在一条路劲从vi到达ui且也存在一条路劲从ui到达vi那么由ui和vi这两个点构成的图成为强连通图,简洁一点就是存在两个或两个点以它们之间可以相互可达由这些点构成的图就称之为强连通图它们的存在形式可以如下 当然一个点也是一个强连通分量，它们都满足所有点之间都可以互相可达。 以上就是对强...
强连通分量_Kosaraju算法
expleeve
01-26 731
//将图G通过深度优先遍历，记录退出访问的序列（此序列为一逆拓扑序），并逐一入栈（拓扑序），将图G转置（即边的方向反转），对栈顶每个元素进行逐一深度遍历，遍历到的元素即为一个强连通分量；如果已经之前被遍历，则不再重复遍历。（这里使用邻接矩阵，可以使用十字链表来实现正逆矩阵）#include 　　using namespace std; 　　const int MAXN = 110; 　　t
强连通分量——kosaraju算法
fuyukai的专栏
05-13 2606
kosaraju算法，三大强连通分量算法之一，最简单、最好理解的求解有向图强连通分量的方法，单纯的两次深搜，就可以划分我们的图。 算法流程： 1、从任意一个点开始深搜，得到图的一个最晚完成时间的排序； 2、求图的反图； 3、根据第1步得到的排序，从最晚完成的一个点开始搜索并染色； 4、第三步每一次深搜完成就是一个强连通分量。 下面进行算法的具体分析。 算法思想： 其实这个算法是由两
强连通分量（kosaraju）
booyoungxu的专栏
07-30 520
强连通分量特点 1.有向图 2.强连通分量中任意2个点可以互达 3.在一个非强连通图中极大的强连通子图就是该图的强连通分量 4.一个非强连通图可以有多个强连通分量 kosaraju算法 事实：置换图（将图中的边的方向换向）和原始图有相同的强连通分量 描述： 1.首先使G为一个有向图，并且S是一个空栈 2.while S非空：任意选择一个不在栈S中的顶点。从这个顶点v出
强连通分量——Kosaraju算法
blog
07-25 510
①随意选取一个结点开始深搜，当搜索完子树时将它压到栈中 ②将原图转置（边的方向变成与原来相反），从栈顶节点再进行深搜，每次深搜结束所得的节点就是一个强连通分量 #include #include #include #include #include #include using namespace std; vector g[100],gt[100]; bool visit[100];
Kosaraju算法求强连通分量
m0_54123999的博客
05-21 344
Kosaraju算法 该算法旨在得到深度优先后续排列后的递归探索中，每次调用DFS的所有顶点都属于同一强联通分量。所以可以这么理解：当递归进入一个强联通分量时，把他锁死在这个强联通分量中（即不能从该强联通分量中的任意顶点达到外部顶点） ...
理解有向图的强连通分量：Kosaraju算法解析
本文主要介绍了有向图的强连通分量的概念以及如何利用Kosaraju算法来计算它们。 有向图的强连通分量是指在一个有向图中，如果任意两个节点都可以互相到达，那么这些节点就构成了一个强连通分量。换句话说，强连通...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值