POJ2762 tarjan缩点+拓扑排序

POJ2762
题意：

有向图N<=1000 M<=6000，

如果图中任意两点u,v 均有u可达v或v可达u，

输出YES，否则输出NO

思路：

嘛，强连通分量内的点肯定互相可达

对于缩点之后的DAG，怎么判呢？

如果一开始就有多个入度为0的点，那么就是No

交一发WA了

这时候就要想反例了

发现有一种情况也是No

比如1 2 ，1 3， 2 4， 3 4

2 3之间不可达，但是如果把点1跟1的边去掉，

就会发现2 3同时入度为0！

所以我们不断把入度为0的点跟边同时去掉，

判每个阶段是否同时有多个入度为0的点

而这种操作就是拓扑排序的经典操作

坑点：

这种判断不需要考虑重边，想多了

DAG不要跟原来的有向图搞混

329ms

#include
#include
#include
#include 
#include
#include
using namespace std;
const int maxn=1005;
const int maxe=6005;
int low[maxn];
int dfn[maxn];
bool ins[maxn];
int sk[maxn];
int poi=0,idx=0,cnt=0;
int num=0;
int head[maxn];
int to[maxe*2];
int nxt[maxe*2];

int n,m;
int in[maxn];//入度 
int scc[maxn];
vectordag[maxn];
queueq;
void add(int u,int v)
{
	cnt++;nxt[cnt]=head[u];
	head[u]=cnt; to[cnt]=v;
}
void tarjan(int u)
{
	dfn[u]=low[u]=++idx;
	ins[u]=1;
	sk[poi++]=u;
	for(int i=head[u];i!=-1;i=nxt[i])
	{
		int v=to[i];
		if(!dfn[v])
		{
			tarjan(v);
			low[u]=min(low[u],low[v]);
		}
		else if(ins[v]) low[u]=min(low[u],dfn[v]);
	}
	if(low[u]==dfn[u])
	{
		num++;
		int t;
		do{
			t=sk[--poi];
			scc[t]=num;
			ins[t]=0;
		}
		while(t!=u);
	}
}
bool check()//拓扑排序 
{
     while(!q.empty())q.pop();
     int fl=0;
     for(int i=1;i<=num;i++)
         if(in[i]==0)
             fl++,q.push(i);
     if(fl>1)return false;
     while(!q.empty())
     {
         fl=0;
         int u=q.front();
         q.pop();int v;
         for(int i=0;i1)return false;
         }   
     }
     return true;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d %d",&n,&m);
		memset(ins,0,sizeof(ins));
		memset(dfn,0,sizeof(dfn));
		memset(low,0,sizeof(low));
		memset(head,-1,sizeof(head));
		memset(in,0,sizeof(in));
		num=poi=cnt=idx=0;
        int u,v;
        for(int i=1;i<=m;i++)
            scanf("%d %d",&u,&v),add(u,v);
		for(int i=1;i<=n;i++)
		{
            dag[i].clear();
  			if(!dfn[i])
				tarjan(i);
        }  

        //printf("num:%d\n",num);  
		for(int u=1;u<=n;u++)
		{
            //这里手贱把dag清空写在这里了，WA一发 
			for(int i=head[u];i!=-1;i=nxt[i])
			{
				int v=to[i];
				if(scc[u]!=scc[v])
				{
                    dag[scc[u]].push_back(scc[v]);
                    in[scc[v]]++;
				}
			}
		} 
        if(check())
            printf("Yes\n");
        else
            printf("No\n");
     
    } 
	

		
}