hdu 5154 有向图判环

Harry and Magical Computer

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 230    Accepted Submission(s): 108

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
  
  
  
  


  
  

昨天bestcoder比赛打得好伤心，这道题想错了，题意是存在依存关系的就必须按照依存关系的顺序处理，如果不存在就无所谓了，我一直以为不存在就不能process了。

第一种方法：即bestcoder题解

用floyd判断，如果a->b的路径存在且b->a的路径存在，就NO 

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cassert>
#include <cstdio>
using namespace std ;

const int N = 100 + 11 ;

bool arr[N][N] ;
int n , m ;

void floyd() {
    for(int i = 1 ; i <= n ; ++i) {
        for(int j = 1 ; j <= n ; ++j) {
            if(i == j || arr[i][j]) continue ;
            for(int k = 1 ; k <= n ; ++k) {
                if(k == i ) continue ;
                arr[i][j] = arr[i][k] & arr[k][j] ;
            }
        }
    }
    for(int i = 1 ; i <= n ; ++i) {
        for(int j = i ; j <= n ; ++j) {
            if(arr[i][j] && arr[j][i]) {
                printf("NO\n") ; return ;
            }
        }
    }
    printf("YES\n") ;
}

int main() {//freopen("data.in" , "r" ,stdin) ;
    int a , b ;
    while(scanf("%d%d" ,&n ,&m)==2) {
        memset(arr , 0 , sizeof(arr)) ;
        while(m--) {
            scanf("%d%d" ,&a ,&b) ;
            arr[a][b] = true ;
        }
        floyd() ;
    }
}

第二种方法：拓扑排序

如果能把所有的点排序则YES

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

const int N = 100 + 11 ;

vector<int> err[N] ;
int degree[N] ;
int n , m ;

void topsort() {
    queue<int> que ;
    for(int i = 1 ; i <= n ; ++i) {
        if(degree[i] == 0) {
            que.push(i) ;
        }
    }
    int k = 0 ;
    while(!que.empty()) {
        ++k ;
        int f = que.front() ;
        que.pop() ;
        for(int i = 0 ; i < err[f].size() ; ++i) {
            int tmp = err[f][i] ;
            --degree[tmp] ;
            if(degree[tmp] == 0) {
                que.push(tmp) ;
            }
        }
    }
    if(k == n) printf("YES\n") ;
    else printf("NO\n") ;
}

int main() {//freopen("data.in" , "r" , stdin) ;
    int a , b ;
    while(scanf("%d%d" ,&n ,&m)==2) {
        memset(degree , 0 ,sizeof(degree)) ;for(int i = 1 ; i <= n ; ++i) err[i].clear() ;
        while(m--) {
            scanf("%d%d" ,&a ,&b) ;
            err[b].push_back(a) ;
            ++degree[a] ;
        }
        topsort() ;
    }
}