hdu1269-强连通模板题

迷宫城堡
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 24018 Accepted Submission(s): 10332

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

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

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

Sample Input

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

Sample Output

Yes
No
写这道题，1是因为我们队要有一个写java的（不会python而且hdu和poj都不能用python，但是要应对大数，所以就java了），2是博客没有关于强连通的题目，所以就写了这个模板题。。。
题意：中文题意不解释
介绍一下强连通：在一个点的集合里面，如果任意两个点都连接了，就是都能到对方，那么这个集合就是强连通分量。
写强连通我一般是用tarjan来写的（然后现在又回来了）
tarjan大概思路就是：dfs遍历所有的点，用栈来接收点。用一个数组 dfn 表示到一个点的时间，把所有点都遍历完。
开始回溯了。用 pre 数组来表示 在刚刚遍历的时候如果遍历的点 dfn 有值，那么表示就形成了一个环，也就是一个强连通，而pre数组就是来更新最早的点的dfn值的。回溯的时候如果dfn==pre的话，说明就开始强连通了，然后开始把栈里面的数放出来。如果在刚刚遍历的时候就找到dfn有值的情况，那也更新pre的值就可以了。等下再代码里面注释一下比较方便。。。
代码：

import java.util.Arrays;
import java.util.Scanner;
class Node{		//链式前向星。。。搞了好久才知道要放外面
	public int end;
	public int next;
	public Node (int _end,int _next) {
		this.end=_end;
		this.next=_next;
	}
}
public class Main {
	public static int INF=0x7f7f7f7f;
	public static int maxn=100000+10;
	public static int maxm=10000+10;
	public static Node map[]=new Node[maxn];
	public static int sum=0;
	public static int[] head=new int[maxn];
	public static int n,m,index,top,ans;
	public static int pre[]=new int[maxm];		//最早的时间
	public static int dfn[]=new int[maxm];		//遍历到自己的时间
	public static boolean vis[]=new boolean[maxm];
	public static int stack[]=new int[maxm];
	public static int max(int x,int y) {
		if (x>y) return x;
		return y;
	}
	public static int min(int x,int y) {
		if (x>y) return y;
		return x;
	}
	public static void addedge(int start,int end) {
	//	System.out.println(111);
		map[sum]=new Node(end,head[start]);
		head[start]=sum++;
	}
	public static void Init() {		//初始化
		Arrays.fill(head, -1);
		Arrays.fill(dfn, 0);
		Arrays.fill(pre, 0);
		Arrays.fill(vis, false);
	}
	private static void tarjan(int start) {
		// TODO Auto-generated method stub
		dfn[start]=pre[start]=++index;	//什么时候到自己
		vis[start]=true;
		stack[++top]=start;			//栈来接收点
		for (int i=head[start];i!=-1;i=map[i].next) {
			int end=map[i].end;
			if (dfn[end]==0) {		//下一个点没有找过，深入
				tarjan(end);
				pre[start]=min(pre[start],pre[end]);		//
			}else {		//如果走过了，就更新pre start 节点==最早到的
				if (vis[end]==true) pre[start]=min(pre[start],dfn[end]);
			}		//因为只有找到最早的属于这个强连通分量的点，再后面输出栈里面的数的
		}			//时候才可以全部输出
		if (dfn[start]==pre[start]) {		//一个点的强连通也要注意
			ans++;
			int j=0;
			while (j!=start) {
				j=stack[top--];
		//		System.out.print(j+" ");
				vis[j]=false;
			}
		//	System.out.println();
		}
		return ;
	}
	private static void solve() {
		// TODO Auto-generated method stub
		top=index=ans=0;
		for (int i=1;i<=n;i++)
			if (dfn[i]==0) tarjan(i);		//暴力就行了，主要是防止有些点没有被之前的点连接
	}
	public static void main(String args[]) {
		@SuppressWarnings("resource")
		Scanner reader=new Scanner(System.in);
		while (reader.hasNext()) {
			n=reader.nextInt();
			m=reader.nextInt();
			if (n==0&&m==0) break;
			Init();sum=0;
	//		System.out.println(n+"    "+m);
			for (int i=1;i<=m;i++) {
				int start=reader.nextInt();
				int end=reader.nextInt();
			//	System.out.println(start+"----"+end);
				addedge(start,end);
			}
			solve();
			if (ans==1) System.out.println("Yes");
			else System.out.println("No");
		}
	}
}