有向图连通分量SCC

在无向图中，如果从顶点vi到顶点vj有路径，则称vi和vj连通。如果图中任意两个顶点之间都连通，则称该图为连通图，否则，称该图为非连通图，则其中的极大连通子图称为连通分量，这里所谓的极大是指子图中包含的顶点个数极大。

直观地说，极大就是不能再大，或者说再大也不能超过自己。因此，极大连通子图就是：
　　设
　　1) S为G的子图，S连通，
　　2) 如果有S'也是G的连通子图，且S是S'的子图，可推出S = S'，
　　则称S是G的极大连通子图。
　　极小连通子图正好相反，极小就是不能再小，再多小一点就会不连通或点不足。因此，极小连通子图就是：
　　设
　　1) S为G的子图，S连通，
　　2) 如果有S'也是G的连通子图，S'包含G的所有顶点，且S'是S的子图，可推出S' = S，
　　则称S是G的级小连通子图。
　　注：这个定义和pinejeely给出的等价。这里给出的定义比较容易验证。

在有向图中，如果对于每一对顶点vi和vj，从vi到vj和从vj到vi都有路径，则称该图为强连通图；否则，将其中的极大强连通子图称为强连通分量。

 

Kosaraju算法：先dfs，得到最后完成时间f，再求反图，按f递减的方向对反图再dfs一次。

 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include <iomanip>
 #include <set>
 #include <map>
 #include <vector>
 #include <queue>
 using namespace std;
 #define N 1000
 int head[N], headt[N], cnt;
 struct node
 {
     int next, to;
 }edge[N * ], edget[N * ];

 void addedge(int from, int to)//G_T
 {
     cnt++;
     edge[cnt].next = head[from];
     edge[cnt].to = to;
     head[from] = cnt;
     //得到反图
     edget[cnt].next = headt[to];
     edget[cnt].to = from;
     headt[to] = cnt;
 }
 int f[N];//finishtime
 int d[N];//discovertime
 int color[N];//init 0 denote white; 1 denote gray discover; 2 denote black finish
 int time;
 int belong[N];//which scc
 int cur;//current scc
 void dfs_visit(int x)
 {
     color[x] = ;
     d[x] = ++time;
     int i, j;
     for (i = head[x]; i; i = edge[i].next)
     {
         j = edge[i].to;
         if (!color[j])
         {
             dfs_visit(j);
         }
     }
     //color[x] = 2;
     f[x] = ++time;
 }

 void dfs_visit_t(int x)
 {
     color[x] = ;
     //d[x] = ++time;
     int i, j;
     for (i = headt[x]; i; i = edget[i].next)
     {
         j = edget[i].to;
         if (!color[j])
         {
             dfs_visit_t(j);
         }
     }
     //color[x] = 2;
     //f[x] = ++time;
     belong[x] = cur;
 }

 bool cmp(const int &a, const int &b)
 {
     return a > b;
 }

 map<int, int, greater<int> > mp;//使用map对f[i]进行从大到小排序
 map<int, int>::iterator it;

 void init()
 {
     cnt = cur = ;
     time = -;
     memset(head, , sizeof(head));
     memset(f, , sizeof(f));
     memset(d, , sizeof(d));
     memset(color, , sizeof(color));
     memset(belong, , sizeof(belong));
     mp.clear();
 }

 int main()
 {
     int n, m, u, v, i;
     while (~scanf("%d%d", &n, &m))
     {
         init();
         for (i = ; i < m; i++)
         {
             scanf("%d%d", &u, &v);
              addedge(u, v);
         }
         for (i = ; i <= n; i++)//得到f
             if (!color[i])
                 dfs_visit(i);
         //sort(f, f + n, cmp);
         for (i = ; i <=n; i++)//对f排序
             mp[f[i]] = i;
         memset(color, , sizeof(color));
         for (it = mp.begin(); it != mp.end(); ++it)//对反图进行dfs
         {
             if (!color[it->second])
             {
                 dfs_visit_t(it->second);
                 cur++;
             }
         }
         for (i = ; i <=n; i++)
             printf("%d ", belong[i]);
     }
     return ;
 }

Tarjan算法只需一次dfs，而且不用求反图，dfs找最早祖先点(最先被发现)也就是寻找B边。

使用LOW函数测试此条件

 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include <iomanip>
 #include <set>
 #include <map>
 #include <vector>
 #include <queue>
 #include <stack>
 #define INF 0x7fffffff
 using namespace std;
 #define N 1000

 stack<int> s;
 int head[N], cnt;
 struct node
 {
     int next, to;
 }edge[N * ];

 void addedge(int from, int to)
 {
     cnt++;
     edge[cnt].next = head[from];
     edge[cnt].to = to;
     head[from] = cnt;
 }
 //int f[N];//finishtime
 int pre[N];//discovertime
 //int color[N];//init 0 denote white; 1 denote gray discover; 2 denote black finish
 int time;
 int id[N];//which scc
 int low[N];//
 int cur;//current scc
 void dfs_visit(int x)
 {
     low[x] = pre[x] = ++time;
     s.push(x);
     int i, j;
     for (i = head[x]; i; i = edge[i].next)
     {
         j = edge[i].to;
         if (!pre[j])
         {
             dfs_visit(j);
         }
         if (low[j] < low[x])//找最小的low[x]，即是否存在后向边(B边)
             low[x] = low[j];
     }
     if (low[x] == pre[x])//找到了一个scc
     {
         do
         {
             i = s.top();
             s.pop();
             low[i] = INF;
             id[i] = cur;
         }while (i != x);
         cur++;
     }
 }

 void init()
 {
     cnt = cur = ;
     time = ;
     memset(head, , sizeof(head));
     memset(pre, , sizeof(pre));
     memset(low, , sizeof(low));
     memset(id, , sizeof(id));
     while (!s.empty())
         s.pop();
 }

 int main()
 {
     int n, m, u, v, i;
     while (~scanf("%d%d", &n, &m))
     {
         init();
         for (i = ; i < m; i++)
         {
             scanf("%d%d", &u, &v);
              addedge(u, v);
         }
         for (i = ; i <= n; i++)
             if (!pre[i])
                 dfs_visit(i);
         for (i = ; i <=n; i++)
             printf("%d ", id[i]);
     }
     return ;
 }

Gabow算法：思路与tarjan思路一样,但是用一个stack替代了low数组，使得交换次数减小

 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include <iomanip>
 #include <set>
 #include <map>
 #include <vector>
 #include <queue>
 #include <stack>
 #define INF 0x7fffffff
 using namespace std;
 #define N 1000

 stack<int> s;
 stack<int> p;
 int head[N], cnt;
 struct node
 {
     int next, to;
 }edge[N * ];

 void addedge(int from, int to)
 {
     cnt++;
     edge[cnt].next = head[from];
     edge[cnt].to = to;
     head[from] = cnt;
 }
 //int f[N];//finishtime
 int pre[N];//discovertime
 //int color[N];//init 0 denote white; 1 denote gray discover; 2 denote black finish
 int time;
 int id[N];//which scc
 int low[N];//
 int cur;//current scc
 void dfs_visit(int x)
 {
     low[x] = pre[x] = ++time;
     s.push(x);
     p.push(x);
     int i, j;
     for (i = head[x]; i; i = edge[i].next)
     {
         j = edge[i].to;
         if (!pre[j])
             dfs_visit(j);
         if (!id[j])//该点未在已求的scc中
             while (pre[j] < pre[p.top()])存在后向边，出栈
                 p.pop();
     }
     if (p.top() == x)//找到一个scc
     {
         p.pop();
         do
         {
             i = s.top();
             id[i] = cur;
             s.pop();
         }while (i != x);
         cur++;
     }
 }

 void init()
 {
     cnt = cur = ;
     time = ;
     memset(head, , sizeof(head));
     memset(pre, , sizeof(pre));
     memset(low, , sizeof(low));
     memset(id, , sizeof(id));
     while (!s.empty())
         s.pop();
     while (!p.empty())
         p.pop();
 }

 int main()
 {
     int n, m, u, v, i;
     while (~scanf("%d%d", &n, &m))
     {
         init();
         for (i = ; i < m; i++)
         {
             scanf("%d%d", &u, &v);
              addedge(u, v);
         }
         for (i = ; i <= n; i++)
             if (!pre[i])
                 dfs_visit(i);
         for (i = ; i <=n; i++)
             printf("%d ", id[i]);
     }
     return ;
 }