uva 11865 stream my contest

最新推荐文章于 2018-07-01 17:15:28 发布

qte_acm

最新推荐文章于 2018-07-01 17:15:28 发布

阅读量608

点赞数

CC 4.0 BY-SA版权

分类专栏：最小生成树、最小瓶颈路

本文链接：https://blog.youkuaiyun.com/zengchen__acmer/article/details/17323257

最小生成树、最小瓶颈路专栏收录该内容

17 篇文章

订阅专栏

本文介绍了一种利用二分法解决最小树形图问题的方法，通过将网线话费作为边权值，禁用宽带低于设定值的网线，并采用朱刘算法求解最小花费。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这明显是一个求最小树形图的题，只不过这个题多了一个限制条件。
因此问题可转化为：把每条网线的话费做为每条边的权值，而对于最小宽带最大化，可以用二分法来做。
让确定宽带是多少时，就禁用比这个宽带小的网线，然后再用朱刘算法来求最小花费，如果这个花费大于题目给出的限制那么就失败，否则成功。

代码：
#include
#include
#include
#include
#include
#include
using namespace std;

const int MAXN = 300;
const int inf = 0x3f3f3f3f ;
struct node
{
    int from , to , b , c;
    node(int from , int to , int b , int c)
    {
        this->from = from ;
        this->to = to;
        this->b = b;
        this->c= c;
    }
};
vectorgrap , grap1;
int pre[MAXN] , min_cost[MAXN];
int cost , n , m , root ;

void init()
{
    grap1.clear();
    memset(pre , 0 , sizeof(pre));
    root = 0;
}

bool solve(int maxb)
{
    long long ret = 0;
    int i;
    grap.clear();
    for(i = 0 ; i < grap1.size(); i++)
        if(grap1[i].b >= maxb)
            grap.push_back(grap1[i]);
    while(1)
    {
        for(i = 0 ; i < n; i++) min_cost[i] = inf;
        for(i = 0 ; i < grap.size() ; i++)
        {
            int u = grap[i].from , v = grap[i].to ;
            if(grap[i].c < min_cost[v] && u != v)
            {
                pre[v] = u;
                min_cost[v] = grap[i].c;
            }
        }
        for(i = 0; i < n; i++)
            if(min_cost[i] == inf && i != root) return false;
        int cntnode = 0 , vis[MAXN] , done[MAXN];
        memset(vis , -1 , sizeof(vis));
        memset(done , -1 , sizeof(done));
        min_cost[root] = 0;
        for(i = 0 ; i < n; i++)
        {
            ret += min_cost[i];
            int v = i;
            while(vis[v] != i && done[v] == -1 && v != root)
            {
                vis[v] = i;
                v = pre[v];
            }
            if(v != root && done[v] == -1)
            {
                for(int u = pre[v] ; u != v; u = pre[u])
                    done[u] = cntnode;
                done[v] = cntnode++;
            }
        }

        if(cntnode == 0) break;
        for(i = 0 ; i < n; i++)
            if(done[i] == -1) done[i] = cntnode++;
        for(i = 0 ; i < grap.size(); i++)
        {
            int v = grap[i].to ;
            grap[i].from = done[grap[i].from] ;
            grap[i].to = done[grap[i].to] ;
            if(grap[i].from != grap[i].to)    grap[i].c -= min_cost[v];
        }
        n = cntnode;
        root = done[root];
    }
    if(ret <= cost) return true;
    else return false;
}

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
    //    cout<<endl;
        scanf("%d %d %d" , &n , &m , &cost);
        init();
        int i , x , y , b , c , l = inf , r = 0;
        for(i = 0 ; i < m; i++)
        {
            scanf("%d %d %d %d" , &x , &y , &b , &c);
            grap1.push_back(node(x , y , b , c));
            if(b > r) r = b;
            if(b < l) l = b;
        }
        x = n;
        if(!solve(l)) {printf("streaming not possible.\n"); continue ;}
        while(l < r)
        {
            n = x;
            root = 0;
            int m = l + (r-l+1)/2;
            if(solve(m)) l = m;
            else r = m-1;

        }
        printf("%d kbps\n" , l);
    }
    return 0;
}