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 = 65;
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 = 0;
    
    int res = 0;
    
    int tn = n;
    
    for (int i = 0;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 (1)
    {
        //printf("2333
");    
        
        memset(in,inf,sizeof(in));
        
        for (int i = 0;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 = 0;i < tn;i++)
        {
            if (i != root && in[i] == inf)
                return -1;
        }
        
        int cnt = 0;
        
        memset(id,-1,sizeof(id));
        memset(vis,-1,sizeof(vis));
        
        in[root] = 0;
        
        for (int i = 0;i < tn;i++)
        {
            res += in[i];
            
            int v = i;
            
            while (vis[v] != i && id[v] == -1 && v != root)
            {
                vis[v] = i;
                v = pre[v];
            }
            
            if (id[v] == -1 && v != root)
            {
                for (int u = pre[v];u != v;u = pre[u])
                {
                    id[u] = cnt;
                }
                
                id[v] = cnt++;
            }
        }
        
        if (cnt == 0) break;
        
        for (int i = 0;i < tn;i++)
        {
            if (id[i] == -1) id[i] = cnt++;
        }
        
        for (int i = 0;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 -1;
    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 = 0;
        
        for (int i = 0;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) == -1)
        {
            printf("streaming not possible.
");
        }
        else
        {
            while (mxb - mnb > 1)
            {
                //printf("***
");
                int mid = (mxb + mnb) >> 1;
                
                if (meet(mid) != -1) mnb = mid;
                else mxb = mid - 1;
            }
            
            while (meet(mnb+1) != -1) mnb++;
            
            printf("%d kbps
",mnb);
        }
    }
    
    return 0;
}