有向图的强连通分量Kosaraju算法 和 Tarjan算法思维详解及代码模板

有向图的强连通分量 SCC： 在有向图G中，如果两个顶点间相互可达，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通有向图的极大强连通子图，称为强连通分量(strongly connected components)。

如果把每个scc看成一个节点，那么有向图中所有的scc就构成了一个scc图

Kosaraju算法的思想：
在讲解Tarjan算法之前，我们先来了解一下Kasaraju算法的思想。在一个有向图中，我们一定可以找到这样一个合理顺序，使得我们只需要按照这个顺序进行dfs遍历，那么每一次的dfs就可以使我们得到一个scc。

经过简单的分析我们可以知道，那样的一个合理顺序就是scc图的拓扑顺序的逆序。

所以Kosaraju算法的核心思想就是如何找到scc图的拓扑顺序的逆序
Kosaraju算法代码思维详解：
1：对于dfs1（）的作用
有dfs1（）的代码可知，若dfs1（）最初访问的u节点是一颗连通有向图的根节点，则s中存点的顺序是“后序遍历”的顺序，即对于一颗子树而言，子节点一定比其父节点先存入s中，我们大体上可以理解为“深度大的节点先存入s”,所以s的顺序就是拓扑顺序的逆序。

2：对于dfs2（）的作用
因为dfs1（）已经找到了逆序（即那个合理的顺序），所有我们只需按照存入s的先后顺序访问节点，进行遍历即可。
Kosaraju算法代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <stack>
#include <vector>
#include <cstring>
using namespace std;

const int maxn = 10000;
struct Edge
{
    int v,next;
}edges[maxn];

int n,m,e;          //节点数，边数
int head[maxn];
int sccno[maxn];    //节点的强连通分量的编号
int scc_cnt;        //强连通分量的个数
vector<int> s;
int vis[maxn];

void addedges(int u,int v)  //添加边
{
    edges[e].v = v;
    edges[e].next = head[u];
    head[u] = e++;
}

void dfs1(int u)
{
    if(vis[u]) return;
    vis[u] = 1;
    for(int i=head[u];i!=-1;i=edges[i].next) dfs1(edges[i].v);
    s.push_back(u);
}

void dfs2(int u)
{
    if(sccno[u]) return;
    sccno[u] = scc_cnt;
    for(int i=head[u];i!=-1;i=edges[i].next) dfs2(edges[i].v);
}
int main()
{
    freopen("in.txt","r",stdin);
    int u,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        e = 0; scc_cnt = 0;
        memset(head,-1,sizeof(head));
        memset(vis,0,sizeof(vis));
        memset(sccno,0,sizeof(sccno));
        s.clear();
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&u,&v);
            addedges(u,v);
        }
        for(int i=1;i<=n;i++) dfs1(i);
        for(int i=0;i<n;i++) if(!sccno[s[i]])
        {
            scc_cnt++;
            dfs2(s[i]);
        }
        cout<<scc_cnt<<endl;
        for(int i=1;i<=n;i++)
            cout<<i<<" "<<sccno[i]<<endl;
    }
    return 0;
}

看完Kosaraju算法后，Kosaraju算法是靠遍历的顺序将不同的scc分开。而Tarjan算法则可以在一颗DFS树上一次性找出所有的scc

Tarjan算法的思想详解：
考虑某个强连通分量c,设其中第一个被发现大节点为x,则：
1：c中其他节点在DFS树上都是x的后代
我们希望在访问x完成时，立刻输出c.那么问题的关键就是判断一个点是否为某一强连通分量scc中第一个被发现的节点。 经过前面我们所学过的求无向图中的双连通分量，我们可以想到这里依然是利用lowu来实现判断。
我们设lowu表示u节点及其子节点能追溯到的最早的祖先v的pre[v]值，那么
2：当lowu == pre[u] 时，u节点即为某一scc中第一个被发现的节点

注意：这里的追溯只能通过当前scc中的节点，而不能通过已经确定scc编号的节点来追溯。

Tarjan算法：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <stack>
#include <cstring>
using namespace std;

const int maxn = 10000;
struct Edge
{
    int v,next;
}edges[maxn];

int n,m,e;          //节点数，边数
int head[maxn];
int pre[maxn];      //节点的时间戳
int sccno[maxn];    //节点的强连通分量的编号
int scc_cnt;        //强连通分量的个数
int dfs_clock;      //时间戳
stack<int> s;

void addedges(int u,int v)  //添加边
{
    edges[e].v = v;
    edges[e].next = head[u];
    head[u] = e++;
}

int dfs(int u)
{
    int lowu = pre[u] = ++dfs_clock;
    s.push(u);
    for(int i=head[u];i!=-1;i=edges[i].next)
    {
        int v = edges[i].v;
        if(!pre[v])                                 //用为访问的子节点更新
        {
            int lowv = dfs(v);
            lowu = min(lowu,lowv);
        }
        else if(!sccno[v]) lowu = min(lowu,pre[v]); //用访问过的但是没有确定编号的节点更新
    }
    if(lowu == pre[u])                              //找到某个强连通分量的第一个节点
    {
        scc_cnt++;
        for(;;)
        {
            int x = s.top(); s.pop();
            sccno[x] = scc_cnt;
            if(x == u) break;
        }
    }
    return lowu;
}

int main()
{
    freopen("in.txt","r",stdin);
    int u,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        e = 0; dfs_clock = 0; scc_cnt = 0;
        memset(head,-1,sizeof(head));
        memset(pre,0,sizeof(pre));
        memset(sccno,0,sizeof(sccno));
        while(s.size()) s.pop();
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&u,&v);
            addedges(u,v);
        }
        for(int i=1;i<=n;i++)
        {
            if(!pre[i]) dfs(i);
        }
        cout<<scc_cnt<<endl;
        for(int i=1;i<=n;i++)
        {
            cout<<i<<" "<<sccno[i]<<endl;
        }
    }
    return 0;
}