迷宫城堡(强联通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=10010;
vector<int>vec[MAXN];
int vis[MAXN];
void dfs(int x){
    for(int i=0;i<vec[x].size();i++){
        int v=vec[x][i];
        if(vis[v])continue;
        vis[v]=1;
        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=0;i<MAXN;i++)vec[i].clear();
        while(M--){
            int a,b;
            scanf("%d%d",&a,&b);
            vec[a].push_back(b);
        }
        int ans=1;
        for(int i=1;i<=N;i++){
            memset(vis,0,sizeof(vis));
            vis[i]=1;
            dfs(i);
            for(int i=1;i<=N;i++){
                if(vis[i]==0){
                    ans=0;
                    break;
                }
                if(!ans)break;
            }
            if(!ans)break;
        }
        if(ans)puts("Yes");
        else puts("No");
    }
    return 0;
}

方法二：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=10010;
//#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]=1;
    for(int i=0;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(1){
        int v=S.top();
        S.pop();
        Instack[v]=0;
        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=0;i<MAXN;i++)vec[i].clear();
        mem(dfn,0);mem(low,0);mem(Instack,0);
        while(!S.empty())S.pop();
        int a,b;
        while(M--){
            scanf("%d%d",&a,&b);
            vec[a].push_back(b);
        }
        scc=dfs_block=0;
        for(int i=1;i<=N;i++){
            if(dfn[i])continue;
            targin(i,-1);
        }
        if(scc==1)puts("Yes");
        else puts("No");
    }
    return 0;
}

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

#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=10010;
const int MAXM=100010;//<<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]=1;
        for(int i=head[u];i!=-1;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(1){
            int v=S.top();
            S.pop();
            Instack[v]=0;
            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,-1);mem(dfn,0);mem(low,0);mem(Instack,0);
        edgnum=dfs_block=lcc=0;
        while(!S.empty())S.pop();
        int a,b;
        while(M--){
            scanf("%d%d",&a,&b);
            add(a,b);
        }
        for(int i=1;i<=N;i++){
            if(dfn[i])continue;
            targin(i,-1);
        }
        if(lcc==1)puts("Yes");
        else puts("No");
    }
    return 0;
}