uva 11478 - Halum（BellmanFold）

题目链接：uva 11478 - Halum

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;
const int maxn = 505;
//const double eps = 1e-3;

struct BellmanFord {

	struct Edge {
		int u, v, d;
		Edge(int u = 0, int v = 0, int d = 0):u(u), v(v), d(d) {}
	};

	int n, m;
	vector<Edge> edges;
	vector<int> G[maxn];
	bool inq[maxn];
	int d[maxn], p[maxn], c[maxn];

	void init (int n) {
		this->n = n;
		edges.clear();
		for (int i = 0; i < n; i++) G[i].clear();
	}

	void addEdge (int u, int v, int d) {
		edges.push_back(Edge(u, v, d));
		m = edges.size();
		G[u].push_back(m-1);
	}

	bool negativeCycle() {
		queue<int> que;
		memset(c, 0, sizeof(c));
		memset(inq, 0, sizeof(inq));

		for (int i = 0; i < n; i++) {
			d[i] = 0, inq[i] = true;
			que.push(i);
		}

		while (!que.empty()) {
			int u = que.front();
			que.pop();
			inq[u] = false;

			for (int i = 0; i < G[u].size(); i++) {
				Edge& e = edges[G[u][i]];
				if (d[e.v] > d[u] + e.d) {
					d[e.v] = d[u] + e.d;
					p[e.v] = G[u][i];
					if (!inq[e.v]) {
						que.push(e.v);
						inq[e.v] = true;
						if (++c[e.v] > n) return true;
					}
				}
			}
		}
		return false;
	}
}solver;

int N, M, T;

void init () {
	solver.init(N+1);
	T = 0;

	int u, v, d;
	for (int i = 0; i < M; i++) {
		scanf("%d%d%d", &u, &v, &d);
		solver.addEdge(u, v, d);
		T = max(T, d);
	}
	for (int i = 1; i <= N; i++)
		solver.addEdge(0, i, 0);
}

bool judge(int x) {
	for (int i = 0; i < solver.m; i++) solver.edges[i].d -= x;
	bool ret = solver.negativeCycle();
	for (int i = 0; i < solver.m; i++) solver.edges[i].d += x;
	return !ret;
}

int main () {
	while (scanf("%d%d", &N, &M) == 2) {
		init();
		if (!judge(1)) printf("No Solution\n");
		else if (judge(T+1)) printf("Infinite\n");
		else {
			int l = 1, r = T+1;
			while (l < r - 1) {
				int mid = (l + r) >> 1;
				if (judge(mid)) l = mid;
				else r = mid;
			}
			printf("%d\n", l);
		}
	}
	return 0;
}