【强连通分量】tarjan算法及kosaraju算法＋例题

最新推荐文章于 2025-02-19 19:44:44 发布

巴黎没有欧莱雅你也不值得被拥有

最新推荐文章于 2025-02-19 19:44:44 发布

阅读量705

点赞数

分类专栏：图论

图论专栏收录该内容

47 篇文章

订阅专栏

【强连通分量】tarjan算法及kosaraju算法＋例题

阅读前请确保自己知道强连通分量是什么，本文不做赘述。

Tarjan算法
一、算法简介
　　Tarjan算法是一种由Robert Tarjan提出的求有向图强连通分量的时间复杂度为O(n)的算法。

　　首先我们要知道两个概念：时间戳（DFN），节点能追溯到的最早的栈中节点的时间戳（LOW）。顾名思义，DFN就是在搜索中某一节点被遍历到的次序号（dfs_num），LOW就是某一节点在栈中能追溯到的最早的父亲节点的搜索次序号。

　　Tarjan算法是基于深度优先搜索的算法。在搜索过程中把没有Tarjan过的点入栈，并将该节点的DFN[i]=LOW[i]=++dfs_num（也就是设成他自己），然后以这个节点为树根再进行搜索。当一颗子树搜索完毕时回溯，并在回溯时比较当前节点和目标节点的LOW值，将较小的LOW值赋给当前结点的LOW，这样可以保证每个节点在以其为树根的子树的所有节点中LOW值是最小的。如果回溯时发现当前节点DFN[i]==LOW[i]，就将栈中当前结点以上的节点全部弹栈，这些点就组成了一个强连通分量。还要注意一点是，当目标节点进行过Tarjan但还在栈中，就拿当前节点LOW值与目标节点DFN值比较，把更小的赋给当前结点的LOW。

　　所以总的来说我们在搜索过程中会遇到以下三种节点：从没访问过的节点（固然不在栈中），访问过但不在栈中的节点，访问过但在栈中的节点。对于三种点我们要分开讨论。

　　①对于从没访问过的节点：加入栈中让其DFN[i]=LOW[i]=++dfs_num，让vis[i]=1表示该点入栈了。这类点的标志是!DFN[i]&&!vis[i]。

　　②对于访问过但不在栈中的节点(!vis[i])直接回溯即可，因为既然该节点访问过了又不在栈中，就必定属于另一个强连通分量。这类点的标志是DFN[i]&&!vis[i]。

　　②对于访问过且在栈中的节点，比较当前节点LOW值和目标节点DFN值，将较小的赋给当前结点LOW值然后回溯。这类点的标志是DFN[i]&&vis[i]。

　　在弹栈过程中可以将不同强连通分量染色，方便后续的其他处理（例如缩点，记录不同强连通分量大小等）。

　　Tarjan除了用来求强连通分量，还可以用来缩点、求点双连通分量、求LCA等等。

二、算法模板

复制代码
 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 }

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

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

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

　　先对正图进行一遍dfs，遇到没访问过的点就让其发现时间等于目前的dfs次序号。在回溯时若发现某一结点的子树全部被遍历完，就让其完成时间等于目前dfs次序号。正图遍历完后将节点按完成时间入栈，保证栈顶是完成时间最大的节点，栈底是完成时间最小的节点。

　　（玄学内容开始）然后从栈顶开始向下每一个没有被反向遍历过的节点为起点对逆图进行一遍dfs，将访问到的点记录下来（或染色）并弹栈，每一遍反向dfs遍历到的点就构成一个强连通分量。虽然不知道为什么但他就成强连通分量了…

二、算法模板
复制代码

 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 }

复制代码
三、例题/裸题
codevs1332 上白泽慧音

时间限制: 1 s
空间限制: 128000 KB
题目等级 : 黄金 Gold

题目描述 Description
在幻想乡，上白泽慧音是以知识渊博闻名的老师。春雪异变导致人间之里的很多道路都被大雪堵塞，使有的学生不能顺利地到达慧音所在的村庄。因此慧音决定换一个能够聚集最多人数的村庄作为新的教学地点。人间之里由N个村庄（编号为1..N）和M条道路组成，道路分为两种一种为单向通行的，一种为双向通行的，分别用1和2来标记。如果存在由村庄A到达村庄B的通路，那么我们认为可以从村庄A到达村庄B，记为(A,B)。当(A,B)和(B,A)同时满足时，我们认为A,B是绝对连通的，记为

这里写代码片


复制代码
 1 #include <stdio.h>
 2 #include <algorithm>
 3 using namespace std;
 4 int n,m,cnt,index,dfs_num,CN,maxn=-1;
 5 int pre[50010],vis[50010],DFN[50010],LOW[50010],stack[50010],dye[50010],size[50010];
 6 struct pack{int to,next;} E[50010];
 7 void add_edge(int x,int y){
 8     E[++cnt].to=y;
 9     E[cnt].next=pre[x];
10     pre[x]=cnt;
11 }
12 void input(){
13     scanf("%d%d",&n,&m);
14     for(int i=1;i<=m;i++){
15         int a,b,c;
16         scanf("%d%d%d",&a,&b,&c);
17         add_edge(a,b);
18         if(c==2) add_edge(b,a);
19     }
20 }
21 void tarjan(int pos){
22     vis[stack[++index]=pos]=1;
23     LOW[pos]=DFN[pos]=++dfs_num;
24     for(int i=pre[pos];i;i=E[i].next){
25         if(!DFN[E[i].to]){
26             tarjan(E[i].to);
27             LOW[pos]=min(LOW[pos],LOW[E[i].to]);
28         }
29         else if(vis[E[i].to]) LOW[pos]=min(LOW[pos],DFN[E[i].to]);
30     }
31     if(LOW[pos]==DFN[pos]){
32         vis[pos]=0;
33         size[dye[pos]=++CN]++;
34         while(pos!=stack[index]){
35             vis[stack[index]]=0;
36             size[CN]++;
37             dye[stack[index--]]=CN;
38         }
39         index--;
40     }
41 }
42 void output(){
43     int lenn=0;
44     int tar;
45     for(int i=1;i<=n;i++)
46         if(size[dye[i]]>maxn) maxn=size[dye[i]],tar=i;
47     printf("%d\n",maxn);
48     for(int i=1;i<=n;i++)
49         if(dye[i]==dye[tar]) printf("%d ",i);
50 }
51 int main(){
52     input();
53     for(int i=1;i<=n;i++)
54         if(!dye[i]) tarjan(i);
55     output();
56     return 0;
57 }

复制代码
Korasaju：

复制代码


 1 #include <stdio.h>
 2 #include <algorithm>
 3 #include <cstring>
 4 using namespace std;
 5 int N,M,DFN,CN,tot;
 6 int cnt[3],vis[50010],stack[70010],dye[50010],size[50010];
 7 int pre[3][50010];
 8 struct pack{
 9     int to;
10     int next;
11 }E[3][50010];
12 void add_edge(int x,int y,int f){
13     E[f][++cnt[f]].to=y;
14     E[f][cnt[f]].next=pre[f][x];
15     pre[f][x]=cnt[f];
16 }
17 void positive_dfs(int pos){
18     DFN++;
19     vis[pos]=1;
20     for(int i=pre[1][pos];i;i=E[1][i].next)
21         if(!vis[E[1][i].to])
22             positive_dfs(E[1][i].to);
23     stack[N*2+1-(++DFN)]=pos;
24 }
25 void negative_dfs(int pos){
26     dye[pos]=CN;
27     vis[pos]=0;
28     size[dye[pos]]++;
29     for(int i=pre[2][pos];i;i=E[2][i].next)
30         if(vis[E[2][i].to])
31             negative_dfs(E[2][i].to);
32 }
33 int main(){
34     scanf("%d%d",&N,&M);
35     for(int i=1;i<=M;i++){
36         int a,b,t;
37         scanf("%d%d%d",&a,&b,&t);
38         add_edge(a,b,1);
39         add_edge(b,a,2);
40         if(t==2){
41             add_edge(b,a,1);
42             add_edge(a,b,2);
43         }
44     }
45     for(int i=1;i<=N;i++)
46         if(!vis[i])
47             positive_dfs(i);
48     for(int i=1;i<=N*2;i++)
49         if(stack[i]&&vis[stack[i]]){
50             CN++;
51             negative_dfs(stack[i]);
52         }
53     int maxn=-1,tar;
54     for(int i=1;i<=N;i++)
55         if(size[dye[i]]>maxn) maxn=size[dye[i]],tar=i;
56     printf("%d\n",maxn);
57     for(int i=1;i<=N;i++)
58         if(dye[i]==dye[tar]) printf("%d ",i);
59     return 0;
60 }

复制代码
bzoj1051 受欢迎的牛

Time Limit: 10 Sec Memory Limit: 162 MB
Submit: 3673 Solved: 1940
Description
每一头牛的愿望就是变成一头最受欢迎的牛。现在有N头牛，给你M对整数(A,B)，表示牛A认为牛B受欢迎。这种关系是具有传递性的，如果A认为B受欢迎，B认为C受欢迎，那么牛A也认为牛C受欢迎。你的任务是求出有多少头牛被所有的牛认为是受欢迎的。
Input
第一行两个数N,M。接下来M行，每行两个数A,B，意思是A认为B是受欢迎的（给出的信息有可能重复，即有可能出现多个A,B）
Output
一个数，即有多少头牛被所有的牛认为是受欢迎的。
Sample Input
3 3
1 2
2 1
2 3
Sample Output
1
HINT
100%的数据N<=10000,M<=50000

题解：这道题主要思路是求出强连通分量后将每个强连通分量合并缩成一个节点，然后求出出度为零的节点即可。注意，缩点后只能有一个出度为零的节点，如果有多个答案为0，若没有出度为0的点答案也为0。

由于这道题我只用了Tarjan写，所以只付上Tarjan AC代码。由于我是用染色处理的，所以Korasaju应该也能写。

这里写代码片

 1 #include <stdio.h>
 2 #include <algorithm>
 3 using namespace std;
 4 int n,m,cnt,re_cnt,top,dfs_num,CN;
 5 int pre[50010],re_pre[50010],tow[50010],DFN[50010],LOW[50010],dye[50010],size[50010],vis[50010];
 6 struct pack{int to,next;} E[50010],re_E[50010];
 7 void add_edge(int x,int y){
 8     E[++cnt].to=y;
 9     E[cnt].next=pre[x];
10     pre[x]=cnt;
11 }
12 void tarjan(int pos){
13     vis[tow[++top]=pos]=1;
14     DFN[pos]=LOW[pos]=++dfs_num;
15     for(int i=pre[pos];i;i=E[i].next){
16         if(!DFN[E[i].to]){
17             tarjan(E[i].to);
18             LOW[pos]=min(LOW[pos],LOW[E[i].to]);
19         }
20         else if(vis[E[i].to])
21             LOW[pos]=min(LOW[pos],DFN[E[i].to]);
22     }
23     if(LOW[pos]==DFN[pos]){
24         vis[pos]=0;
25         size[dye[pos]=++CN]++;
26         while(pos!=tow[top]){
27             vis[tow[top]]=0;
28             size[dye[tow[top--]]=CN]++;
29         }
30         top--;
31     }
32 }
33 void rebuild(){
34     for(int i=1;i<=n;++i)
35         for(int j=pre[i];j;j=E[j].next)
36             if(dye[i]!=dye[E[j].to]){
37                 re_E[++re_cnt].next=re_pre[dye[i]];//这里写复杂了，其实光统计出度就够了，不用彻底重建图
38                 re_E[re_cnt].to=dye[E[j].to];
39                 re_pre[dye[i]]=re_cnt;
40             }
41 }
42 int cal(){
43     int ret=0;
44     for(int i=1;i<=CN;++i)
45         if(!re_pre[i]){
46             if(ret) return 0;
47             else ret=size[i];
48         }
49     return ret;
50 }
51 int main(){
52     scanf("%d%d",&n,&m);
53     for(int i=1;i<=m;++i){
54         int a,b;
55         scanf("%d%d",&a,&b);
56         add_edge(a,b);
57     }
58     for(int i=1;i<=n;++i)
59         if(!dye[i]) tarjan(i);
60     rebuild();
61     printf("%d",cal());
62     return 0;
63 }