Legal or Not(拓扑排序)...

题目链接
思路很清晰，就是利用拓扑排序，若是n个数被全部排序，那么就不构成环，反正则构成了环，即为不合法
这个是ac代码

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

using namespace std;

int G[105][105];
int d[105];
vector <int> e[105];

void topsort(int n)
{
    queue <int> q;
    for(int i = 0; i < n; i++){
        if(!d[i]){
            q.push(i);
        }
    }
    int count = 0;
    while(!q.empty()){
        int p = q.front();
        q.pop();
        count++;
        for(int i = 0; i < e[p].size(); i++){
            int y = e[p][i];
            d[y]--;
            if(!d[y]){
                q.push(y);
            }
        }
    }
    if(count == n)
        cout<<"YES"<<endl;
    else
        cout<<"NO"<<endl;
}
int main()
{
    int m,n;
    while(cin>>n>>m){
        if(!n&&!m)
            break;
        int u,v;
        for(int i =0 ; i < n; i++){
            e[i].clear();
        }
        memset(G,0,sizeof(G));
        memset(d,0,sizeof(d));
        while(m--){
            cin>>u>>v;
        /*    if(!G[u][v]){
                G[u][v] = v;//路径*/
                e[u].push_back(v);
                d[v]++;//入度加一
            //}
        }
        topsort(n);
    }
    return 0;
}

这个是利用数组的代码ac代码

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

using namespace std;

int G[505][505];
int d[505];
int in[505];

void topsort(int n)
{
    queue <int> q;
    for(int i = 0; i < n; i++){
        if(!d[i]){
            q.push(i);
        }
    }
    int count = 0;
    while(!q.empty()){
        int p = q.front();
        q.pop();
        count++;
        for(int i = 0; i < n; i++){
            if(G[p][i]){
                d[i]--;
                if(!d[i])
                   q.push(i);
            }
        }
    }
    if(count == n)
        cout<<"YES"<<endl;
    else
        cout<<"NO"<<endl;
}
int main()
{
    int m,n;
    while(cin>>n>>m){
        if(!n&&!m)
            break;
        int u,v;
        memset(G,0,sizeof(G));
        memset(d,0,sizeof(d));
        while(m--){
            cin>>u>>v;
            if(!G[u][v]){
                G[u][v] = 1;//路径
                d[v]++;//入度加一
            }
        }
        topsort(n);
    }
    return 0;
}

之前wa的代码，因为在被调函数中使用的循环减入度时，如果采用下面的这种方法，将会使 0 结点出的入度混乱，导致错误，但是如果一定要采取这种方法，可以错误代码下面的代码，这样就避免了使第一个结点混乱的情况

void topsort(int n)
{
    queue <int> q;
    for(int i = 0; i < n; i++){
        if(!d[i]){
            q.push(i);
        }
    }
    int count = 0;
    while(!q.empty()){
        int p = q.front();
        q.pop();
        in[count] = p;
        count++;
        for(int i = 0; i < n; i++){
            int y = G[p][i];
            d[y]--;
            if(!d[y]){
                q.push(y);
            }
        }
    }
    if(count == n)
        cout<<"YES"<<endl;
    else
        cout<<"NO"<<endl;
}
int main()
{
    int m,n;
    while(cin>>n>>m){
        if(!n&&!m)
            break;
        int u,v;
        memset(G,0,sizeof(G));
        memset(d,0,sizeof(d));
        while(m--){
            cin>>u>>v;
            if(!G[u][v]){
                G[u][v] = v;//路径
                d[v]++;//入度加一
            }
        }
        topsort(n);
    }
    return 0;
}

//某点入度，有多少条路径指向该点
//队列实现拓扑排序，存储用的数组可以换成vector；
#include <iostream>
#include <string.h>
#include <queue>
#include <vector>

using namespace std;

int G[510][510];
int d[510];

void topsort(int n)
{
    priority_queue<int,vector<int>,greater<int> > q;
    int k;
    int in[505];
    memset(in, 0, sizeof(in));
    for(int i = 1; i <= n; i++){
        if(!d[i]){
            q.push(i);
        }
    }
    int count = 0;
    while(!q.empty()){
        int p = q.top();
        q.pop();
        in[count] = p;
        count++;
        for(int i = 1; i <= n; i++){
            int x = G[p][i];
            d[x]--;
            if(!d[x]){
                q.push(i);
            }
        }
    }
    if(count == n){
        cout<<"YES"<<endl;
    }
    else
        cout<<"NO"<<endl;
}

int main()
{
    int n,m;
    while(cin>>n>>m){
        if(!n&&!m)
            break;
        memset(G,0,sizeof(G));
        memset(d,0,sizeof(d));
        while(m--){
            int b,e;
            cin>>b>>e;
            if(!G[b + 1][e + 1]){//记录e是否被b打败过，防止重复记录
                G[b + 1][e + 1] = e + 1;
                d[e + 1]++;//e的入度+1
            }
        }
        topsort(n);
    }
    return 0;
}