poj 2762 Going from u to v or from v to u? 【 强连通 拓扑排序】

给出n个点，m条边，问是否任意两点u,v,是否满足u能够到达v，或者v能够到达u

自己写的时候以为缩一下点，然后再判断一下能不能拓扑排序就可以了

但是--wa---

后来看了这篇题解

http://edward-mj.com/archives/27

按紫书上讲的，如果图中存在有向环，则不存在拓扑排序，反之则存在

所以上面这幅图是满足拓扑排序的

但是因为u,v的入度都为0，u，v之间不能到达

所以缩点完之后的图应该满足是一条长链才行

 #include<cstdio>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #include<stack>
 #include<queue>
 #include<vector>
 using namespace std;

 const int maxn = ;
 int first[maxn];
 int low[maxn],pre[maxn],sc[maxn];
 int in[maxn],dout[maxn];
 int n,m;
 int ecnt,scnt,dfs_clock;
 stack<int> S;

 vector<int> g[maxn];
 int c[maxn];
 int ans[maxn];

 struct Edge{
     int v,next;
 }e[*maxn];

 void init(){
     ecnt = ;
     memset(first,-,sizeof(first));
     memset(in,,sizeof(in));
     memset(dout,,sizeof(dout));
 }

 void addedges(int u,int v){
     e[ecnt].v = v;
     e[ecnt].next = first[u];
     first[u] = ecnt++;
 }

 void dfs(int u){
     low[u] = pre[u] = ++dfs_clock;
     S.push(u);
     for(int i = first[u];~i;i = e[i].next){
         int v = e[i].v;
         if(!pre[v]){
             dfs(v);
             low[u] = min(low[u],low[v]);
         }
         else if(!sc[v]) low[u] = min(low[u],pre[v]);
     }
     if(pre[u] == low[u]){
         scnt++;
         for(;;){
             int x = S.top();S.pop();
             sc[x] = scnt;
             if(x == u) break;
         }
     }
 }

 void find_scc(){
     while(!S.empty()) S.pop();
     memset(low,,sizeof(low));memset(pre,,sizeof(pre));
     memset(sc,,sizeof(sc));
     dfs_clock = scnt = ;
     for(int i = ;i <= n;i++) if(!pre[i]) dfs(i);
 }

 bool topsort(int N) {
     queue<int> s;
     for (int i = ; i <= N; i++) {
         if (!in[i]) s.push(i);
         if (s.size() == ) return false;
     }
     while (!s.empty()) {
         int u = s.front();s.pop();
         bool flag = false;
         for (int i = ; i < g[u].size(); i++) {
             int v = g[u][i];
             in[v] -= ;
             if (!in[v]) {
                 if (flag) return false;
                 s.push(v);
                 flag = true;
             }
         }
     }
     return true;
 }

 int main(){
     int T;
     scanf("%d",&T);
     while(T--){
         scanf("%d %d",&n,&m);
         init();
         for(int i = ;i <= m;i++){
             int u,v;
             scanf("%d %d",&u,&v);
             addedges(u,v);
         }
         find_scc();
         if(scnt == ) {
             puts("Yes");
             continue;
         }
         for(int i = ;i <= scnt;i++) g[i].clear();
         for(int u = ;u <= n;u++){
             for(int i = first[u];~i;i = e[i].next){
                 int v = e[i].v;
                 if(sc[u] != sc[v]) {
                     g[sc[u]].push_back(sc[v]);
                     in[sc[v]]++;
                 }
             }
         }
         if(topsort(scnt)) puts("Yes");
         else puts("No");
     }
     return ;
 }