浅析强连通分量（Tarjan和kosaraju）

时间：2017-09-26 11:12:25 阅读：259 评论：0 收藏：0 [点我收藏+]

标签：connect 分析 tar int pre strong www. dex 一个

理解

在有向图G中，如果两点互相可达，则称这两个点强连通，如果G中任意两点互相可达，则称G是强连通图。

定理： 1、一个有向图是强连通的，当且仅当G中有一个回路，它至少包含每个节点一次。

2、非强连通有向图的极大强连通子图，称为强连通分量（SCC即Strongly Connected Componenet）。

在上图中，{1,2,3,4}是一个强连通分量，{5}，{6}分别是另外两个强连通分量。怎么判断一个图是否是强连通图，如果不是，有哪些强连通分量，又怎么使它成为强连通图呢？

方法1：Korasaju算法

首先理解一下转置图的定义:将有向图G中的每一条边反向形成的图称为G的转置G^T 。(注意到原图和G ^T 的强连通分支是一样的)

算法流程：

1.深度优先遍历G,算出每个结点u的结束时间f[u],起点如何选择无所谓。

2.深度优先遍历G的转置图G T ,选择遍历的起点时,按照结点的结束时间从大到小进行。遍历的过程中,一边遍历,一边给结点做分类标记,每找到一个新的起点,分类标记值就加1。

3. 第2步中产生的标记值相同的结点构成深度优先森林中的一棵树,也即一个强连通分量

注意：

　　Kosaraju算法比Tarjan时间复杂度要高，应用范围小，还有着爆栈超内存的风险，但这个算法比Tarjan好理解很多。当然和Tarjan一样，Kosaraju也只能用于有向图中。

　　Kosaraju也是基于深度优先搜索的算法。这个算法牵扯到两个概念，发现时间st，完成时间et。发现时间是指一个节点第一次被遍历到时的次序号，完成时间是指某一结点最后一次被遍历到的次序号。

　　在加边时把有向图正向建造完毕后再反向加边建一张逆图。

　　先对正图进行一遍dfs，遇到没访问过的点就让其发现时间等于目前的dfs次序号。在回溯时若发现某一结点的子树全部被遍历完，就让其完成时间等于目前dfs次序号。正图遍历完后将节点按完成时间入栈，保证栈顶是完成时间最大的节点，栈底是完成时间最小的节点。然后从栈顶开始向下每一个没有被反向遍历过的节点为起点对逆图进行一遍dfs，将访问到的点记录下来（或染色）并弹栈，每一遍反向dfs遍历到的点就构成一个强连通分量。

图解：

技术分享

(a)为有向图G,
其中的阴影部分
是G的强连通分
支,对每个顶点
都标出了其发现
时刻与完成时刻
,黑色边为深度
优先搜索的树
枝;
(b)G的转置图G T
依次以b,c,g,h
为起点做DFS,
得到4个强连通
分量

算法复杂度分析

深度优先搜索的复杂度:Θ(V + E)

计算G T 的复杂度:0或者Θ(V + E)(临接表)
所以总的复杂度为:Θ(V + E)
非常好的算法!（个人更青睐于Tarjan，但kosaraju的思路至少得理解）

模板：

 1 void positive_dfs(int pos){
 2     DFN++;
 3     vis[pos]=1;
 4     for(int i=pre[1][pos];i;i=E[1][i].next)
 5         if(!vis[E[1][i].to])
 6             positive_dfs(E[1][i].to);
 7     stack[N*2+1-(++DFN)]=pos;
 8 }
 9 void negative_dfs(int pos){
10     dye[pos]=CN;
11     vis[pos]=0;
12     size[dye[pos]]++;
13     for(int i=pre[2][pos];i;i=E[2][i].next)
14         if(vis[E[2][i].to])
15             negative_dfs(E[2][i].to);
16 }
17 int main(){
18 
19         ...... 
20 
21     for(int i=1;i<=N;i++)
22         if(!vis[i])
23             positive_dfs(i);
24     for(int i=1;i<=N*2;i++)
25         if(stack[i]&&vis[stack[i]]){
26             CN++;
27             negative_dfs(stack[i]);
28         }
29 
30         ......
31     
32 }

方法二：Tarjan算法

理解：

　　Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。总的来说， Tarjan算法基于一个观察，即：同处于一个SCC中的结点必然构成DFS树的一棵子树。我们要找SCC，就得找到它在DFS树上的根。

算法思想如下：

　　 dfn[u]表示dfs时达到顶点u的次序号（时间戳），low[u]表示以u为根节点的dfs树中次序号最小的顶点的次序号，所以当dfn[u]=low[u]时，以u为根的搜索子树上所有节点是一个强连通分量。先将顶点u入栈，dfn[u]=low[u]=++idx,扫描u能到达的顶点v，如果v没有被访问过，则dfs(v)，low[u]=min(low[u],low[v])，如果v在栈里，low[u]=min(low[u],dfn[v])，扫描完v以后，如果dfn[u]=low[u]，则将u及其以上顶点出栈。

图解（一定要仔细从左往右看）：

模板（Tarjan算法）：

 1 void tarjan(int pos){
 2     vis[stack[++index]=pos]=1;//入栈并标记
 3     LOW[pos]=DFN[pos]=++dfs_num;
 4     for(int i=pre[pos];i;i=E[i].next){
 5         if(!DFN[E[i].to]){
 6             tarjan(E[i].to);
 7             LOW[pos]=min(LOW[pos],LOW[E[i].to]);
 8         }
 9         else if(vis[E[i].to]) LOW[pos]=min(LOW[pos],DFN[E[i].to]);
10     }
11     if(LOW[pos]==DFN[pos]){
12         vis[pos]=0;
13         size[dye[pos]=++CN]++;//染色及记录强连通分量大小
14         while(pos!=stack[index]){
15             vis[stack[index]]=0;
16             size[CN]++;//记录大小
17             dye[stack[index--]]=CN;//弹栈并染色
18         }
19         index--;
20     }
21 }

模板（完整Tarjan）：

 1 #include <cstdio>
 2 #include <stack>
 3 #include <cstring>
 4 #include <iostream>
 5 using namespace std;
 6 int n,m,idx=0,k=1,Bcnt=0;
 7 int head[100];
 8 int ins[100]={0};
 9 int dfn[100]={0},low[100]={0};
10 int Belong[100];
11 stack <int> s;
12 struct edge
13 {
14     int v,next;
15 }e[100];
16 int min(int a,int b)
17 {
18     return a<b?a:b;
19 }
20 void adde(int u,int v)
21 {
22      e[k].v=v;
23      e[k].next=head[u];
24      head[u]=k++;
25 }
26 void readdata()
27 {
28      int a,b;
29      memset(head,-1,sizeof(head));
30      scanf("%d%d",&n,&m);
31      for(int i=1;i<=m;i++)
32      {
33          scanf("%d%d",&a,&b);
34          adde(a,b);
35      }
36 }
37 void tarjan(int u)
38 {
39      int v;
40      dfn[u]=low[u]=++idx;//每次dfs，u的次序号增加1
41      s.push(u);//将u入栈
42      ins[u]=1;//标记u在栈内
43      for(int i=head[u];i!=-1;i=e[i].next)//访问从u出发的边
44      {
45          v=e[i].v;
46          if(!dfn[v])//如果v没被处理过
47          {
48              tarjan(v);//dfs(v)
49              low[u]=min(low[u],low[v]);//u点能到达的最小次序号是它自己能到达点的最小次序号和连接点v能到达点的最小次序号中较小的
50          }
51          else if(ins[v])low[u]=min(low[u],dfn[v]);//如果v在栈内，u点能到达的最小次序号是它自己能到达点的最小次序号和v的次序号中较小的
52      }     
53      if(dfn[u]==low[u])
54      {
55          Bcnt++;
56          do
57          {
58              v=s.top();
59              s.pop();
60              ins[v]=0;
61              Belong[v]=Bcnt;
62          }while(u != v);
63      }
64 }
65 void work()
66 {
67      for(int i=1;i<=n;i++)if(!dfn[i])tarjan(i);
68      printf("\n");
69      for(int i = 1;i <= 6;i++)printf("%d %d\n",dfn[i],low[i]);
70      printf("共有%d强连通分量，它们是:\n",Bcnt); 
71      for(int i=1;i<=Bcnt;i++)
72      {
73         printf("第%d个:",i);
74         for(int j=1;j<=n;j++)
75         {
76            if(Belong[j]==i)printf("%d ",j);
77         }
78         printf("\n");
79      }
80 }
81 int main()
82 {
83     readdata();
84     work();
85     return 0;
86 }
87 /*
88 6 8 
89 1 2
90 1 3
91 2 4
92 3 4
93 3 5
94 4 1
95 4 6 
96 5 6
97 */