HDU5154 Harry and Magical Computer【拓扑排序】

Harry and Magical Computer

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 73    Accepted Submission(s): 34

Problem Description

In reward of being yearly outstanding magic student, Harry gets a magical computer. When the computer begins to deal with a process, it will work until the ending of the processes. One day the computer got n processes to deal with. We number the processes from
1 to n. However there are some dependencies between some processes. When there exists a dependencies (a, b), it means process b must be finished before process a. By knowing all the m dependencies, Harry wants to know if the computer can finish all the n processes.

Input

There are several test cases, you should process to the end of file.

For each test case, there are two numbers n m on the first line, indicates the number processes and the number of dependencies. 1≤n≤100,1≤m≤10000

The next following m lines, each line contains two numbers a b, indicates a dependencies (a, b). 1≤a,b≤n

Output

Output one line for each test case.

If the computer can finish all the process print "YES" (Without quotes).

Else print "NO" (Without quotes).

Sample Input

3 2

3 1

2 1

3 3

3 2

2 1

1 3

Sample Output

YES

NO

Source

BestCoder Round #25

题目大意： 哈利用一个魔法电脑处理N个任务，但是有M个前后关系(a，b)，

意思是在b执行之前必须先执行a，即a任务在b任务前，问你是否能满足要求

处理完这N个任务。

思路：拓扑排序，用到了队列。先将所有入度为0的点入队，并用Count统计

入度不为0的点。遍历队列中的点所连的所有边，并减少该点连接边另一端的

入度，只要另一端入度为0了，就将它加入队列中，并统计这一端的个数id。

最后比较id和Count是否相等就可以判断是否能处理完这N个任务。

#include<iostream>
#include<algorithm>
#include<queue>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN = 110;
const int MAXM = 10010;

int head[MAXN],indegree[MAXM],N,M,T;
struct EdgeNode
{
    int to;
    int w;
    int next;
};
EdgeNode Edges[MAXM];

int toposort()
{
    queue<int> Q;
    int u;
    int Count = 0;
    for(int i = 1; i <= N; i++)
    {
        if(indegree[i] == 0)
            Q.push(i);
        else
            Count++;
    }
    int id = 0;
    while(!Q.empty())
    {
        u = Q.front();
        Q.pop();
        for(int i = head[u]; i != -1; i = Edges[i].next)
        {
            indegree[Edges[i].to]--;
            if(indegree[Edges[i].to]==0)
            {
                id++;
                Q.push(Edges[i].to);
            }
        }
    }
    if(id < Count)
        return false;
    else
        return true;
}
int main()
{
    int x,y;
    while(cin >> N >> M)
    {
        memset(head,-1,sizeof(head));
        memset(indegree,0,sizeof(indegree));
        for(int i = 0; i < M; i++)
        {
            cin >> x >> y;
            Edges[i].to = y;
            Edges[i].w = 1;
            Edges[i].next = head[x];
            head[x] = i;
            indegree[y]++;
        }
        if(toposort())
            cout << "YES" << endl;
        else
            cout << "NO" << endl;
    }

    return 0;
}