ACM图论__有向图的强连通分支算法

求有向图的强连通分支，主要有两种算法tarjan算法和kosaraju算法，这里介绍tarjan算法

先来看几个定义：

（1）连通：两个点可以相互到达

（2）强连通(strongly connected)： 在一个有向图G里，设两个点 a b 发现，由a有一条路可以走到b，由b又有一条路可以走到a，我们就叫这两个顶点（a，b）强连通。

（3）强连通分量strongly connected components)：在一个有向图G中，有一个子图，这个子图每2个点都满足强连通，我们就叫这个子图叫做 强连通分量 ［分量：：把一个向量分解成几个方向的向量的和，那些方向上的向量就叫做该向量（未分解前的向量）的分量］

算法思路：

定义一个低位数，一个DFN数，根据两个数之间的关系来判断

低位数：DFS过程中可以回到的最小的DFN数

DFN数：DFS过程中的时间戳（也就是先遍历的标1，接着2,3...）

遍历，入栈，直到这条路径走完，此时，DFN数==低位数的点，是强连通分量的起点，在它后面的都属于这个强连通分量

下面给出代码：

#include<algorithm>
#include<string.h>
#include <stack>
#include <iostream>
using namespace std;
int DFN[100],low[100],index=0,e[100][100],n,top,tol=0;
int Stack[100],instack[100];//用Stack来模拟栈，用instack来判断点是否在栈内
void tarjan(int x)
{
    int i,j;
    index++;
    DFN[x]=low[x]=index; //c初始化低位数和时间戳
    Stack[top++]=x;//入栈
    instack[x]=true;
    for(i=1;i<=n;i++)
    {
        if(e[x][i]==1)
        {
            if(DFN[i]==0)
            {
                tarjan(i);
                low[x]=min(low[x],low[i]);//取最小的为低位数
            }
            else if(instack[x]==1)
            {
                low[x]=min(low[x],DFN[i]);
            }
        }
    }
    if(low[x]==DFN[x])
    {
        int ans=0;
        while(x!=Stack[top]) //必须将只含一个点的除去
        {
            top--;
            ans++;
        }
        if(ans>1)
        {
            top+=ans;
            tol++;
            cout<<"强连通分支"<<tol<<":  ";
            int v;
            do
            {
                v=Stack[--top];
                if(low[v]==low[x]) //输出时必须进行判断
                {
                    cout<<v<<',';
                }
                instack[v]=0;
            }
           while(x!=Stack[top]);
           cout<<endl;
        }




    }
}
int main()
{
    int i,x,y,m;
    memset(e,0,sizeof(e));
    cin>>n>>m;
    for(i=1;i<=m;i++)
    {
        cin>>x>>y;
        e[x][y]=1;
    }
    top=0;
    memset(instack,0,sizeof(instack));
    memset(DFN,0,sizeof(DFN));
    for(i=1;i<=n;i++)
    {
        if(DFN[i]==0)
            tarjan(i);
    }
    return 0;
}

下面介绍kosaralu算法

kosaralu算法主要利用逆序遍历结合正序遍历的思想，得出强连通分支个数：

kosaralu算法原理及其证明：有向图中相互连通的点，对图进行求反操作后，这两个点依然连通。简而言之，原图与逆图具有相同的连通分支。

证明过程：

1.如果两个结点处于同一强连通支中，那么在它们之间不存在离开该连通支的通路。

2.在任何深度优先搜索中，同一强连通支内的所有顶点均在同一棵深度优先树中

3.在强连通支内的所有结点中，设r第一个被发现。因为r是第一个被发现，所以发现r时强连通支内的其他结点都为白色。在强连通支内从r到每一其他结点均有通路，因为这些通路都没有离开该强连通支(据引理1)，所以其上所有结点均为白色。因此根据白色路径定理，在深度优先树中，强连通支内的每一个结点都是结点r的后裔。

先逆序遍历，将逆序逆序遍历的点压入栈中，接着一次从栈中读取元素，进行正序DFS即可得出结论

下面给出代码：

#include<cstdio>
#include<algorithm>
#include<string.h>
#include <stack>
#include <iostream>
using namespace std;
int e[100][100],F[100][100],cn=0;
bool visit[100];
int n,m;
stack<int> S;
void DFS1(int x)//逆序遍历
{
    visit[x]=true;
    for(int i=1;i<=n;i++)
    {
        if(F[x][i]==1)
        {
            if(visit[i]==0)
            {
                DFS1(i);
            }
        }
    }
    S.push(x);//遍历起点入栈
}
void DFS2(int u)//正序DFS
{
    visit[u]=true;
    for(int i=1;i<=n;i++)
    {
        if(e[u][i]==1)
        {
            if(visit[i]==0)
            {
                DFS2(i);
            }
        }
    }
}
int main()
{
    int x,y,i,j;
    cin>>n>>m;
    memset(e,0,sizeof(e));
    memset(F,0,sizeof(F));
    for(i=1;i<=m;i++)
    {
        cin>>x>>y;
        e[x][y]=1;
        F[y][x]=1;
    }
    memset(visit,false,sizeof(visit));
    for(i=1;i<=n;i++)
    {
        if(visit[i]==0)
        {
            DFS1(i);
        }
    }
    memset(visit,false,sizeof(visit));
    int v;
    while(S.empty()==0)
    {
        v=S.top();
        S.pop();
        if(visit[v]==0)
        {
           DFS2(v);//每次DFS得到一个强连通分支
           cn++;
        }
    }
    cout<<cn<<endl;
    return 0;
}

转载请注明出处