tzoj 3645: 迷宫城堡 （tarjan强连通分量）

题目：

为了训练小希的方向感，Gardon建立了一座大城堡，里面有N个房间(从1～N编号，N<=10000)和M条通道(M<=100000)，每个通道都是单向的，就是说若称某通道连通了A房间和B房间，只说明可以通过这个通道由A房间到达B房间，但并不说明通过它可以由B房间到达A房间。Gardon需要请你写个程序确认一下是否任意两个房间都是相互连通的，即：对于任意的i和j，至少存在一条路径可以从房间i到房间j，也存在一条路径可以从房间j到房间i。

输入：

输入包含多组数据，输入的第一行有两个数：N和M，接下来的M行每行有两个数a和b，表示了一条通道可以从A房间来到B房间。文件最后以两个0结束。

输出：

对于输入的每组数据，如果任意两个房间都是相互连接的，输出"Yes"，否则输出"No"。

样例输入：

3 3
1 2
2 3
3 1
3 3
1 2
2 3
3 2
0 0

样例输出：

Yes
No 

题意：

有一座城堡，里面的路都是单向，让我们判断该座城堡内的所有房间是否属于一个强连通分量。是则输出“Yes”否则输出“No”。

预备知识：

什么是强连通分量？

一个强连通分量指的是该分量里的任意两个点，比如有两点i,j  可以由i走j，也可以由j走到i。强连通分量与有向图挂钩。

举个栗子：

 我们可以看上图，在1号强连通分量中，任何任意点i可以到达任意点j。2号和3号也一样。

那2号+1号是否为强连通分量呢？答案是否的。因为看2号中的b点不能通过某条路径到达一号中的a点，d点也无法到达a点（里面的例子很多大家可以自己找找）。

那我们该怎么算有多少这样的强连通分量呢？

tarjan强连通分量

具体怎么实现的呢？引入两个数组，一个是dfn[]，另一个为low[]（这两个数组都是一个节点的两个属性），dfn比较好理解指的是第几个访问到该节点的，low一开始与dfn为同一值，low指的是不通过他的父亲节点(那么只能去看他的子节点了对吧)，所能到达的最小的dfn，low是在回溯的过程中进行更新的，因为这时他的子节点都已经算完了，这时就可以和他的子节点能到达的最小dfn（就是子节点的low）取一个min。

我们以一个简单的例子模拟一下该算法：

 这里一眼就可以看出有两个强连通分量。我们假设第一次访问的是a节点。并且引入一个栈。 括号中分别表示dfn   low。

a(1,1)    栈中元素为  a

b(2,2)   栈中元素为  a  b

c(3,3)    栈中元素为 a  b  c

d(4,4)   栈中元素为 a b c d

由于d能到b且b的low值比d小，则可以更新d(4,2) ，d点除了b就没有其他可以访问的点了，就回溯

然后回溯可以更新c(3,2) 当回溯到b点时，b的low值最小只能是2不能更新了，所以就把d,c,b都出栈，那么一个强连通分量就是 d c b

然后进行回溯 到a点，由于a点的low值只能最小到1，无法更小，所以a出栈。另一个强连通分量就是   a。至此算法结束。

（注意在我们更新low的时候如果他的连接点已经被更新过了，我们不能直接对取min而是要看这个节点是否已经出栈，如果出栈了，那么他已经属于另一个强连通分量，不能再更新当前的点了。）

这么多文字是不是有点生涩、难懂，并且无法好好冷静下来看呢，我懂的。

可以看一下这个视频，听完肯定会对强连通分量和实现方式有更加清晰的认识%%%。 

点击这里

通过代码：

#include<bits/stdc++.h>
#define x first
#define y second
#define IOS ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define PI 3.1415926535898
using namespace std;
typedef pair<int,int>pii;
typedef long long ll;
const int N=10010,inf=0x3f3f3f3f;
vector<int>g[N]; 
int n,m,t,low[N],dfn[N],dfn_cnt,root;
bool vis[N];//判断是否还在栈中；
stack<int>st; 
//判断强连通分量为1； 
void init()
{
	for(int i=1;i<=n;i++) g[i].clear();
	memset(low,0,sizeof low);
	memset(dfn,0,sizeof dfn);
	memset(vis,0,sizeof vis);
	while(!st.empty())
	{
		st.pop();
	}
	t=0;
	dfn_cnt=0;
}
void dfs(int u,int fa)
{
	int child=0;
	dfn[u]=low[u]=++t;
	st.push(u);
	vis[u]=true;
	for(int i=0;i<g[u].size();i++)
	{
		if(g[u][i]==fa) continue;
		if(!dfn[g[u][i]])
		{
			child++;
			dfs(g[u][i],u);
			low[u]=min(low[u],low[g[u][i]]);
		}
		else if(vis[g[u][i]])//要看他的祖先是否还在栈中 
		{
			low[u]=min(low[u],low[g[u][i]]);
		}
	}
	if(dfn[u]==low[u]) 
	{
		dfn_cnt++;
		while(true)
		{
			int t=st.top();
			vis[t]=false;
			st.pop();
			if(t==u) break;
		}
	}
}
void solve()
{
	for(int i=0;i<m;i++)
	{
		int u,v; cin>>u>>v;
		g[u].push_back(v);
	}
	for(int i=1;i<=n;i++)
	{
		 if(!dfn[i]) 
		{
			root=i;
			dfs(i,0);
		}
	}
	if(dfn_cnt==1) cout<<"Yes"<<endl;
	else cout<<"No"<<endl;
}  
int main()
{	
	IOS; 
    int T;
    T=1;
    while(cin>>n>>m&&n&&m)
	{
		init();
		solve();
	} 
}