POJ 2762 Going from u to v or from v to u? （Tarjan） - from lanshui_Yang
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.
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 。
解题思路：先用tarjan缩点，然后用拓扑排序一下，排序后的序列中，如果所有相邻两个点之间均存在边，则说明原图中，任意两点之间均存在可达的路径，即输出“Yes”，否则，输出“No”。
请看代码：
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdio>
#include<algorithm>
using namespace std ;
const int MAXN = 1111 ;
struct Node
{
int adj ;
Node *next ;
}mem[MAXN * 6]; // 先把存放边节点的数组开好，这样能大量节省时间
int memp ;
Node *vert[MAXN] ; // 建立顶点数组
short g[MAXN][MAXN] ; // 缩点后的邻接矩阵
bool inq[MAXN] ; // 判断节点是否在栈中
int stap[MAXN] ; // 数组模拟栈
int top ;
int d[MAXN] ; // 统计 缩点后各连通分量的 入度
int tpo[MAXN] ; // 拓扑序列
bool vis[MAXN] ;
int dfn[MAXN] ;
int low[MAXN] ;
int tmpdfn ;
int belong[MAXN] ;
int n , m ;
int scnt ; // 记录强连通分量个数
void clr() // 初始化
{
memset(dfn , 0 , sizeof(dfn)) ;
memset(low , 0 , sizeof(low)) ;
memset(vert , 0 , sizeof(vert)) ;
memset(belong , -1 , sizeof(belong)) ;
memset(vis , 0 , sizeof(vis)) ;
memset(g , 0 , sizeof(g)) ;
memset(stap , -1 , sizeof(stap)) ;
memset(d , 0 , sizeof(d)) ;
memset(tpo , -1 , sizeof(tpo)) ;
memset(inq , 0 , sizeof(inq)) ;
memp = 0 ;
top = -1 ;
scnt = -1 ;
tmpdfn = 0 ;
}
void tarjan(int u)
{
vis[u] = 1 ;
dfn[u] = low[u] = ++ tmpdfn ;
stap[++ top] = u ;
inq[u] = true ;
Node *p = vert[u] ;
while (p != NULL)
{
int v = p -> adj ;
if(!vis[v])
{
tarjan(v) ;
low[u] = min(low[u] , low[v]) ;
}
else if(inq[v]) // 如果点v还在栈中
{
low[u] = min(low[u] , dfn[v]) ;
}
p = p -> next ;
}
if(dfn[u] == low[u]) // 缩点
{
scnt ++ ;
int tmp = stap[top --] ;
do
{
tmp = stap[top --] ;
inq[tmp] = false ;
belong[tmp] = scnt ;
}while(tmp != u) ;
}
}
void build()
{
Node * p ;
int i ;
for(i = 1 ; i <= n ; i ++)
{
p = vert[i] ;
while (p)
{
int tv = p -> adj ;
int x = belong[i] ;
int y = belong[tv] ;
g[belong[i]][belong[tv]] = 1 ;
if(x != y)
d[y] ++ ;
p = p -> next ;
}
}
}
void topo() // 拓扑排序
{
int k ;
for(k = 0 ; k <= scnt ; k ++)
{
int i ;
for(i = 0 ; i <= scnt ; i ++)
{
if(d[i] == 0)
break ;
}
tpo[k] = i ;
d[i] = -1 ;
int j ;
for(j = 0 ; j <= scnt ; j ++)
{
if(i != j)
d[j] -= g[i][j] ;
}
}
}
void init()
{
scanf("%d%d" , &n , &m) ;
int i , j ;
clr() ;
int root ;
for(i = 0 ; i < m ; i ++)
{
int a , b ;
scanf("%d%d" , &a , &b) ;
Node *p = &mem[memp] ;
p -> adj = b ;
p -> next = vert[a] ;
vert[a] = p ;
memp ++ ;
}
for(i = 1 ; i <= n ; i ++) // 注意此处，保证图中每个节点都被访问
{
if(!vis[i])
tarjan(i) ;
}
build() ;
topo() ;
bool flag = true ;
for(i = 0 ; i < scnt ; i ++)
{
if(!g[ tpo[i] ][ tpo[i + 1] ])
{
flag = false ;
break ;
}
}
if(flag)
puts("Yes") ;
else
puts("No") ;
}
int main()
{
int T ;
scanf("%d" , &T) ;
while (T --)
{
init() ;
}
return 0 ;
}