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

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

题意：有n个山洞m条路，问任意两点x,y能否存在从x到y或者从y到x。

思路：

1、注意是或而不是和，所以“缩点”后，由于“缩点”内的点相互可达，所以不需要管“缩点”内的点。注意，不是判断强连通的数量为1，而是判断是否是弱连通。

2、如果两点不可达那么在拓扑排序时，该两点谁也不是谁的前驱和后继，所以在拓扑排序时只要同时出现至少两个入度为０的点，那么这些点一定互不可达，所以只要判断拓扑的方式是否唯一即可。

第一种方法：只要用拓扑判断入度为0的点是否为1个，如果有多个，就出现在分叉，不可能从x到y。

第二种方法：从入度为0的点DFS搜索最长能到达的路径如果路径长度等于点数，说明可以从源点访问完所有点。

知识充电：

强连通图：在有向图中, 若对于每一对顶点v1和v2, 都存在一条从v1到v2和从v2到v1的路径,则称此图是强连通图.

弱连通图：将有向图的所有的有向边替换为无向边，所得到的图称为原图的基图。如果一个有向图的基图是连通图，则有向图是弱连通图。

单向连通图：如果有向图中，对于任意节点v1和v2，至少存在从v1到v2和从v2到v1的路径中的一条，则原图为单向连通图。

三者之间的关系是，强连通图必然是单向连通的，单向连通图必然是弱连通图。

CODE：

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

#define MAXN 50010
#define MAXM 100010

struct Edge
{
int v, next;
}edge[MAXM], edge2[MAXM];

int first[MAXN], first2[MAXN],stack[MAXN], ins[MAXN], dfn[MAXN], low[MAXN];
int belong[MAXM];
int ind[MAXN], outd[MAXN], topo[MAXN];

int n, m;
int cnt, cnt2;
int scnt, top, tot;

void init()
{
cnt = 0, cnt2 = 0;
scnt = top = tot = 0;
memset(dfn, 0, sizeof(dfn));
memset(first, -1, sizeof(first));
memset(first2, -1, sizeof(first2));
memset(ins, 0, sizeof(ins));
memset(ind, 0, sizeof(ind));
//memset(outd, 0, sizeof(outd));
//memset(topo, 0, sizeof(topo));
}

void read_graph(int u, int v)
{
edge[cnt].v = v;
edge[cnt].next = first[u];
first[u] = cnt++;
}

void read_graph2(int u, int v) //重构图
{
edge2[cnt2].v = v;
edge2[cnt2].next = first2[u], first2[u] = cnt2++;
}

void dfs(int u)
{
int v;
dfn[u] = low[u] = ++tot;
ins[u] = 1;
stack[top++] = u;
for(int e = first[u]; e != -1; e = edge[e].next)
{
v = edge[e].v;
if(!dfn[v])
{
dfs(v);
low[u] = min(low[u], low[v]);
}
else if(ins[v])
{
low[u] = min(low[u], dfn[v]);
}
}
if(dfn[u] == low[u])
{
scnt++;
do
{
v = stack[--top];
belong[v] = scnt;
ins[v] = 0;
}while(v != u);
}
}

void Tarjan()
{
for(int v = 1; v <= n; v++) if(!dfn[v])
dfs(v);
} //Tarjan

int toposort()
{
queue<int> q;
int tot2 = 0;
for(int i = 1; i <= scnt; i++) if(!ind[i]) q.push(i);
if(q.size() > 1) return 0;
while(!q.empty())
{
int x = q.front(); q.pop();
topo[++tot2] = x;
for(int e = first2[x]; e != -1; e = edge2[e].next)
{
int v = edge2[e].v;
if(--ind[v] == 0)
{
q.push(v);
}
}
if(q.size() > 1) return 0;
}
if(tot2 != scnt) return 0;
else return 1;
} //toposort

void solve()
{
Tarjan();
for(int u = 1; u <= n; u++) //重构图
{
for(int e = first[u]; e != -1; e = edge[e].next)
{
int v = edge[e].v;
if(belong[u] != belong[v])
{
ind[belong[v]]++;
read_graph2(belong[u], belong[v]);
}
}
}
if(toposort()) printf("Yes\n");
else printf("No\n");
}

int main()
{
int T;
scanf("%d", &T);
while(T--)
{
init();
scanf("%d%d", &n, &m);
while(m--)
{
int u, v;
scanf("%d%d", &u, &v);
read_graph(u, v);
}
solve();
}
return 0;
}