连通图 hdu 1269

题目链接： http://acm.hust.edu.cn/vjudge/contest/view.action?cid=122091#problem/A

 

题目：

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

 

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

 

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

 

 

简单来说就是问你从1-n是否都相互彼此连接。

 

#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
#define maxn 10005
vector<vector<int> >G;
int dfn[maxn],stacks[maxn],low[maxn],instacks[maxn];
int n, m, top, time, blocks, cnt;

void Init()
{
    G.clear();
    G.resize(n+5);
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(stacks, 0, sizeof(stacks));
    memset(instacks, 0, sizeof(instacks));
    blocks = top = cnt =0;
    time = 1;
}

void Tarjan(int u)
{
    low[u] = dfn[u] = time++;
    stacks[top++] = u;
    instacks[u] = 1;
    int len = G[u].size(),v;
    for(int i=0; i<len; i++)
    {
        v = G[u][i];
        if(!dfn[v])
        {
            Tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(instacks[v])
        {
            low[u] = min(low[u], dfn[v]);
        }
    }

    if(low[u] == dfn[u])
    {
        blocks++;
        do
        {
          cnt++;
          v = stacks[--top];
          instacks[v] = 0;
        }while(u!=v);
    }
}
int main()
{
    while(scanf("%d %d", &n, &m),n+m)
    {
        Init();
        while(m --)
        {
            int a, b;
            scanf("%d %d", &a, &b);
            G[a].push_back(b);
        }

        Tarjan(1);

        if(cnt == n && blocks == 1)
            puts("Yes");
        else
            puts("No");

    }
    return 0;
}

#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
#define maxn 10005
int dfn[maxn];///代表最先遍历到这个点的时间
int low[maxn];///这个点所能到达之前最早的时间点
int Stack[maxn];///自定义的栈，比较好用
int cnt, bloks;///cnt总的连通个数， 连通块的总个数 
bool InStack[maxn];///判断这个点是否在栈中
int n, m, Time, top;///Time 时间点，  top用于栈操作
vector<vector<int> > G;
void Tarjan(int u)
{
    low[u] = dfn[u] = ++Time;///更新时间点
    Stack[top++] = u;///将u压入栈中
    InStack[u] = true;
    int len = G[u].size(), v;///深度优先遍历与u相连的所有节点
    
    for(int i=0; i<len; i++)
    {
        v = G[u][i];

        if(!dfn[v])///我们可以用dfn判断这个点是否曾经被遍历过
        {///若是没被遍历过，那么我们就遍历一下
            Tarjan(v);
            ///假如u点下方节点v可以到达的点那么u点也一定能到达
            low[u] = min(low[u], low[v]);
            ///在两者中取一个最小的，到达点
        }
        else if( InStack[v] )
        /**如果遍历的这个点已经在栈中了，那么就需要更新一下*/
            low[u] = min(low[u], dfn[v]);
    }
    /**当这个节点的所有节点已经遍历完了并且 low[u] == dfn[u]，这个时候说明我们已经返回到了这个点的最初的时间点的位置
        将我们栈中的所有元素出栈就可以完成连通图求解了*/
    if(low[u] == dfn[u])
    {
        do
        {
            cnt ++;
            v = Stack[--top];
            InStack[v] = false;
        }while(u != v);
        bloks ++;
    }
}
void Init()
{
    G.clear();
    G.resize(n+1);
    memset(low, 0, sizeof(low));
    memset(dfn, 0, sizeof(dfn));
    memset(Stack, 0, sizeof(Stack));
    memset(InStack, false, sizeof(InStack));
    bloks = cnt = Time = top = 0;
}

int main()
{
    while(scanf("%d %d",&n, &m), n+m)
    {
        Init();
        while(m --)
        {
            int a, b;
            scanf("%d %d", &a, &b);
            G[a].push_back(b);
        }
        Tarjan(1);
        if( cnt == n && bloks == 1 )
            puts("Yes");
        else
            puts("No");
    }
    return 0;
}