图论trainning-part-1 D. Going in Cycle!!

D. Going in Cycle!!

Time Limit: 3000ms

Memory Limit: 131072KB

64-bit integer IO format: %lld      Java class name: Main

 

You are given a weighted directed graph with n vertices and m edges. Each cycle in the graph has a weight, which equals to sum of its edges. There are so many cycles in the graph with different weights. In this problem we want to find a cycle with the minimum mean.

 

Input 

The first line of input gives the number of cases, N. N test cases follow. Each one starts with two numbers n and m. m lines follow, each has three positive number a, b, c which means there is an edge from vertex a to b with weight of c.

 

Output

For each test case output one line containing Case #x: followed by a number that is the lowest mean cycle in graph with 2 digits after decimal place, if there is a cycle. Otherwise print No cycle found..

 

- n ≤ 50

- a, b ≤ n

- c ≤ 10000000

Sample Input

2
2 1
1 2 1
2 2
1 2 2
2 1 3

Output for Sample Input

Case #1: No cycle found.

Case #2: 2.50

解题：二分+spfa负权回路判定

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <climits>
#include <algorithm>
#include <cmath>
#include <queue>
#define LL long long
#define INF 0x3f3f3ff
using namespace std;
const int maxn = 60;
const double exps = 1e-3;
struct arc {
    int to;
    double w;
};

vector<arc>g[maxn];
int cnt[maxn],n,m;
double d[maxn];
bool vis[maxn];
bool spfa() {
    int i,j,v,u;
    queue<int>q;
    for(i = 1; i <= n; i++) {
        q.push(i);
        d[i] = INF;
        vis[i] = true;
        cnt[i] = 1;
    }
    d[1] = 0;
    while(!q.empty()) {
        u = q.front();
        q.pop();
        vis[u] = false;
        for(i = 0; i < g[u].size(); i++) {
            v = g[u][i].to;
            if(d[v] > d[u]+g[u][i].w) {
                d[v] = d[u]+g[u][i].w;
                if(!vis[v]) {
                    vis[v] = true;
                    cnt[v]++;
                    q.push(v);
                    if(cnt[u] > n) return true;

                }
            }
        }
    }
    return false;
}
void modify(double val) {
    for(int i = 1; i <= n; i++) {
        for(int j = 0; j < g[i].size(); j++) {
            g[i][j].w += val;
        }
    }
}
bool test(double val) {
    modify(-val);
    bool it =  spfa();
    modify(val);
    return it;
}
int main() {
    int t,i,j,u,v,k = 1;
    double lt,rt,mid,w;
    scanf("%d",&t);
    while(t--) {
        scanf("%d%d",&n,&m);
        for(i = 0; i <= n; i++)
            g[i].clear();
        lt = INF;
        rt = 0;
        for(i = 0; i < m; i++) {
            scanf("%d%d%lf",&u,&v,&w);
            g[u].push_back((arc) {v,w});
            if(lt > w) lt = w;
            if(w > rt) rt = w;
        }
        printf("Case #%d: ",k++);
        if(test(rt+1.0)) {
            while(rt-lt > exps) {
                mid = lt+(rt-lt)/2;
                if(test(mid)) rt = mid;
                else lt = mid;
            }
            printf("%.2f
",rt);
        } else printf("No cycle found.
");
    }
    return 0;
}