poj 2762(强连通分量+拓扑排序)

题目链接：http://poj.org/problem?id=2762

题意：给出一个有向图，判断任意的两个顶点（u，v）能否从u到达v，或v到达u，即单连通，输出Yes或No.

分析：对于同一个强连通分量而言，所有的点都是互达的，如果该有向图只有一个强连通分量，则肯定是Yes了；

若有多个强连通分量呢？判断两个不同的强连通分量的点u和v是否单连通，缩点后，建新图，用拓扑排序判断，删除点的时候若发现有大于2个点的入度为0，则u和v必定不能连通。

AC代码：

 #include<cstdio>
 #include<cstring>
 const int N=+;
 const int M=+;
 struct EDGE{
     int v,next;
 }edge[M],edge2[M];
 int first[N],low[N],dfn[N],sta[M],belong[N],que[M],in[N],first2[N];
 bool instack[N],map[N][N];
 int cnt,g,scc,top,k;
 void AddEdge(int u,int v)
 {
     edge[g].v=v;
     edge[g].next=first[u];
     first[u]=g++;
 }
 void AddEdge2(int u,int v)
 {
     edge2[k].v=v;
     edge2[k].next=first2[u];
     first2[u]=k++;
 }
 int min(int a,int b)
 {
     return a<b?a:b;
 }
 void Tarjan(int u)    //求强连通分量
 {
     int i,v;
     low[u]=dfn[u]=++cnt;
     sta[++top]=u;
     instack[u]=true;
     for(i=first[u];i!=-;i=edge[i].next)
     {
         v=edge[i].v;
         if(!dfn[v])
         {
             Tarjan(v);
             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()
         {
             v=sta[top--];
             instack[v]=false;
             belong[v]=scc;    //缩点
             if(v==u)
                 break;
         }
     }
 }
 void build(int n)    //建缩点后的新图
 {
     int u,i,v,a,b;
     memset(map,false,sizeof(map));
     memset(first2,-,sizeof(first2));
     memset(in,,sizeof(in));
     k=;
     for(u=;u<=n;u++)      //遍历每个顶点的出边
     {
         for(i=first[u];i!=-;i=edge[i].next)
         {
             v=edge[i].v;
             a=belong[u];
             b=belong[v];
             if(a==b)     //若属于同一个强连通分量
                 continue;
             if(!map[a][b])
             {
                 AddEdge2(a,b);   //建新边
                 map[a][b]=true;
                 in[b]++;
             }
         }
     }
 }
 int topo()   //拓扑排序
 {
     int i,front,rear,top,v;
     front=rear=;
     for(i=;i<=scc;i++)
         if(in[i]==)
         {
             que[rear++]=i;
         }
     if(rear-front>)    //入度为0的顶点个数大于1,则无解
         return ;
     while(front<rear)
     {
         top=que[front++];
         for(i=first2[top];i!=-;i=edge2[i].next)
         {
             v=edge2[i].v;
             in[v]--;
             if(in[v]==)
             {
                 que[rear++]=v;
             }
             if(rear-front>)
                 return ;
         }
     }
     return ;      //有解
 }
 int main()
 {
     int t,n,m,i,u,v;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d%d",&n,&m);
         g=cnt=top=scc=;
         memset(first,-,sizeof(first));
         memset(dfn,,sizeof(dfn));
         memset(instack,false,sizeof(instack));
         while(m--)
         {
             scanf("%d%d",&u,&v);
             AddEdge(u,v);
         }
         for(i=;i<=n;i++)    //求强连通分量
             if(!dfn[i])
                 Tarjan(i);
         build(n);     //建缩点后的新图
         if(topo())    //拓扑排序
             printf("Yes\n");
         else
             printf("No\n");
     }
     return ;
 }