求有向图的强连通分支,主要有两种算法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;
}
转载请注明出处