UVA 11090 Going in Cycle!!(Bellman-Ford推断负圈)

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#define eps 1e-4
#define LL long long
using namespace std;

const int maxn = 100 + 5;
const int INF = 0x3f3f3f3f;

//Bellman-Ford算法
struct Edge {
int from, to;
double dist;
Edge(int u = 0, int v = 0, double d = 0) : from(u), to(v), dist(d) {
}
};
struct BellmanFord{
int n, m;
vector<Edge> edges;
vector<int> G[maxn];
bool inq[maxn];
double d[maxn];
int p[maxn];
int cnt[maxn];

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

void AddEdges(int from, int to, int dist) {
edges.push_back(Edge(from, to, dist));
m = edges.size();
G[from].push_back(m-1);
}

bool negetiveCycle() {
queue<int> Q;
memset(inq, 0, sizeof(inq));
memset(cnt, 0, sizeof(cnt));
for(int i = 0; i < n; i++) {
d[i] = 0; inq[0] = true; Q.push(i);
}
while(!Q.empty()) {
int u = Q.front(); Q.pop();
inq[u] = false;
for(int i = 0; i < G[u].size(); i++) {
Edge& e = edges[G[u][i]];
if(d[e.to]>d[u]+e.dist) {
d[e.to] = d[u] + e.dist;
p[e.to] = G[u][i];
if(!inq[e.to]) {
Q.push(e.to);
inq[e.to] = true;
if(++cnt[e.to] > n) return true;
}
}
}
}
return false;
}

} solver;

int n, m;
bool test(double w) {
for(int i = 0; i < m; i++) solver.edges[i].dist -= w;
int t = solver.negetiveCycle();
for(int i = 0; i < m; i++) solver.edges[i].dist += w;
return t;
}

int kase;
int main() {
freopen("input.txt", "r", stdin);
int t; cin >> t;
while(t--) {
cin >> n >> m;
solver.init(n);
for(int i = 0; i < m; i++) {
int u, v, d;
cin >> u >> v >> d;
u--; v--;
solver.AddEdges(u, v, d);
}
double L = -10000001, R = 10000001;
if(!test(R)) printf("Case #%d: No cycle found.\n", ++kase);
else {
while(R-L>eps) {
double M = (R+L)/2;
if(test(M)) R = M;
else L = M;
}
printf("Case #%d: %.2lf\n", ++kase, R);
}
}
return 0;
}