有向图强连通分量（Kosaraju算法）+POJ 2762解题报告

Kosaraju_Algorithm:

 step1：对原图G进行深度优先遍历，记录每个节点的离开时间。

 step2：选择具有最晚离开时间的顶点，对反图GT进行遍历，删除能够遍历到的顶点，这些顶点构成一个强连通分量。

 step3：如果还有顶点没有删除，继续step2，否则算法结束。

这算法我不会证明其正确性，具体可以参见严蔚敏的《数据结构C语言版》和《算法导论》，里面都有证明。

下面给出C++代码

void dfs1(int u)//正向图DFS
{
    vis[u] = 1;
    for(int i = 0 ; i < g[u].size() ; i ++)
        if(!vis[g[u][i]]) dfs1(g[u][i]);
    ord.push_back(u);
}

void dfs2(int u)//反向图DFS
{
    belong[u] = cnt;//标记该节点u属于哪个连通分量
    vis[u] = 1;
    for(int i = 0 ; i < gt[u].size() ; i ++)
        if(!vis[gt[u][i]]) dfs2(gt[u][i]);
}

void kosaraju()
{
    memset(vis,0,sizeof(vis));
    ord.clear();
    for(int i = 1 ; i <= n ; i ++)
        if(!vis[i]) dfs1(i);
    cnt = 0;
    memset(vis,0,sizeof(vis));
    for(int i = ord.size() - 1 ; i >= 0 ; i --)
        if(!vis[ord[i]])
        {
            cnt++;
            dfs2(ord[i]);
        }
}

通过上面的代码我们能够发现，原来的图其实已经被缩点了，每个强连通分量被缩成了一个点，我们现在结合原图g就能够求出缩点之后的图mat，具体代码如下

 for(int i = 1 ; i <= n ; i ++)
    {
        for(int j = 0 ; j < g[i].size() ; j ++)
        {
            int u = i, v = g[i][j];
            if(belong[u] != belong[v])
            {
                mat[belong[u]].push_back(belong[v]);
                in[belong[v]] ++;
                out[belong[u]] ++;
            }
        }
    }

其中in[],out[]分别表示入度和出度。

算法导论里面又提出了一个问题：半连通分量，就是说对原图g，如果对所有顶点对（u，v），都有u->v，或者v->u。

大家可以思考下这个问题怎么解决？

这里的解决思路是：首先求出原图G的强连通分量并且缩点，求出缩点后的图mat，并且求出缩点后所有顶点的入度in[]和出度out[]。

这时我们思考下，如果原图G要是半连通的，那么缩点后的图mat必须要连通，这是基础的前提，不然原图都是不连通的，这时只要判断mat中顶点是否只有一个入度为0的点，否则图G不是半连通的。此外，mat就是一棵树，入度为0的顶点就是根，如果这个树不是一条链，那么图G也不是半连通的，不是链就说明有分叉，两个分叉之间是不能到达的，那么如何判断是否有分叉呢？答案是拓扑排序，如果排序到某个节点后，剩下的顺序不能确定，就说明出现了分叉。

POJ 2762就是个半连通分量的题。

vector<int>g[N],gt[N],ord,mat[N];//g[]原图,gt[]反向图,mat[]缩点后的图
int n,m,cnt;
int vis[N],belong[N],in[N],out[N];

void dfs1(int u)
{
    vis[u] = 1;
    for(int i = 0 ; i < g[u].size() ; i ++)
        if(!vis[g[u][i]]) dfs1(g[u][i]);
    ord.push_back(u);
}

void dfs2(int u)
{
    belong[u] = cnt;//属于哪个连通分量
    vis[u] = 1;
    for(int i = 0 ; i < gt[u].size() ; i ++)
        if(!vis[gt[u][i]]) dfs2(gt[u][i]);
}

void kosaraju()
{
    memset(vis,0,sizeof(vis));
    ord.clear();
    for(int i = 1 ; i <= n ; i ++)
        if(!vis[i]) dfs1(i);
    cnt = 0;
    memset(vis,0,sizeof(vis));
    for(int i = ord.size() - 1 ; i >= 0 ; i --)
        if(!vis[ord[i]])
        {
            cnt++;
            dfs2(ord[i]);
        }
}

void solve()
{
    for(int i = 1 ; i <= n ; i ++)//缩点图
    {
        for(int j = 0 ; j < g[i].size() ; j ++)
        {
            int u = i, v = g[i][j];
            if(belong[u] != belong[v])
            {
                mat[belong[u]].push_back(belong[v]);
                out[belong[u]] ++;
                in[belong[v]] ++;
            }
        }
    }
    int res = 0,pos ;
    for(int i = 1 ; i <= cnt ;  i++)
        if(in[i] == 0) res ++;
    if(res > 1) puts("No");//只有一个入度为0的点，说明缩点后的图不是连通图
    else
    {
        int ans = 0;
        while(1)
        {
            res = 0;
            for(int i = 1 ; i <= cnt ; i ++)
            {
                if(in[i] == 0) res ++,pos = i;
            }
            if(res > 1 || res == 0) break;
            in[pos] = -1;
            ans ++;
            for(int i = 0 ; i < mat[pos].size() ; i ++)
                in[mat[pos][i]] --;
        }
        if(ans == cnt) puts("Yes");
        else puts("No");
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d %d",&n,&m);
        for(int i = 1 ; i <= n ; i ++)
        {
            g[i].clear();
            gt[i].clear();
            mat[i].clear();
            in[i] = out[i] = 0;
        }
        while(m--)
        {
            int u,v;
            scanf("%d %d",&u,&v);
            g[u].push_back(v);
            gt[v].push_back(u);
        }
        kosaraju();
        solve();
    }
    return 0;
}