【有向图的强连通分】HDUOJ 1269 迷宫城堡(Kosaraju算法+Tarjan算法)

首先来看几个概念:     

在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。

如果有向图G的每两个顶点都强连通，称G是一个强连通图。

非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。

任意有向图都可以分解成若干不想交的强连通分量,这就是强连通量的分解.把分解后的强连通分量缩成一个顶点,就得到了一个DAG(有向无环图).

参考博客:http://blog.csdn.net/justlovetao/article/details/6673602

Tarjan算法

其实，tarjan算法的基础是DFS。我们准备两个数组Low和Dfn。Low数组是一个标记数组，记录该点所在的强连通子图所在搜索子树的根节点的Dfn值（很绕嘴，往下看你就会明白），Dfn数组记录搜索到该点的时间，也就是第几个搜索这个点的。根据以下几条规则，经过搜索遍历该图（无需回溯）和对栈的操作，我们就可以得到该有向图的强连通分量。 

1、数组的初始化：当首次搜索到点p时，Dfn与Low数组的值都为到该点的时间。

2、堆栈：每搜索到一个点，将它压入栈顶。

3、当点p有与点p’相连时，如果此时（时间为dfn[p]时）p’不在栈中，p的low值为两点的low值中较小的一个。

4、当点p有与点p’相连时，如果此时（时间为dfn[p]时）p’在栈中，p的low值为p的low值和p’的dfn值中较小的一个。

5、每当搜索到一个点经过以上操作后（也就是子树已经全部遍历）的low值等于dfn值，则将它以及在它之上的元素弹出栈。这些出栈的元素组成一个强连通分量。

6、继续搜索（或许会更换搜索的起点，因为整个有向图可能分为两个不连通的部分），直到所有点被遍历。

      由于每个顶点只访问过一次，每条边也只访问过一次，我们就可以在O（n+m）的时间内求出有向图的强连通分量。但是，这么做的原因是什么呢？

 

      Tarjan算法的操作原理如下：

1、Tarjan算法基于定理：在任何深度优先搜索中，同一强连通分量内的所有顶点均在同一棵深度优先搜索树中。也就是说，强连通分量一定是有向图的某个深搜树子树。

2、可以证明，当一个点既是强连通子图Ⅰ中的点，又是强连通子图Ⅱ中的点，则它是强连通子图Ⅰ∪Ⅱ中的点。

3、这样，我们用low值记录该点所在强连通子图对应的搜索子树的根节点的Dfn值。注意，该子树中的元素在栈中一定是相邻的，且根节点在栈中一定位于所有子树元素的最下方。

4、强连通分量是由若干个环组成的。所以，当有环形成时（也就是搜索的下一个点已在栈中），我们将这一条路径的low值统一，即这条路径上的点属于同一个强连通分量。

5、如果遍历完整个搜索树后某个点的dfn值等于low值，则它是该搜索子树的根。这时，它以上（包括它自己）一直到栈顶的所有元素组成一个强连通分量。

Kosaraju算法

算法步骤
调用DFS(G), 计算出每个结点的f[u]
计算GT
调用DFS(GT), 在主循环中按照f[u]递减的顺序执行DFS-VISIT, 则得到的每个DFS树恰好对应于一个SCC
运行时间：O(n+m)                            

SCC的f性质

当按照f值排序以后, 第二次DFS是按照SCC的拓扑顺序进行(以后所指d[u]和f[u]都是第一次DFS所得到的值)
记d(C)和f(C)分别表示集合C所有元素的最早发现时间和最晚完成时间, 有如下定理:
定理: 对于两个SCC C和C’, 如果C到C’有边, 则f(C)>f(C’)
情况一: d(C) < d(C’), 考虑C中第一个被发现的点x, 则C’全为白色, 而C到C’有边, 故x到C’中每个点都有白色路径. 这样, C和C’全是x的后代, 因此f(C) > f(C’)
情况二: d(C) > d(C’). 由于从C’不可到达C, 因此必须等C’全部访问完毕才能访问C. 因此f(C) > f(C’)
推论:对于两个SCC C和C’, 如果在GT中C到C’有边, 则f(C)

Kosaraju算法的正确性
首先考虑f(C)最大的强连通分量. 显然, 此次DFS将访问C的所有点, 问题是是否可能访问其他连通分量的点? 答案是否定的, 因为根据推论, 如果在GT中C到另外某个C’存在边, 一定有f(C).

以HDU1269为例来看这两种算法的代码,具体解释见注释.

/*有向图强连通分量*///Tarjan算法
const int maxn=200010;//点的个数
const int maxm=500010;//边的个数
struct edge
{
    int to,next;
}eg[Maxm];
int head[Maxn],tot;
int low[Maxn],dfn[Maxn],Stack[Maxn],Belong[Maxn];
/*
Belong[Maxn]各顶点属于哪个强连通分量
Instack[Maxn]标记是否在stack中
dfn[Maxn]节点u搜索的序号(时间戳)
low[Maxn]u或u的子树能够追溯到的最早的栈中节点的序号(时间戳)
Index序号(时间戳)
scc强连通分量的个数
*/
int Index,top,scc;
bool Instack[Maxn];
int num[Maxn];//各个强连通分量包含点的个数，数组编号1~scc,num数组不一定需要，结合实际情况
void addedge(int u,int v)
{
    eg[tot].to=v;
    eg[tot].next=head[u];
    head[u]=tot++;
}
void Tarjan(int u)
{
    int v;
    low[u]=dfn[u]=++Index;
    Stack[top++]=u;
    Instack[u]=true;
    for(int i=head[u];i!=-1;i=eg[i].next)
    {
        int v=eg[i].to;
        //cout<<u<<"*"<<v<<" ";
        if(!dfn[v])
        {
            Tarjan(v);
                low[u]=min(low[u],low[v]);
        }
        else if(Instack[v])
            low[u]=min(dfn[v],low[u]);
    }
    if(low[u]==dfn[u])
    {
        scc++;
        do
        {
            v=Stack[--top];
            Instack[v]=false;
            Belong[v]=scc;
        }
        while(v!=u);
    }
}
void solve(int N)
{
    memset(dfn,0,sizeof(dfn));
    memset(Instack,0,sizeof(dfn));
    Index=scc=top=0;
    for(int i=1;i<=N;i++)
    {
        if(dfn[i]==0)
            Tarjan(i);
    }
}
void init()
{
    tot=0;
    memset(head,-1,sizeof(head));
}
int main()
{
   int n,m;
   while(~scanf("%d%d",&n,&m))
   {
       init();
       if(n==0&&m==0)
        break;
        int u,v;
       for(int i=0;i<m;i++)
       {
           scanf("%d%d",&u,&v);
           addedge(u,v);
       }
       solve(n);
//       for(int i=1;i<=n;i++)
          //printf("%d*%d ",Belong[i],num[i]);
       //cout<<scc<<endl;
       if(scc==1)
        printf("Yes\n");
       else
        printf("No\n");
   }
}

const int maxn=200010;//点的个数
const int maxm=500010;//边的个数
int low[maxn],dfn[maxn];
vector<int>G[maxn];
int sccno[maxn];
int scc,Index;
stack<int>s;
void dfs(int u)
{
    dfn[u]=low[u]=++Index;
    s.push(u);
    for(int i=0;i<G[u].size();i++)
    {
        int v=G[u][i];
        if(!dfn[v])
        {
            dfs(v);
            low[u]=min(low[v],low[u]);
        }
        else if(!sccno[v])
            low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u])
    {
        scc++;
        for(;;)
        {
            int x=s.top();
            s.pop();
            sccno[x]=scc;
            if(x==u)
                break;
        }
    }
}
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        scc=Index=0;
        if(n==0&&m==0)
            break;
        memset(dfn,0,sizeof(dfn));
        memset(sccno,0,sizeof(sccno));
        memset(low,0,sizeof(low));
        for(int i=0;i<=n;i++)
            G[i].clear();
        while(!s.empty())
            s.pop();
        int u,v;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
        }
        for(int i=1;i<=n;i++)
        {
            if(!dfn[i])
                dfs(i);
        }
//        cout<<scc<<"*********"<<endl;
//        for(int i=0;i<=n;i++)
//            cout<<sccno[i]<<"***"<<endl;
        if(scc==1)
            printf("Yes\n");
        else
            printf("No\n");
    }
}

Kosaraju算法:

/*有向图强连通分量*/
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<math.h>
#include<queue>
#include<map>
#include<set>
#include<stack>
#include<stdlib.h>
using namespace std;
typedef long long LL;
const int maxn=200010;//点的个数
const int maxm=500010;//边的个数
vector<int>G[maxn],G2[maxn];
vector<int>s;
int vis[maxn],sccno[maxn],scc;
void dfs1(int u)//第一次dfs,为逆序遍历排序
{
    if(vis[u])
        return;
    vis[u]=1;
    for(int i=0;i<G[u].size();i++)
    {
        int v=G[u][i];
        dfs1(v);
    }
    s.push_back(u);
}
void dfs2(int u)//第二次dfs
{
    if(sccno[u])
        return;
    sccno[u]=scc;//每个点属于哪一个强连通分量
    for(int i=0;i<G2[u].size();i++)
    {
        dfs2(G2[u][i]);
    }
}
void find_scc(int n)
{
    scc=0;
    s.clear();
    memset(sccno,0,sizeof(sccno));
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)
        dfs1(i);
    for(int i=s.size()-1;i>=0;i--)
    {
        if(!sccno[s[i]])
        {
            scc++;//强连通分量的个数
            dfs2(s[i]);
        }
    }
}
int main()
{
    int n,m,u,v;
    while(~scanf("%d%d",&n,&m))
    {
        if(n==0&&m==0)
            break;
        for(int i=0;i<=n;i++)
        {
            G[i].clear();
            G2[i].clear();
        }
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&u,&v);
            G[u].push_back(v);//图的邻接表表示
            G2[v].push_back(u);//反向后的图
        }
        find_scc(n);
//        for(int i=0;i<=n;i++)
//            cout<<sccno[i]<<" "<<endl;
//        printf("%d****",scc);
         if(scc==1)
            printf("Yes\n");
         else
            printf("No\n");
    }
}

struct edge
{
    int to,next;
}eg1[maxm],eg2[maxm];
int head1[maxn],head2[maxn];
bool mark1[maxn],mark2[maxn];
int tot1,tot2,cnt1,cnt2;
int st[maxn];//对原图进行dfs，点的结束时间从小到大排序
int Belong[maxn];//每个点属于哪个连通分量0~cnt2-1
int num;//中间变量,用来数某个连通分量中点的个数
int setnum[maxn];//强连通分量中点的个数,编号(0~cnt2-1)
void addedge(int u,int v)
{
    eg1[tot1].to=v;
    eg1[tot1].next=head1[u];
    head1[u]=tot1++;
    eg2[tot2].to=u;
    eg2[tot2].next=head2[v];
    head2[v]=tot2++;
}
void dfs1(int u)
{
    mark1[u]=true;
    for(int i=head1[u];i!=-1;i=eg1[i].next)
    {
        int v=eg1[i].to;
        if(mark1[v]==0)
            dfs1(v);
    }
    st[cnt1++]=u;
}
void dfs2(int u)
{
    mark2[u]=true;
    num++;
    Belong[u]=cnt2;
    for(int i=head2[u];i!=-1;i=eg2[i].next)
    {
        int v=eg2[i].to;
        if(!mark2[v])
            dfs2(v);
    }
}
void solve(int n)
{
    memset(mark1,false,sizeof(mark1));
    memset(mark2,false,sizeof(mark2));
    cnt1=cnt2=0;
    for(int i=1;i<=n;i++)
    {
        if(!mark1[i])
            dfs1(i);
    }
    for(int i=cnt1-1;i>=0;i--)
    {
        if(!mark2[st[i]])
        {
            num=0;
            dfs2(st[i]);
            setnum[cnt2++]=num;
        }
    }
}
int main()
{
   int n,m;
   while(~scanf("%d%d",&n,&m))
   {
       memset(st,0,sizeof(st));
       memset(setnum,0,sizeof(setnum));
       memset(Belong,0,sizeof(Belong));
       memset(head1,-1,sizeof(head1));
       memset(head2,-1,sizeof(head2));
       if(n==0&&m==0)
        break;
        int u,v;
       for(int i=0;i<m;i++)
       {
           scanf("%d%d",&u,&v);
           addedge(u,v);
       }
       solve(n);
//       int ans=0;
//       for(int i=0;i<=n;i++)
//       {
           if(Belong[i]==1)
            ans++;
//           printf("%d*%d ",Belong[i],setnum[i]);
//       }
       //cout<<cnt2<<"***"<<endl;
       if(setnum[0]==n)
        printf("Yes\n");
       else
        printf("No\n");
   }
}