poj 2762 Going from u to v or from v to u?

u到v或者v到u

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

简单来说,这是一个有向图的弱连通问题…

注意，是有向图！

学习了图的强连通后，不难发现，一个样有向图的强连通是有向环，对于环上的每一个点(room),他们都可以互相到达。

如果我们找到图中的强连通分量，将他们缩点，再连边，会形成一个“压缩到极致的”无环有向图(不想无向图，缩点连边后是一棵树。实际上是因为有向图有横叉边)

再仔细想想，如果此时的新图中，有两个或以上入度为0的点，那么这两个点肯定不能互相到达。

如果只有一个入度为0的点，以这个点为root，DFS遍历整个图，如果对于某个结点，他有两个或以上的儿子，那么这两棵或以上的子树上的点，就不能互相到达。说了这么多其实就是能形成一条单链。。。

那么，就来实现一下。

代码：

#include<cstdio>
#include<stack>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAXN 1000
#define MAXM 6000
int t,n,m;
struct node{
int v;
node *next;
}edge[MAXM+10],*adj[MAXN+10],*ecnt=&edge[0];
int dfn[MAXN+10],low[MAXN+10],dcnt,block_cnt,bccno[MAXN+10],in[MAXN+10],out[MAXN+10];
stack<int> point;
bool instack[MAXN+10],mat[MAXN+10][MAXN+10],vis[MAXN+10];
void reset()
{
memset(edge,0,sizeof(edge)); memset(adj,0,sizeof(adj)); ecnt=&edge[0];
memset(dfn,0,sizeof(dfn)); memset(low,0,sizeof(low)); memset(bccno,0,sizeof(bccno));
memset(in,0,sizeof(in)); memset(out,0,sizeof(out));
memset(instack,0,sizeof(instack)); memset(mat,0,sizeof(mat)); memset(vis,0,sizeof(vis));
dcnt=block_cnt=0;
}
void addedge(int u,int v)
{
node *p=++ecnt;
p->v=v;
p->next=adj[u];
adj[u]=p;
}
void read()
{
int x,y;
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++){
scanf("%d%d",&x,&y);
addedge(x,y);
mat[x][y]=true;
}
}
void dfs_find_SCC(int u,int fa)
{
point.push(u);
instack[u]=true;
dfn[u]=low[u]=++dcnt;
for(node *p=adj[u];p;p=p->next){
int v=p->v;
if(!dfn[v]){
dfs_find_SCC(v,u);
low[u]=min(low[u],low[v]);
}
else if(instack[v])
low[u]=min(low[u],dfn[v]);
}
if(dfn[u]==low[u]){
++block_cnt;
int uu;
do{
uu=point.top(); point.pop();
bccno[uu]=block_cnt;
instack[uu]=false;
}while(uu!=u);
}
}
void build_new_tree()
{
memset(edge,0,sizeof(edge));
memset(adj,0,sizeof(adj));
ecnt=&edge[0];
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++){
if(j==i) continue;
if(mat[i][j]&&bccno[i]!=bccno[j]){
addedge(bccno[i],bccno[j]);
out[bccno[i]]++,in[bccno[j]]++;
}
}
}
bool dfs_Judge(int u)
{
vis[u]=true;
int cnt=0;
for(node *p=adj[u];p;p=p->next){
int v=p->v;
if(!vis[v]){
cnt++;
bool f=dfs_Judge(v);
if(!f) return false;
}
}
if(cnt>=2) return false;
return true;
}
bool solve()
{
//最多只能有一个入度为0的点，如果有多个入度为0的点，则这两个连通分量肯定是不连通的
int incnt=0,rt=-1;
for(int i=1;i<=block_cnt;i++)
if(!in[i]) incnt++,rt=i;
if(incnt>1) return false;
if(dfs_Judge(rt)) return true;
else return false;
}

int main()
{
scanf("%d",&t);
for(int i=1;i<=t;i++){
reset();
read();
for(int i=1;i<=n;i++)
if(!dfn[i])
dfs_find_SCC(i,-1); //strongly connected componenet:强连通
build_new_tree();  //缩点，建树
bool f=solve();
if(f) printf("Yes\n");
else printf("No\n");
}
}

不大满意的地方:reset写得比较丑。。。。