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

最新推荐文章于 2022-05-14 20:48:37 发布

转载最新推荐文章于 2022-05-14 20:48:37 发布 · 76 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/wiklvrain/p/8179370.html

本文介绍了一种通过计算有向图的强连通分量来判断任意两点是否可达的方法。利用Tarjan算法找到所有强连通分量，并进一步通过缩点后的图判断其是否构成链状结构。

题目大意：

给出一个有向图，这个图，是否存在任意两点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;
}

转载于:https://www.cnblogs.com/wiklvrain/p/8179370.html