首先来看几个概念:
在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。
如果有向图G的每两个顶点都强连通，称G是一个强连通图。
非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。
任意有向图都可以分解成若干不想交的强连通分量,这就是强连通量的分解.把分解后的强连通分量缩成一个顶点,就得到了一个DAG(有向无环图).
参考博客:http://blog.youkuaiyun.com/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)
首先考虑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");
}
}
扫一扫
6643
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
