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

关注

原创最新推荐文章于 2026-03-06 00:18:24 发布 1.3k 阅读 AI 写同款· GEO 优化 ›

算法导论第22章图的基本算法（四）强连通分支 强连通分支 计算有向图的强连通分支是深度优先搜索经典应用，很多图相关的算法都是将图分解为各个强连通分支之后，然后在各个强连通分支上运行，最后根据各个强连通分支之间的关系将所有的解组合起来。对于有向图G=(V,E)任意两个顶点u,v，如果u能够经过一条路径到达v，v也能通过一条路径到达u，即两者互相可达，它们将属于一个强连通分支，强连通用分支就是这样一个最大的互相可达的顶点集合。阅读详情

求强连通分量的著名算法：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 输入

2 3

17.1.4 输出

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 输入

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.youkuaiyun.com/fsdev/article

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

收录于