迷宫城堡

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other)

Total Submission(s) : 29   Accepted Submission(s) : 12

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

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

Source

HDU 2006-4 Programming Contest

。。。。迭代器方法

#include <iostream>
#include<cstdio>
#include<cstring>
#include<set>
using namespace std;

set<int> s[100005],sv;
int vis[100005];
int n,m,i,x,y,flag;

void dfs(int ori,int room)
{
    set<int>::iterator it=s[room].begin();
    while(it!=s[room].end())
    {
        if (vis[*it]) { it++; continue;}
        vis[*it]=1;
        sv.insert(*it);
        dfs(ori,*it);
        it++;
    }
    return;
}
int main()
{
    while(~scanf("%d%d",&n,&m),n)
    {
        for(i=1;i<=n;i++) s[i].clear();
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&x,&y);
            s[x].insert(y);
        }
        flag=1;
       for(i=1;i<=n;i++)
       {
         memset(vis,0,sizeof(vis));
         sv.clear();
         vis[i]=1;
         dfs(i,i);
         if(sv.size()!=n-1) {flag=0; break;}
       }
        if (flag) printf("Yes\n");
          else printf("No\n");
    }
    return 0;
}

tarjan算法。。

#include <iostream>
#include<cstring>
#include<cstdio>
#include<deque>
#include<algorithm>
using namespace std;

int dfn[10005],low[10005],instack[10005],vis[10005],p[10005];
struct node
{
    int num,next;
}tree[100005];
int i,j,n,m,x,y,index,l,flag,num;
deque<int> s;
void tarjan(int u)
{
    dfn[u]=low[u]=++index;
    vis[u]=1;
    instack[u]=1;
    s.push_back(u);
    for(int i=p[u];i!=-1;i=tree[i].next)
    {
        if (!vis[tree[i].num])
         {
             tarjan(tree[i].num);
             if (flag) return;
             low[u]=min(low[u],low[tree[i].num]);
         } else
         if (instack[tree[i].num])
         {
             low[u]=min(low[u],dfn[tree[i].num]);
         }
    }
     if (dfn[u]==low[u])
         {
           num=0;
           int v;
           do
           {
               v=s.back();
               s.pop_back();
               instack[v]=0;
               num++;
           }
           while(u!=v);
            flag=1;
            return;
         }
    return;
}
int main()
{
    while(scanf("%d%d",&n,&m) && n!=0)
    {
       l=0;
       memset(p,-1,sizeof(p));
        for(i=1;i<=m;i++)
            {
                scanf("%d%d",&x,&y);
                tree[++l].num=y;
                tree[l].next=p[x];
                p[x]=l;
            }
            memset(vis,0,sizeof(vis));
            memset(instack,0,sizeof(instack));
            index=0;
            flag=0;
            s.clear();
            tarjan(x);
            if (n==num) printf("Yes\n");
               else printf("No\n");
    }
    return 0;
}