poj 2762 Going from u to v or from v to u?(tarjan+拓扑排序)

Going from u to v or from v to u?

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 14488		Accepted: 3812

Description

In order to make their sons brave, Jiajia and Wind take them to a big cave. The cave has n rooms, and one-way corridors connecting some rooms. Each time, Wind choose two rooms x and y, and ask one of their little sons go from one to the other. The son can either
go from x to y, or from y to x. Wind promised that her tasks are all possible, but she actually doesn't know how to decide if a task is possible. To make her life easier, Jiajia decided to choose a cave in which every pair of rooms is a possible task. Given
a cave, can you tell Jiajia whether Wind can randomly choose two rooms without worrying about anything?
Input

The first line contains a single integer T, the number of test cases. And followed T cases.

The first line for each case contains two integers n, m(0 < n < 1001,m < 6000), the number of rooms and corridors in the cave. The next m lines each contains two integers u and v, indicating that there is a corridor connecting room u and room v directly.

Output

The output should contain T lines. Write 'Yes' if the cave has the property stated above, or 'No' otherwise.
Sample Input

1
3 3
1 2
2 3
3 1

Sample Output
Yes

题意：判断有向图是否任意两点u、v间都存在u到v的路径或v到u的路径？
1、首先将图中的环缩成点，因为环肯定满足条件；
2、缩成点之后，只有是一条链的时候才满足条件，用拓扑排序判断，若同时存在2个或以上的入度为0的点，则不满足条件。

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

const int maxn = 1010;
const int maxe = 2*6005;
int n , m;
vector<int> V[maxn];
int degree[maxn];

/////////////////////////////tarjan
struct edge{
int u , v , next;
edge(int a = 0 , int b = 0 , int c = 0){
u = a , v = b , next = c;
}
}tarjan_e[maxe];
int tarjan_low[maxn] , tarjan_dfn[maxn] , tarjan_vis[maxn] , tarjan_block[maxn] , tarjan_head[maxn];//tarjan_block值相同即属于同一个环
int tarjan_order , tarjan_b , tarjan_cnt;
stack<int> tarjan_stack;

void tarjan_add(int u , int v){
tarjan_e[tarjan_cnt] = edge(u , v , tarjan_head[u]);
tarjan_head[u] = tarjan_cnt++;
}

void tarjan_init(){
for(int i = 0; i < maxn; i++){
tarjan_low[i] = 0;
tarjan_dfn[i] = 0;
tarjan_vis[i] = 0;
tarjan_block[i] = 0;
tarjan_head[i] = -1;
}
tarjan_b = 1;
tarjan_order = 1;
tarjan_cnt = 0;
while(!tarjan_stack.empty()) tarjan_stack.pop();
}

void tarjan(int u){
tarjan_low[u] = tarjan_order;
tarjan_dfn[u] = tarjan_order++;
tarjan_vis[u] = 1;
tarjan_stack.push(u);
for(int i = tarjan_head[u]; i != -1; i = tarjan_e[i].next){
int v = tarjan_e[i].v;
if(!tarjan_dfn[v]){
tarjan(v);
tarjan_low[u] = min(tarjan_low[u] , tarjan_low[v]);
}else if(tarjan_vis[v]) tarjan_low[u] = min(tarjan_low[u] , tarjan_dfn[v]);
}
if(tarjan_low[u] == tarjan_dfn[u]){
int top;
do{
top = tarjan_stack.top();
tarjan_stack.pop();
tarjan_vis[top] = 0;
tarjan_block[top] = tarjan_b;
}while(top != u);
tarjan_b++;
}
}
/////////////////////////////////

void initial(){
tarjan_init();
for(int i = 0; i < maxn; i++){
V[i].clear();
degree[i] = 0;
}
}

void readcase(){
scanf("%d%d" , &n , &m);
int u , v;
for(int i = 0; i < m; i++){
scanf("%d%d" , &u , &v);
tarjan_add(u , v);
}
}

void computing(){
for(int i = 1; i <= n; i++){
if(!tarjan_dfn[i]) tarjan(i);
}
for(int i = 0; i < tarjan_cnt; i++){
int u = tarjan_e[i].u , v = tarjan_e[i].v;
if(tarjan_block[u] != tarjan_block[v]){
//cout << u << " " << v << endl;
degree[tarjan_block[v]]++;
V[tarjan_block[u]].push_back(tarjan_block[v]);
}
}
queue<int> q;
for(int i = 1; i < tarjan_b; i++) if(degree[i] == 0) q.push(i);
while(!q.empty()){
if(q.size() > 1){
printf("No\n");
return;
}
int f = q.front();
q.pop();
for(int i = 0; i < V[f].size(); i++){
degree[V[f][i]]--;
if(degree[V[f][i]] == 0) q.push(degree[V[f][i]]);
}
}
printf("Yes\n");
}

int main(){
int T;
scanf("%d" , &T);
while(T--){
initial();
readcase();
computing();
}
return 0;
}