uvalive 11865 Stream My Contest

题意：

有一个网络中心，和许多个城市，网络中心以及城市之间有若干条边，这些边有两个属性，最大带宽和修建费用。

现在要用最多不超过C的费用修建网络，使得每个城市都有网络连接，最大化最小带宽。

带宽限制是，一条边可以接受不大于自己最大值的带宽。

边是有向边，unidirectional。

思路：

最大化最小值，那么考虑到用二分，但是这题应该有一个隐藏条件，那就是带宽越大，修建费用越高，这样才满足二分的条件。

然后有向边，就用最小树形图的朱刘算法，复杂度为O(n^3)，由于n的规模比较小，所以可以接受。

注意，需要先特判输入中的最小带宽是否满足要求。

代码：

 #include <stdio.h>
 #include <string.h>
 #include <vector>
 #include <algorithm>
 using namespace std;

 const int N = ;
 const int inf = 0x3f3f3f3f;

 int in[N],vis[N],pre[N],id[N];

 struct edge
 {
     int from,to,cost;

     edge(int a,int b,int c)
     {
         from = a;
         to = b;
         cost = c;
     }
 };

 struct node
 {
     int from,to,bd,cost;

     node(int a,int b,int c,int d)
     {
         from = a;
         to = b;
         bd = c;
         cost = d;
     }
 };

 vector<node> ns;
 vector<edge> es;

 int n,m,sumc;

 int meet(int lim)
 {
     es.clear();

     int root = ;

     int res = ;

     int tn = n;

     for (int i = ;i < m;i++)
     {
         int a = ns[i].from,b = ns[i].to,c = ns[i].bd,d = ns[i].cost;

         if (c < lim) continue;

         es.push_back(edge(a,b,d));
     }

     while ()
     {
         //printf("2333\n");    

         memset(in,inf,sizeof(in));

         for (int i = ;i < es.size();i++)
         {
             edge e = es[i];

             int to = e.to;

             if (e.from != e.to && e.cost < in[to])
             {
                 in[to] = e.cost;
                 pre[to] = e.from;
             }
         }

         for (int i = ;i < tn;i++)
         {
             if (i != root && in[i] == inf)
                 return -;
         }

         int cnt = ;

         memset(id,-,sizeof(id));
         memset(vis,-,sizeof(vis));

         in[root] = ;

         for (int i = ;i < tn;i++)
         {
             res += in[i];

             int v = i;

             while (vis[v] != i && id[v] == - && v != root)
             {
                 vis[v] = i;
                 v = pre[v];
             }

             if (id[v] == - && v != root)
             {
                 for (int u = pre[v];u != v;u = pre[u])
                 {
                     id[u] = cnt;
                 }

                 id[v] = cnt++;
             }
         }

         if (cnt == ) break;

         for (int i = ;i < tn;i++)
         {
             if (id[i] == -) id[i] = cnt++;
         }

         for (int i = ;i < es.size();i++)
         {
             int to = es[i].to;

             es[i].from = id[es[i].from];
             es[i].to = id[es[i].to];

             if (es[i].from != es[i].to)
             {
                 es[i].cost -= in[to];
             }
         }

         root = id[root];
         tn = cnt;
     }

     if (res > sumc) return -;
     else return res;
 }

 int main()
 {
     int t;

     scanf("%d",&t);

     while (t--)
     {
         scanf("%d%d%d",&n,&m,&sumc);

         ns.clear();

         int mnb = inf,mxb = ;

         for (int i = ;i < m;i++)
         {
             int a,b,c,d;

             scanf("%d%d%d%d",&a,&b,&c,&d);

             ns.push_back(node(a,b,c,d));

             mxb = max(mxb,c);
             mnb = min(mnb,c);
         }

         if (meet(mnb) == -)
         {
             printf("streaming not possible.\n");
         }
         else
         {
             while (mxb - mnb > )
             {
                 //printf("***\n");
                 int mid = (mxb + mnb) >> ;

                 if (meet(mid) != -) mnb = mid;
                 else mxb = mid - ;
             }

             while (meet(mnb+) != -) mnb++;

             printf("%d kbps\n",mnb);
         }
     }

     return ;
 }