UVA 11090 Going in Cycle!! SPFA判断负圈

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..
Constraints
• n ≤ 50
• a, b ≤ n
• c ≤ 10000000
Sample Input
2
2 1
1 2 1
2 2
1 2 2
2 1 3
Sample Output
Case #1: No cycle found.
Case #2: 2.50

//二分搜索答案 判断是否有负环
//假设存在一个有k条边的回路,平均值小于mid.
//则w1+w2+...+wk<k*mid
//即(w1-mid)+(w2-mid)+...+(wk-mid)<0
//转化为是否存在负环的问题,二分求解.

#include<stdio.h>
#include<string>
#include<cstring>
#include<queue>
#include<algorithm>
#include<functional>
#include<vector>
#include<iomanip>
#include<math.h>
#include<iostream>
#include<sstream>
#include<stack>
#include<set>
#include<bitset>
using namespace std;
const int INF=0x3f3f3f3f;
const double MIN=0.0001;
const int MAXN=55;
const int MAXM=MAXN*MAXN;
int T,N,M,E,a,b,c,MaxW;
int V[MAXM],Next[MAXM],First[MAXN],Cnt[MAXN];
double Dis[MAXN],W[MAXM];
bool Inque[MAXN];
void Init()
{
    E=MaxW=0;
    memset(First,-1,sizeof(First));
    memset(Next,-1,sizeof(Next));
}
void AddEdge(int a,int b,int c)
{
    V[E]=b;
    Next[E]=First[a];
    W[E]=c;
    First[a]=E++;
}
bool NegativeCycle()
{
    memset(Inque,false,sizeof(Inque));
    memset(Cnt,0,sizeof(Cnt));
    queue<int> que;
    for (int i=1;i<=N;i++)
    {
        que.push(i);
        Dis[i]=0;
    }
    while (!que.empty())
    {
        int u=que.front();
        que.pop();
        Inque[u]=false;
        for (int i=First[u];i!=-1;i=Next[i])
        {
            if (Dis[V[i]]>Dis[u]+W[i])
            {
                Dis[V[i]]=Dis[u]+W[i];
                if (!Inque[V[i]])
                {
                    que.push(V[i]),Inque[V[i]]=true;
                    if (++Cnt[V[i]]>N)
                        return true;
                }
            }
        }
    }
    return false;
}
bool Test(double x)
{
    bool flag;
    for (int i=0;i<E;i++)
        W[i]-=x;
    flag=NegativeCycle();
    for (int i=0;i<E;i++)
        W[i]+=x;
    return flag;
}
int main()
{
    scanf("%d",&T);
    for (int cases=1;cases<=T;cases++)
    {
        Init();
        scanf("%d%d",&N,&M);
        for (int i=0;i<M;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            MaxW=max(MaxW,c);
            AddEdge(a,b,c);
        }
        double low=0,mid,high=MaxW;
        if (!Test(high+1))
        {
            printf("Case #%d: No cycle found.\n",cases);
            continue;
        }
        while (high-low>MIN)
        {
            mid=(low+high)/2;
            if (Test(mid))
                high=mid;
            else
                low=mid;
        }
        printf("Case #%d: %.2f\n",cases,high);
    }
    return 0;
}