迷宫城堡(Tarjan)

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

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

Author
Gardon

模板题目：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
struct node
{
  int to, next;
}edge[maxn];
int Low[maxn], DFN[maxn];
int head[maxn];
int tot, top, Stack[maxn], Belong[maxn];
int scc, Index;
bool Instack[maxn];
void add_edge(int u, int v)
{
   edge[tot].to = v;
   edge[tot].next = head[u];
   head[u] = tot++;
}
void Init()
{
   memset(head, -1, sizeof(head));
   tot = 0;
}
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=edge[i].next)
  {
     v = edge[i].to;
     if(!DFN[v])
     {
       Tarjan(v);
       if(Low[u]>Low[v])
       Low[u] = Low[v];
     }
     else if(Instack[v]&&Low[u]>DFN[v])
     Low[u] = DFN[v];
  }
  if(Low[u]==DFN[u])
  {
     scc++;
     do
     {
         v = Stack[--top];
         Instack[v] = false;
         Belong[v] = scc;
     }while(v!=u);
  }
}
void solve(int N)
{
  memset(Instack, false, sizeof(Instack));
  memset(DFN, 0, sizeof(DFN));
  Index = top = scc = 0;
  for(int i=1;i<=N;i++)
  {
     if(!DFN[i])
     {
       Tarjan(i);
     }
  }
}
int main()
{
  int n, m;
  while(~scanf("%d %d", &n, &m))
  {
      if(n==0&&m==0)
      break;
      Init();
      while(m--)
      {
         int u, v;
         scanf("%d %d", &u, &v);
         add_edge(u, v);
      }
      solve(n);
      if(scc==1)
      printf("Yes\n");
      else
      printf("No\n");
  }
  return 0;
}