[POJ 2762]Going from u to v or from v to u? (强连通分量+拓扑排序)

Description

In order to make their sons brave, Jiajia and Wind take them to a big cave. The cave has n rooms, and one-way corridors connecting some rooms. Each time, Wind choose two rooms x and y, and ask one of their little sons go from one to the other. The son can either go from x to y, or from y to x. Wind promised that her tasks are all possible, but she actually doesn't know how to decide if a task is possible. To make her life easier, Jiajia decided to choose a cave in which every pair of rooms is a possible task. Given a cave, can you tell Jiajia whether Wind can randomly choose two rooms without worrying about anything?

Input

The first line contains a single integer T, the number of test cases. And followed T cases.

The first line for each case contains two integers n, m(0 < n < 1001,m < 6000), the number of rooms and corridors in the cave. The next m lines each contains two integers u and v, indicating that there is a corridor connecting room u and room v directly.

Output

The output should contain T lines. Write 'Yes' if the cave has the property stated above, or 'No' otherwise.

Sample Input

1
3 3
1 2
2 3
3 1

Sample Output

Yes

Source

POJ Monthly--2006.02.26,zgl & twb

题目大意：给定一个有向图，判断图中任意两点u,v是否能从u到达v或从v到达u，可以的话输出Yes，不行输出No

注意这里是或者不是而且，如果是而且的话直接判断整个图是不是一个强连通分量即可，简单很多，此题的思路是先将整图缩点(每个强连通分量中任意两点均可达)，对缩点后的DAG进行拓扑排序，在排序过程中若出现多个入点为0的点则判定排序失败，若最终拓扑排序成功则表明图中任意两点u,v能从u到达v或从v到达u

#include <iostream>
#include <string.h>

#define MAXV 8010
#define MAXE 2010
#define cls(array,num) memset(array,num,sizeof(array))

using namespace std;

struct edge
{
    int u,v,next;
}edges[MAXV],newedges[MAXV];

int head[MAXE],dfn[MAXE],low[MAXE],belong[MAXE],stack[4*MAXE],inDegree[MAXE];
bool inStack[MAXE];
int top=0,nCount=0,newCount=0,tot=0,index=0,n,m;

int min(int a,int b)
{
    if(a<b) return a;
    return b;
}

void AddEdge(int U,int V,edge arr[],int& count)
{
    arr[++count].u=U;
    arr[count].v=V;
    arr[count].next=head[U];
    head[U]=count;
}

void tarjan(int u)
{
    dfn[u]=low[u]=++index;
    stack[++top]=u;
    inStack[u]=true;
    for(int p=head[u];p!=-1;p=edges[p].next)
    {
        int v=edges[p].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(inStack[v])
            low[u]=min(low[u],dfn[v]);
    }
    int v;
    if(dfn[u]==low[u])
    {
        tot++;
        do
        {
            v=stack[top--];
            belong[v]=tot;
            inStack[v]=false;
        }while(u!=v);
    }
}

void newGraph() //缩点建图,新图在newedges里
{
    cls(head,-1);
    for(int i=1;i<=nCount;i++)
    {
        int u=edges[i].u,v=edges[i].v;
        if(belong[u]!=belong[v])
        {
            AddEdge(belong[u],belong[v],newedges,newCount);
            inDegree[belong[v]]++;
        }
    }
}

bool topologicalSort()
{
    int ans=0,num;
    for(int i=1;i<=tot;i++)
    {
        if(inDegree[i]==0)
        {
            ans++;
            num=i;
        }
    }
    if(ans>1) return false;
    int rest=tot,result[MAXE];
    while(rest--)
    {
        ans=0;
        for(int p=head[num];p!=-1;p=newedges[p].next)
        {
            int v=newedges[p].v;
            inDegree[v]--;
            if(inDegree[v]==0)
            {
                ans++;
                num=v;
            }
        }
        if(ans>1) return false;
    }
    return true;
}

int main()
{
    int testCase;
    cin>>testCase;
    while(testCase--)
    {
        cls(head,-1);
        cls(dfn,0);
        cls(low,0);
        cls(stack,0);
        cls(inStack,0);
        cls(belong,0);
        cls(inDegree,0);
        top=0,nCount=0,newCount=0,tot=0,index=0;
        for(int i=0;i<MAXV;i++)
        {
            edges[i].u=0;
            edges[i].v=0;
            edges[i].next=0;
            newedges[i].u=0;
            newedges[i].v=0;
            newedges[i].next=0;
        }
        cin>>n>>m;
        for(int i=1;i<=m;i++)
        {
            int a,b;
            cin>>a>>b;
            AddEdge(a,b,edges,nCount);
        }
        for(int i=1;i<=n;i++)
            if(!dfn[i]) tarjan(i);
        newGraph();
        if(topologicalSort())
            cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
    }
    return 0;
}