【有向图的强连通分】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-1int 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");   }}