Hdu 1296（强连通分量+Tarjan算法和Kosaraju算法）

Hdu 1296

 

1、题意：

就是判断这张图有向图是不是强连通图。

 

2、Kosaraju算法

（一）算法流程：

（1）建立深搜树，依次记录每个点（相当于给每个点编号）；

（2）反向建立边

（3）从后向前深搜未标记的点，如果一次能将所有点全搜遍，就说明这个图是强连通图。

（二）算法的思想：

利用强连通图的性质，强连通图的任意两点都能到达，

如果这张图是强连通图，那么这张图的反向图也是强连通图，

我们先正项深搜，得到依次深搜的每个点（这些点是有序的），也就是说，如果是强连通图的话，

那么这张图的逆图（边反向的图）也能逆着将所有点遍历完，如果要cnt次才能遍历完，说明这个图有cnt个连通分量。

（三）代码实现：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<utility>
#include<vector>
using namespace std;
const int maxn = 1e5+10;
int vis[maxn],head[maxn],n,tt,tot,m,d[maxn];
struct Node{
	int v,nxt;
}cur[maxn];
vector <pair <int,int> > vc;
void Init(){
	memset(head,-1,sizeof(head));
	tot = 0;
}
void Add(int x,int y){
	cur[tot].v = y;
	cur[tot].nxt = head[x];
	head[x] = tot++;
}
void dfs1(int x){
	vis[x] = 1;
	for(int i=head[x];i!=-1;i=cur[i].nxt){
		int y = cur[i].v;
		if(!vis[y]){
			dfs1(y);
		}
	}
	d[tt++] = x;
}
void dfs2(int x){
	vis[x] = 1;
	for(int i=head[x];i!=-1;i=cur[i].nxt){
		int y = cur[i].v;
		if(!vis[y]){
			dfs2(y);
		}
	}
}
int main(void){
	while(~scanf("%d%d",&n,&m)&&(n+m)){
		vc.clear();
		Init();
		for(int i=0;i<m;i++){
			int x,y;
			scanf("%d%d",&x,&y);
			vc.push_back(make_pair(y,x));
			Add(x,y);
		}
		
		tt = 0;
		memset(vis,0,sizeof(vis));
		for(int i=1;i<=n;i++)
		if(vis[i]==0){
			dfs1(i);
		}
		
		Init();
		for(int i=0;i<m;i++){
			pair <int,int> tp = vc[i];
			Add(tp.first,tp.second);
		}
		int fg = 0,cnt = 0;
		memset(vis,0,sizeof(vis));
		for(int i=tt-1;i>=0;i--)
		if(vis[d[i]]==0){
			dfs2(d[i]);
			cnt++;
			if(cnt>1){
				fg = 1;break;
			}
		}
		if(fg) printf("No\n");
		else printf("Yes\n");
	}
	return 0;
}

 

3、Tarjan算法

（一）算法流程：

设定

dfn数组：表示dfs访问的次序；

low数组：表示节点x最多能回溯到栈中的最早节点的dfn的值（就是相当于节点x在dfs过程中的根，

因为有回溯的过程，所以在同一个栈中的元素都是可以相互到达的，所以，这些元素组成的就是一个强连通分量）、

st栈：记录每次到达的节点，用来判断一个强连通分量重最多由几个元素。

fa数组：将统一强连通分量中的节点做上相同的标记。

low数组的更新：

//y是x的子节点

①low[x] = min(low[y],low[x]);

②当y不在栈中时：low[x] = min(low[x],dfn[y]);

（2）算法的思想：
利用深搜的思想，在深搜时记录依次每个节点，将每个节点存入栈内，

在回溯时判断能够到达的节点，在找到这些节点的祖先时（就是low[x]==dfn[x]），

将栈中的节点标记为同一个强连通分量。

（3）代码实现：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn = 1e5+10;
int head[maxn],st[maxn],tot,top,tt,fa[maxn];
int n,m,dfn[maxn],low[maxn],vis[maxn],col;
struct Node{
	int v,nxt;
}cur[maxn];
void Init(){
	memset(head,-1,sizeof(head));
	tot = 0;
}
void Add(int x,int y){
	cur[tot].v = y;
	cur[tot].nxt = head[x];
	head[x] = tot++;
}
void Tarjan(int x){
	vis[x] = 1;
	dfn[x] = low[x] = ++tt;
	st[top++] = x; //元素入栈 
	for(int i=head[x];i!=-1;i=cur[i].nxt){
		int y = cur[i].v;
		if(!vis[y]){ //未标记的元素 
			Tarjan(y);
			low[x] = min(low[x],low[y]); //更新求出low[x] 
		}
		else if(!fa[y])//y与x不在同一个栈中 
		low[x] = min(low[x],dfn[y]); 
	}
	if(low[x]==dfn[x]){ //找到根源节点 
		fa[x] = ++col;
		while(st[top]!=x){
			fa[st[top]] = col;
			top--;
		}
		top--;
	}
}
int main(void){
	while(~scanf("%d%d",&n,&m)&&(n+m)){
		Init();
		for(int i=1;i<=m;i++){
			int x,y;
			scanf("%d%d",&x,&y);
			Add(x,y);
		}
		memset(vis,0,sizeof(vis));
		memset(fa,0,sizeof(fa));
		top = 0;col = 0;tt = 0;
		Tarjan(1);
		int cnt = 0;
		for(int i=1;i<=n;i++)
		if(fa[i]==1) cnt++;
		if(cnt==n) printf("Yes\n"); //如果所有元素都在统一强连通分量里，就算是一个强连通图。 
		else printf("No\n");
	}
	return 0;
}