实用算法实现-第 17 篇 强连通分支

最新推荐文章于 2018-09-04 12:46:10 发布
最新推荐文章于 2018-09-04 12:46:10 发布
阅读量1.3k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 实用算法实践 文章标签： 算法 insert graph struct processing 优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fsdev/article/details/6849767
本文详细介绍了Kosaraju算法，包括其实现原理、复杂度分析以及在求解强连通分支和判断单向连通性问题中的应用。通过实例解析算法过程，并提供了程序实现。Kosaraju算法虽然需要对原图和逆图进行两次DFS，但复杂度仍为O(V+E)。文章还探讨了如何通过优化算法以提高效率。

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

求强连通分量的著名算法：Kosaraju算法，Gabow算法和Tarjan算法。其中Kosaraju算法要对原图和逆图都进行一次DFS，而另外两种算法只要进行一次DFS即可。[i]文是介绍Gabow算法的论文。

17.1    Kosaraju算法

Kosaraju算法虽然要进行两次DFS，但是复杂度仍然是O(V+E)，而且比较容易理解。

17.1.1   实例

PKU JudgeOnline, 2186, Popular Cows.

17.1.2   问题描述

有一群牛，总数为N。给出牛之间的M个仰慕关系，该关系可以传递，比如：1仰慕2，2仰慕3，那么1也仰慕3，如果一头牛被所有的牛都仰慕，那么它将是最受欢迎的牛，求出有多少牛是最受欢迎的。

先输入N、M，再输入M个仰慕关系。

17.1.3   输入

33

12

21

2 3

17.1.4   输出

1

17.1.5   分析

先对图求强连通分支，将所有强连通子图合并为一个结点，形成一个新图。

不难证明：在图中，如果将强连通分支看做一个结点，那么如果该结点出度不为0，则该SCC中的牛不是被所有牛仰慕的牛。反证法即可证明。

更进一步，不难证明：如果图中有牛被所有牛仰慕，那么有且只有一个出度为0的，且从图中的任何一个结点都能到达（连通性）的SCC，该SCC包含被所有牛仰慕的牛。反证法可以证明。

也可以知道：如果超过一个SCC的出度为0，那么连通性得不到保障。

可以证明：存在所有牛仰慕的牛，当且仅当出度为0的SCC有且只有一个。“仅当”很容易证明，下面证明“当”。假设只有一个SCC出度不为0时，但是却不存在所有牛仰慕的牛。那么必然意味着，有结点不能到达该SCC。因为如果所有结点都能到达该SCC，那么很自然的该SCC就是包含所有被其它所有牛仰慕的牛。在不能到达该SCC的结点中至少存在一个结点，其出度为0。因为如果所有结点的出度都不为0，那么所有结点必然形成一个环。形成环的结点在构造强连通分支的时候是要合并在一起的，矛盾。所以必然至少存在一个结点，其出度为0。假设和结果矛盾，故此，命题得证。

所以要求被所有牛仰慕的牛的个数，只需要求强连通分支，然后统计出度为0的个数。如果个数不为1则输出0。然后找到出度为0的那个SCC，。如果能就输出该SCC的牛的个数。

1.1.6   程序

#include <stdio.h>
#include <string.h>
#define G_size 100000 //边的最大个数
#define V_size 11000 //点的最大个数
 
typedef struct Graph
{
     int id;//记录了结点的序号
     int next;
}Graph;
 
typedef struct Edge
{
     int s, e;
}Edge;
 
EdgeE[G_size];
GraphGA[G_size];
GraphGT[G_size];
int N, M;
int G_end;
int order[V_size];
int id[V_size];//在逆序的时候记录了SCC的序号
int vis[V_size];//遍历图的时候使用
int in[V_size];//计算反向SCC图的入度，也就是逆向之前的SCC图出度
int cnt, scnt, pos;
 
void Insert(int s, int e) //建立原图和逆图
{
     int p;
     p = s;
     while(GA[p].next){
         p = GA[p].next;
     }
     GA[G_end].id = e;
     GA[p].next = G_end;
 
     p = e;
     while(GT[p].next){
          p= GT[p].next;
     }
     GT[G_end].id = s;
     GT[p].next = G_end;
 
     G_end++;
}
 
void DFST(int x) //对原图进行搜索
{
     int p, q;
     vis[x] = 1;
     p = GT[x].next;
     while(p){
         q = GT[p].id;
         if(!vis[q])
         {
              DFST(q);
         }
         p = GT[p].next;
     }
     order[cnt++] = x;
}
 
void DFSA(int x) //对逆图进行搜索
{
     int p, q;
     vis[x] = 1;
     id[x] = cnt;
     p = GA[x].next;
     while (p){
         q = GA[p].id;
         if(!vis[q])
         {
              DFSA(q);
         }
         p = GA[p].next;
     }
}
 
void Solve() //主要过程
{
     int s, e;
     int i;
 
     memset(GA, 0, sizeof(GA));
     memset(GT, 0, sizeof(GT));
     memset(E, 0, sizeof(E));
     G_end = N + 1;
 
     for (i = 0;i < M; i++)
     {
         scanf("%d%d", &s, &e);
         E[i].s = s - 1;
         E[i].e = e - 1;
         Insert(s - 1, e - 1);
     }
 
     memset(vis, 0, sizeof(vis));
     cnt = 0;
     for (i = 0;i < N; i++)
     {
         if(!vis[i])
         {
              DFST(i);
         }
     }
 
     memset(vis, 0, sizeof(vis));
     cnt = 0;
     for (i = N- 1; i >= 0; i--)
     {
         if(!vis[order[i]])
         {
              DFSA(order[i]);
              cnt++;
         }
     }
 
     for (i = 0;i < M; i++)
     {
         s = id[E[i].s];
         e = id[E[i].e];
         if (s!= e)
         {
              in[s]++;
         }
     }
     scnt = cnt;
     cnt = 0;
     for (i = 0;i < scnt; i++){
         if(in[i] == 0)
         {
              pos = i;
              cnt++;
         }
     }
     if (cnt !=1){
         printf("0\n");
     }
     else{
         cnt = 0;
         for (i= 0; i < N; i++){
              if(in[id[i]] == pos)
              {
                   cnt++;
              }
         }
         printf("%d\n",cnt);
     }
}
 
int main()
{
     while (EOF!= scanf("%d %d", &N, &M))
         Solve();
     return 0;
}


17.2    Kosaraju算法判断单向连通性

17.2.1   实例

PKU JudgeOnline, 2762, Going from u to v or from v to u?.

17.2.2   问题描述

给定N个点和这N个点之间的M个有向连接。如果两个点之间能从其中一个点到另一个点，那么这两个点就是单向连通的。问这N个点是不是都是单向连通的。

先输入测试个数。每个测试，先输入N、M，然后是M个连接。

17.2.3   输入

1

33

12

23

31

17.2.4   输出

Yes

17.2.5   分析

可以通过求强连通分支，简化图形，使得每两个结点只有单向连接。

然后使用DFS方法，对新图进行拓扑排序。

不难证明：如果原图是单向连通的，那么拓扑排序之后的结点必有指向下一个结点的连接。这是因为：假设没有这个连接，原图又是连通的，会拓扑排序的定义相违背。拓扑排序：对于有向无回路图，进行排序之和，如果包含边(u, v)那么u就出现在v之前。

同时不难证明：如果原图是单向连通的，那么新图有且只有一个结点的入度为0。首先，强连通分支将所有的回路聚合了，所以新图不存在回路，故此至少有一个结点的入度为0。其次，如果超过一个结点的入度为0，那么这两个结点肯定不能到达彼此。

故此，只需要先求强连通分支，建立新图，然后新图判断入度为0的结点个数是不是只有一个。然后以这个结点为根，DFS遍历新图，进行拓扑排序。最后，判断排序好的结点到下一个结点是不是有连接。

这里用到的强连通算法仍然是Kosaraju算法，但是由于超时，就对原来的程序进行了优化。主要的优化在于加入数组，记录每个结点的最后一个子结点的保存位置。典型的空间换时间。

1.2.6   程序

#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
#define G_size 10100 //边的最大个数
#define V_size 1010 //点的最大个数
 
typedef struct Graph
{
     int id;//记录了结点的序号
     int next;
}Graph;
 
typedef struct Edge
{
     int s, e;
}Edge;
 
EdgeE[G_size];
GraphGA[G_size];
GraphGT[G_size];
int N, M;
int G_end;
int order[V_size];
int id[V_size];//在逆序的时候记录了边所属的SCC的序号
int vis[V_size];//遍历图的时候使用
int in[V_size];//计算SCC图的入度
int cnt, scnt, pos;
int lastSonGA[V_size];
int lastSonGT[V_size];
void Insert(int s, int e) //建立原图和逆图
{
     int p;
     p = lastSonGA[s];
     GA[G_end].id = e;
     GA[p].next = G_end;
     lastSonGA[s] = G_end;
 
     p = lastSonGT[e];
     GT[G_end].id = s;
     GT[p].next = G_end;
     lastSonGT[e] = G_end;
 
     G_end++;
}
void DFST(int x) //对逆图进行搜索
{
     int p, q;
     vis[x] = 1;
     p = GT[x].next;
     while(p){
         q = GT[p].id;
         if(!vis[q])
         {
              DFST(q);
         }
         p = GT[p].next;
     }
     order[cnt++] = x;
}
 
void DFSA(int x) //对原图进行搜索
{
     int p, q;
     vis[x] = 1;
     id[x] = cnt;
     p = GA[x].next;
     while (p){
         q = GA[p].id;
         if(!vis[q])
         {
              DFSA(q);
         }
         p = GA[p].next;
     }
}
int GSCC_end;
GraphGSCC[G_size];
int lastSonGSCC[V_size];
void InsertGSS(int s, int e) //建立原图和逆图
{
     int p;
     p = lastSonGSCC[s];
     GSCC[GSCC_end].id = e;
     GSCC[p].next = GSCC_end;
     lastSonGSCC[s] = GSCC_end;
     GSCC_end++;
}
int TopologcalOrder[V_size];
void DFS_GSS(int x)
{
     int p, q;
     vis[x] = 1;
     p = GSCC[x].next;
     while (p){
         q = GSCC[p].id;
         if(!vis[q])
         {
              DFS_GSS(q);
         }
         p = GSCC[p].next;
     }
     TopologcalOrder[cnt++] = x;
}
int linked[V_size][V_size];
void Solve() //主要过程
{
     int s, e;
     int p;
     int i;
     int fail;
     memset(GA, 0, sizeof(GA));
     memset(GT, 0, sizeof(GT));
     memset(E, 0, sizeof(E));
     for(i = 1;i <= N; i++){
         lastSonGT[i] = i;
         lastSonGA[i] = i;
     }
     G_end = N + 1;
     for (i = 1;i <= M; i++)
     {
         scanf("%d%d", &s, &e);
         E[i].s = s;
         E[i].e = e;
         Insert(s, e);
     }
 
     memset(vis, 0, sizeof(vis));
     cnt = 0;
     for (i = 1;i <= N; i++)
     {
         if(!vis[i])
         {
              DFST(i);
         }
     }
 
     memset(vis, 0, sizeof(vis));
     cnt = 0;
     for (i = N- 1; i >= 0; i--)
     {
         if(!vis[order[i]])
         {
              cnt++;
              DFSA(order[i]);
         }
     }
 
     scnt = cnt;
     for(i = 1;i <= cnt; i++){
         lastSonGSCC[i] = i;
     }
     GSCC_end = cnt + 1;
     memset(GSCC, 0, sizeof(GSCC));
     memset(in, 0, sizeof(in));
     for (i = 1;i <= M; i++)
     {
         s = id[E[i].s];
         e = id[E[i].e];
         if (s!= e)
         {
              InsertGSS(s, e);
              linked[s][e] = 1;
              in[e]++;
         }
     }
     cnt = 0;
     for (i = 1;i <= scnt; i++){
         if(in[i] == 0)
         {
              pos = i;
              cnt++;
         }
     }
     fail = 0;
     if (cnt !=1){
         fail = 1;
     }else{
         memset(vis, 0, sizeof(vis));
         cnt = 0;
         DFS_GSS(pos);
         for(i =scnt - 1; i > 0; i--)
         {
              s = TopologcalOrder[i];
              e = TopologcalOrder[i - 1];
              if(linked[s][e]== 0)// && linked[e][s] == 0)
              {
                   fail = 1;
                   break;
              }
         }
     }
     if(fail ==1)
     {
         printf("No\n");
     }else{
         printf("Yes\n");
     }
}
 
int main()
{
     int cases;
     scanf("%d",&cases);
     for(; cases> 0; cases--){
         scanf("%d%d", &N, &M);
         Solve();
     }
     return 0;
}

17.3    实例

PKU JudgeOnline, 2186, Popular Cows.

PKU JudgeOnline, 2762, Going from u to v or from v to u?.

本文章欢迎转载，请保留原始博客链接http://blog.csdn.net/fsdev/article

[i] Path-Based Depth-first Search for Strong and Biconnected Components.Harold N. Gabow. Information Processing Letters 74 (2000) 107-114.

算法导论 第22章 图的基本算法（四） 强连通分支
V然成风
03-23 3370
强连通分支    计算有向图的强连通分支是深度优先搜索经典应用，很多图相关的算法都是将图分解为各个强连通分支之后，然后在各个强连通分支上运行，最后根据各个强连通分支之间的关系将所有的解组合起来。    对于有向图G=(V,E)任意两个顶点u,v，如果u能够经过一条路径到达v，v也能通过一条路径到达u，即两者互相可达，它们将属于一个强连通分支，强连通用分支就是这样一个最大的互相可达的顶点集合。
强连通分支算法
smsmn的专栏
11-15 1103
<br />#include<iostream> using namespace std; #define MAXN 10000//最多的点数 #define MAXM 10000//最多的边数 struct Node { int to; int next; }graph[MAXM]; int head[MAXN]; int n, m;//顶点数，边数 int low[MAXN], dfn[MAXN];//low[i]表示能回溯到的最小节点，dfn[i]表示访问的顺序 int b
强连通分支算法--Tarjan算法和Gabow算法
happylife1527的专栏
09-03 1080
Tarjan算法 Kosaraju算法的流程简单，但是需要对图(和逆图)进行两次DFS搜索，而且读逆图的DFS搜索中顶点的访问顺序有特定的限制。下面将介绍的两个算法的过程比Kosaraju算法更为简洁，只需要执行一次DFS，并且不需要计算逆图。 Tarjan基于递归实现的深度优先搜索，在搜索过程中将顶点不断压入堆栈中，并在回溯时判断堆栈中顶点是否在同一联通分支。函数借助两个辅助数组pre和lo
6.3.1 强连通分支算法--Kosaraju算法、Tarjan算法和Gabow算法
weixin_30715523的博客
11-08 349
强连通分支算法 本节内容将详细讨论有向图的强连通分支算法(stronglyconnectedcomponent)，该算法是图深度优先搜索算法的另一重要应用。强分支算法可以将一个大图分解成多个连通分支，某些有向图算法可以分别在各个联通分支上独立运行，最后再根据分支之间的关系将所有的解组合起来。 在无向图中，如果顶点s到t有一条路径，则可以知道从t到s也有一条路径；在有向无环图中个，如果顶...
程序员必知的十大基础实用算法及其讲解
07-22
BFPRT算法用于解决从n个元素的序列中找出第k大（或第k小）的元素问题。该算法通过巧妙的设计确保了最坏情况下的线性时间复杂度O(n)。 **工作原理：** 1. **分组与中位数提取：**将序列分组，并从中提取中位数。 2. ...
源代码_matlab_图论算法_源码实现_
10-03
本压缩包提供了图论算法的源码实现，为学习和研究提供了一个实用的工具。 首先，我们要了解图的基本概念。在图论中，一个图由顶点（Vertex）和边（Edge）组成，可以用来表示现实世界中的各种关系。无向图的边没有...
贪婪算法-回溯-深度优先搜索.pdf
05-16
其中，贪婪算法、回溯法和深度优先搜索是三种经常被使用且具有高度实用价值的方法。它们各自有着独特的应用范围和解决问题的方式，同时又相互关联，共同构成了现代算法设计的基石。 贪婪算法是一种以局部最优为特征...
程序员必备实用算法详解
因此，我将依据标题“程序员实用算法”和描述“程序员实用算法程序员实用算法程序员实用算法”（实际上并未提供有价值的描述内容），以及标签“实用算法”来构建相关的知识点。 ### 程序员实用算法知识点概述 ####...
图论算法实现集锦：初学者指南
资源摘要信息:"本资源是一个专注于图论算法的压缩包文件，标题为 'tulunsuanfa.rar_图论_图论算法_图论算法实现_算法'。该压缩包包含一个PDF文档，名为 '图论算法集锦.pdf'，旨在向初学者展示图论算法的核心知识和...
计算有向图的连通分支个数
03-20
计算有向图的连通分支个数，文件读入，输出到控制台窗口。-Computing connected components of a directed graph the number of documents read, output to the console window.
强连通分支算法--Kosaraju算法
happylife1527的专栏
09-03 1085
强连通分支算法 本节内容将详细讨论有向图的强连通分支算法(strongly connected component)，该算法是图深度优先搜索算法的另一重要应用。强分支算法可以将一个大图分解成多个连通分支，某些有向图算法可以分别在各个联通分支上独立运行，最后再根据分支之间的关系将所有的解组合起来。 在无向图中，如果顶点s到t有一条路径，则可以知道从t到s也有一条路径；在有向无环图中个，如果顶点s
算法基础 - 求有向图的强连通分支(Tarjan算法)
累了就歇一会
05-30 9514
强连通分支如果两个顶点可以相互通达，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。Tarjan算法Tarjan算法是用来求有向图的强连通分量的。求有向图的强连通分量的Tarjan算法是以其发明者Robert Tarjan命
强连通分支及kosaraju算法
白水白水的专栏
08-28 2781
图论中最重要的结构，很多图论问题都可以转化为强连通分支来降低处理复杂度。一个强连通分支中所有的点都是互相连通的，可以将其收缩为单个点，以此来简化图的处理。强连通分支中的点集合是一个最大集合，即再加入任何一个其他点都会导致不连通。   引理1：图G的两个强连通分支C、C’，如果存在点u属于C，u’属于C’，使得(u,u’)为G的一条边，则一定不存在另一条边(v’,v)，使得v’属于C’，v属于C
ACM图论__有向图的强连通分支算法
untilyouydc
02-21 3521
求有向图的强连通分支，主要有两种算法tarjan算法和kosaraju算法，这里介绍tarjan算法先来看几个定义：（1）连通：两个点可以相互到达（2）强连通(strongly connected)： 在一个有向图G里，设两个点 a b 发现，由a有一条路可以走到b，由b又有一条路可以走到a，我们就叫这两个顶点（a，b）强连通。（3）强连通分量strongly connected componen...
有向图强连通分支
逐梦者
09-04 2659
算法 在有向图G中，如果任意两个不同的顶点相互可达，则称该有向图是强连通的。有向图G的极大强连通子图称为G的强连通分支。 Tarjan算法 dfn[i]表示编号为i的节点在DFS过程中的访问序列（也可以叫做开始时间）。在DFS过程中会形成一搜索树。在搜索树上越先遍历到的节点，dfn值越小 low[i]表示从i节点出发DFS过程中i下方结点（开始时间大于dfn[i]，且由i可达的节点）所能到...
4.3　连通分支
哪里有家
10-25 7720
§4.3　连通分支　　本节重点:　　掌握连通分支的定义(即连通”类”的分法)；　　掌握连通分支的性质(定理4.3.1)．　　从前面两节中的内容可以看出，知道一个拓扑空间是否连通给我们处理一些问题带来很大的方便．这导致我们去考察一个我们并不知道是否连通的拓扑空间中的“最大”连通子集（即连通分支）．　　定义4.3.1　设X是一个拓扑空间，x，y∈X．如果X中有一个连通子集同时包含x
强连通分支
yujiazhen1991的专栏
05-14 526
求强连通分支的三种算法： http://www.cnblogs.com/luweiseu/archive/2012/07/14/2591370.html 主要是tarjin算法，详见 http://www.cnblogs.com/saltless/archive/2010/11/08/1871430.html 例外给出一个自己写的最基本的强连通分支算法： #include usi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值