（转）求有向图的强连通分量个数（kosaraju算法）

有向图的连通分量的求解思路

kosaraju算法

逛了很多博客，感觉都很难懂，终于找到一篇能看懂的，摘要记录一下

原博客https://www.cnblogs.com/nullzx/p/6437926.html

关于连通分量是什么自行百度，这里主要说明连通分量的求解方法

基本思路：第一次DFS得出顶点的顺序，根据顶点顺序进行第二次DFS，也就是逆后序遍历（手动模拟一下堆栈就知道第二次DFS的过程就能得出答案）。

为什么要两次DFS?

如果从连通分量A中任意一个定点DFS，得不到正确结果。应该按照被指向的强连通分量的定点排在前面的顺序进行DFS。上图按照B3，B4，B5，A0，A1，A2的顺序DFS。实际中我们只要保证被指向的强连通分量的至少一个顶点排在指向这个连通分量的所有顶点前面即可，比如B3，A0，A1，A2，B4，B5；B3排在强连通分量A所有定点的前面。

如何得到满足要求的顶点顺序：对原图取反，从反向图的任意节点开始进行DFS的逆后序遍历

DFS的逆后序遍历指：如果当前顶点没被访问，先遍历完与当前顶点相连的且未被访问的所有其他顶点，然后将当前顶点加入栈，最后从栈顶到栈底的顺序是我们需要的顶点顺序。

其实它是利用了有向图的方向性：例如在上图中，强连通分量A和B不管正反图都能自己跑一圈，但是从A到B就只能从A2跑到B3，不可能从B3跑到A2，所以将图取反（注意图取反，不能从A2跑到B3，顶点顺序被记录，按顶点顺序一个个弹出遍历，之前遍历过的点就不用再遍历），做成反向图，再逆后序遍历，A0在栈顶，遍历一圈，不能从A2跑到B3，就得到一个连通分量（如下图）

接下来原博主的代码看不懂，还是百度百科kosaraju算法里面的代码好

 #include <iostream>
 #include <cstring>
 #include <cmath>
 #include <cstdio>
 #include <stack>
 #include <algorithm>
 using namespace std;
 #define INF 999999999
 #define MAXN 551
 #define MOD 1000000009
 int n;
 int mp[MAXN][MAXN], nmp[MAXN][MAXN], vis[MAXN];
 stack<int> s;
 void dfs_1(int v)
 {
 //    cout << v <<endl;
     vis[v] = ;
     for(int i = ; i <= n; ++i)
         if(!vis[i] && mp[v][i])
         dfs_1(i);
     s.push(v);
 }
 void dfs_2(int v)
 {
     vis[v] = ;
     for(int i = ; i <= n; ++i)
         if(!vis[i] && nmp[v][i])
         dfs_2(i);
 }
 int kosaraju()
 {
     while(!s.empty())
         s.pop();
     memset(vis, , sizeof(vis));

     for(int i = ; i <= n; ++i)
         if(!vis[i])
         dfs_1(i);

     int ans=;
     memset(vis, , sizeof(vis));

     while(!s.empty())
     {
         int v = s.top();
         s.pop();
         if(!vis[v])
         {
 //            cout << v <<endl;
             ans++;
             dfs_2(v);
         }
     }
     return ans;
 }
 int main()
 {
     int m, a, b;
     //n个点，m条边
     cin >> n >>m;
     memset(mp, , sizeof(mp));
     memset(nmp, , sizeof(nmp));
     for(int i = ; i < m; ++i)
     {
         cin >> a >>b;
         mp[a][b] = ;
         nmp[b][a] = ;
     }
     cout << kosaraju() <<endl;
     return ;
 }
 /*
 5 5
 1 2
 2 1
 2 3
 3 4
 4 1
 样例输出：
 2
 */
  

tarjan算法

这个算法网上很容易找到详解，其实认真看一遍百度百科也就懂得七七八八了

再附详解地址，这位博主也是转别人的，但是那个别人的博客打不开了

https://blog.csdn.net/qq_34374664/article/details/77488976

这个算法的核心思想：将连通分量的各个点用一个点表示。

 #include <iostream>
 #include <cstring>
 #include <cmath>
 #include <cstdio>
 #include <stack>
 #include <algorithm>

 using namespace std;

 #define INF 0x3f3f3f3f
 #define MAXN 551

 int DFN[MAXN], Low[MAXN];
 int vis[MAXN], sta_ck[MAXN];
 int Index, cnt, tot;
 int n;

 struct Node
 {
     int to;
     int next;
 }node[MAXN];
 int head[MAXN];

 //用head作为头指针指向下一个结点下标，让next指向head指向的下标后，head指向该结点
 void add(int x, int y)
 {
     node[++cnt].next = head[x];
     node[cnt].to = y;
     head[x] = cnt;
 }

 void tarjan(int x)
 {
     DFN[x] = Low[x] = ++tot;
     sta_ck[++Index] = x;
     vis[x] = ;
     for(int i = head[x]; i != -; i = node[i].next)
     {
         if(!DFN[node[i].to])
         {
             tarjan(node[i].to);
             Low[x] = min(Low[x], Low[node[i].to]);
         }
         else if(vis[node[i].to])
             Low[x] = min(Low[x], DFN[node[i].to]);
     }
     if(Low[x] == DFN[x])
     {
         do
         {
             cout << sta_ck[Index] <<" ";
             vis[sta_ck[Index]]=;
             Index--;
         }while(x != sta_ck[Index + ]);
         cout << endl;
     }

 }

 int main()
 {
     memset(head, -, sizeof(head));
     memset(DFN, , sizeof(DFN));
     memset(Low, , sizeof(Low));
     int n, m;
     cin >>n >>m;
     int x, y;
     for(int i = ; i <= m; ++i)
     {
         cin >>x >>y;
         add(x, y);
     }
     for(int i = ; i <= n; ++i)
         if(!DFN[i])
         tarjan(i);
     return ;
 }