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

题目大意：

给出一个有向图，这个图，是否存在任意两点a,b可达，这里的任意两点a,b可达是说，只要从a能到b或者只要能从b到a就算是可达的。

解题思路：

先求出这个图的强连通分量，然后缩点建图，只要这个图是一条链状的，那么就可以满足任意两点都可达，否则不满足。

原因是只要这个缩点建图之后的图是链状的，那么必然从链的头到尾，任意两点都可达。一旦不是链状，要么出现分叉，要么某个点入度>=2，这种情况在分叉的两端都是无法可达的。所以只需要是链状就可以了。这个可以用拓扑排序来做，也可以直接一遍dfs求出。

代码：

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

typedef struct node {
int v, nxt;
node(int a = 0, int b = 0) {
v = a; nxt = b;
}
}Edge;

const int maxn = 1005;
const int maxm = 12010;

int n, m;
stack<int> s;
Edge edge[maxm];
int ComponetNumber;
int tot, head[maxn];
int inComponet[maxn];
vector<int> vec[maxn];
int inx, inStack[maxn];
int low[maxn], dfn[maxn];
vector<int> Componet[maxn];
int in[maxn], out[maxn], vis[maxn];

void init() {
inx = tot = ComponetNumber = 0;
while (!s.empty()) s.pop();
memset(in, 0, sizeof(in));
memset(dfn, 0, sizeof(dfn));
memset(low, 0, sizeof(low));
memset(out, 0, sizeof(out));
memset(vis, 0, sizeof(vis));
memset(head, -1, sizeof(head));
memset(inStack, 0, sizeof(inStack));
for (int i = 0; i < maxn; ++i) {
vec[i].clear();
Componet[i].clear();
}
}
void add(int u, int v) {
edge[tot] = Edge(v, head[u]);
head[u] = tot++;
}
void tarjan(int x) {
dfn[x] = low[x] = ++inx;
inStack[x] = 2;
s.push(x);

for (int i = head[x]; ~i; i = edge[i].nxt) {
int v = edge[i].v;
if (!dfn[v]) {
tarjan(v);
low[x] = min(low[x], low[v]);
} else if (inStack[v] == 2) {
low[x] = min(low[x], dfn[v]);
}
}

if (dfn[x] == low[x]) {
++ComponetNumber;
while(!s.empty()){
int v = s.top(); s.pop();
inStack[v] = 1;
Componet[ComponetNumber].push_back(v);
inComponet[v] = ComponetNumber;
if (v == x) break;
}
}
}
void dfs(int p) {
vis[p] = 1;
int len = vec[p].size();
for (int i = 0; i < len; ++i) {
if (!vis[vec[p][i]]) dfs(vec[p][i]);
}
if (len > 1) vis[p] = 0;
}
int main() {
ios::sync_with_stdio(false); cin.tie(0);
int a, b, t; cin >> t;
while (t--) {
cin >> n >> m; init();
for (int i = 0; i < m; ++i) {
cin >> a >> b;
add(a, b);
}
for (int i = 1; i <= n; ++i) {
if (!dfn[i]) tarjan(i);
}
for (int i = 1; i <= n; ++i) {
for (int j = head[i]; ~j; j = edge[j].nxt) {
int v = edge[j].v;
if (inComponet[i] != inComponet[v]) {
++in[inComponet[v]];
++out[inComponet[i]];
vec[inComponet[i]].push_back(inComponet[v]);
}
}
}
for (int i = 1; i <= ComponetNumber; ++i) {
if (!in[i]) { dfs(i); break; }
}
int flag = 1;
for (int i = 1; i <= ComponetNumber; ++i) {
if (!vis[i]) flag = 0;
}
if (flag) cout << "Yes\n";
else cout << "No\n";
}
return 0;
}