迷宫城堡(强联通targin)

迷宫城堡

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 10409    Accepted Submission(s): 4674

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

题解：

强联通问题，targin算法，或者dfs做，建图也可以用邻接表，或者vector；

方法一dfs：

 #include<stdio.h>
 #include<string.h>
 #include<math.h>
 #include<algorithm>
 #include<vector>
 using namespace std;
 #define MAX(x,y)(x>y?x:y)
 #define MIN(x,y)(x<y?x:y)
 //#define LOCAL
 const int INF=0x3f3f3f3f;
 const int MAXN=;
 vector<int>vec[MAXN];
 int vis[MAXN];
 void dfs(int x){
     for(int i=;i<vec[x].size();i++){
         int v=vec[x][i];
         if(vis[v])continue;
         vis[v]=;
         dfs(v);
     }
 }
 int main(){
     #ifdef LOCAL
     freopen("data.in","r",stdin);
     freopen("data.out","w",stdout);
     #endif
     int N,M;
     while(~scanf("%d%d",&N,&M),N|M){
         for(int i=;i<MAXN;i++)vec[i].clear();
         while(M--){
             int a,b;
             scanf("%d%d",&a,&b);
             vec[a].push_back(b);
         }
         int ans=;
         for(int i=;i<=N;i++){
             memset(vis,,sizeof(vis));
             vis[i]=;
             dfs(i);
             for(int i=;i<=N;i++){
                 if(vis[i]==){
                     ans=;
                     break;
                 }
                 if(!ans)break;
             }
             if(!ans)break;
         }
         if(ans)puts("Yes");
         else puts("No");
     }
     return ;
 }

方法二：targin算法：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<queue>
 #include<stack>
 #include<vector>
 #define mem(x,y) memset(x,y,sizeof(x))
 using namespace std;
 const int INF=0x3f3f3f3f;
 const int MAXN=;
 //#define LOCAL
 vector<int>vec[MAXN];
 stack<int>S;
 int dfn[MAXN],low[MAXN],Instack[MAXN];
 int scc,dfs_block;
 void targin(int u,int fa){
     dfn[u]=low[u]=++dfs_block;
     S.push(u);
     Instack[u]=;
     for(int i=;i<vec[u].size();i++){
         int v=vec[u][i];
         if(!dfn[v]){
             targin(v,u);
             low[u]=min(low[u],low[v]);
         }
         else if(Instack[v])
             low[u]=min(low[u],dfn[v]);
     }
     if(low[u]==dfn[u]){
         scc++;
         while(){
         int v=S.top();
         S.pop();
         Instack[v]=;
         if(u==v)break;
         }
     }
 }
 int main(){
     #ifdef LOCAL
     freopen("data.in","r",stdin);
     freopen("data.out","w",stdout);
     #endif
     int N,M;
     while(~scanf("%d%d",&N,&M),N|M){
         for(int i=;i<MAXN;i++)vec[i].clear();
         mem(dfn,);mem(low,);mem(Instack,);
         while(!S.empty())S.pop();
         int a,b;
         while(M--){
             scanf("%d%d",&a,&b);
             vec[a].push_back(b);
         }
         scc=dfs_block=;
         for(int i=;i<=N;i++){
             if(dfn[i])continue;
             targin(i,-);
         }
         if(scc==)puts("Yes");
         else puts("No");
     }
     return ;
 }

邻接表建图又写了一遍，邻接表都不太熟练了：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<queue>
 #include<stack>
 #include<vector>
 using namespace std;
 const int INF=0x3f3f3f3f;
 //#define LOCAL
 #define mem(x,y) memset(x,y,sizeof(x))
 const int MAXN=;
 const int MAXM=;//<<1;
 int head[MAXM],low[MAXN],dfn[MAXN],Instack[MAXN];
 int edgnum,dfs_block,lcc;
 stack<int>S;
 struct Edge{
     int from,to,next;
 };
 Edge edg[MAXM];
 void add(int u,int v){
     Edge E={u,v,head[u]};
     edg[edgnum]=E;
     head[u]=edgnum++;//**
 }
 void targin(int u,int fa){
         low[u]=dfn[u]=++dfs_block;
         S.push(u);
         Instack[u]=;
         for(int i=head[u];i!=-;i=edg[i].next){//**
             int v=edg[i].to;
             if(!dfn[v]){
                 targin(v,u);
                 low[u]=min(low[v],low[u]);
             }
             else if(Instack[v]){
                 low[u]=min(low[u],dfn[v]);
             }
         }
         if(low[u]==dfn[u]){
             lcc++;
             while(){
             int v=S.top();
             S.pop();
             Instack[v]=;
             if(u==v)break;
             }
         }
 }
 int main(){
     #ifdef LOCAL
     freopen("data.in","r",stdin);
     freopen("data.out","w",stdout);
     #endif
     int N,M;
     while(~scanf("%d%d",&N,&M),N|M){
     mem(head,-);mem(dfn,);mem(low,);mem(Instack,);
         edgnum=dfs_block=lcc=;
         while(!S.empty())S.pop();
         int a,b;
         while(M--){
             scanf("%d%d",&a,&b);
             add(a,b);
         }
         for(int i=;i<=N;i++){
             if(dfn[i])continue;
             targin(i,-);
         }
         if(lcc==)puts("Yes");
         else puts("No");
     }
     return ;
 }