UVA 11090 Going in Cycle!!（二分答案+判负环）

在加权有向图中求平均权值最小的回路。

一上手没有思路，看到“回路”，第一想法就是找连通分量，可又是加权图，没什么好思路，那就转换题意：由求回路权值->判负环，求最小值->常用二分答案。

二份答案，再利用利用bellman-ford判负环。

注意：

1、double：经常为了确定每个变量的类型，漏掉了某个变量，调半天心都凉了。干脆全变double。

2、没有告诉m的数据范围，要是在比赛中肯定有人问，要是reply是“read carefully”，总不能猜吧，乖乖用vector吧= =

3、原图为有向图，但不一定强连通，所以所有点要先入队才能找到全部的连通分量（就wa在这里）

 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<algorithm>
 #define clr(a,m) memset(a,m,sizeof(a))
 #define rep(i,a,b) for(int i=a;i<=b;i++)
 using namespace std;

 const int MAXN=;
 const int INF =1e8;
 const double eps=1e-;

 struct Edge{
     int u,v;
     double c;
 };

 int inq[MAXN],cnt[MAXN];
 double d[MAXN];
 vector<Edge>edge;
 vector<int>G[MAXN];

 void init(int n)
 {
     edge.clear();
     rep(i,,n)
         G[i].clear();
 }

 void add(int u,int v,double c)
 {
     edge.push_back((Edge){u,v,c});
     int m=edge.size();
     G[u].push_back(m-);
 }

 double build(int m)
 {
     int u,v;
     double c;
     double up=;
     rep(i,,m){
         scanf("%d%d%lf",&u,&v,&c);
         up=max(up,c);
         add(u,v,c);
     }
     return up;
 }

 bool BF(int st,int n)
 {
     clr(inq,);
     clr(cnt,);
     queue<int>q;
     rep(i,,n){
         if(i==st)d[i]=;
         else d[i]=INF;
         q.push(i);
     }
     while(!q.empty())
     {
         int u=q.front();q.pop();
         inq[u]=false;
         int sz=G[u].size();
         rep(i,,sz-){
             Edge e=edge[G[u][i]];
             if(d[e.v]>d[u]+e.c){
                 d[e.v]=d[u]+e.c;
                 if(!inq[e.v]){
                     q.push(e.v);
                     inq[e.v]=true;
                     if(++cnt[e.v]>n)
                         return true;
                 }
             }
         }
     }
     return false;
 }

 bool test(int n,int m,double x)
 {
     rep(i,,m-)
         edge[i].c-=x;
     bool flog=BF(,n);
     rep(i,,m-)
         edge[i].c+=x;
     return flog;
 }

 int main()
 {
     int T,n,m;
     scanf("%d",&T);
     for(int ans=;ans<=T;ans++)
     {
         scanf("%d%d",&n,&m);
         init(n);
         double up=build(m);

         printf("Case #%d: ",ans);
         if(!test(n,m,up+))
             printf("No cycle found.\n");
         else{
             double l=,r=up;
             while(r-l>eps)
             {
                 double x=l+(r-l)/;
                 if(test(n,m,x))
                     r=x;
                 else
                     l=x;
             }
             printf("%.2f\n",l);
         }
     }
     return ;
 }