zoukankan      html  css  js  c++  java
  • bzoj千题计划131:bzoj3993: [SDOI2015]星际战争

    http://www.lydsy.com/JudgeOnline/problem.php?id=3993

    二分答案

    源点向武器连 mid*攻击力的边

    机器人向汇点连 防御力 的边

    武器i能攻击机器人j,i向j连 >=j防御力的边

    判断最大流是否=防御力

    将时间、防御力 * 10000,避免浮点数运算

    #include<queue>
    #include<cstdio>
    #include<cstring>
    #include<iostream>
    
    using namespace std;
    
    #define N 2502
    #define M 2601
    #define inf 1e18
    
    typedef long long LL;
    
    int n,m;
    LL sum;
    
    int src,decc;
    
    LL recovery[51],attack[51];
    int mp[51][51];
    
    int tot;
    int front[N],nxt[M<<1],to[M<<1],from[M<<1];
    LL val[M<<1];
    
    int lev[N],num[N];
    
    int cur[N];
    int path[N];
    
    void read(int &x)
    {
        x=0; char c=getchar();
        while(!isdigit(c)) c=getchar();
        while(isdigit(c)) { x=x*10+c-'0'; c=getchar(); }
    }
    
    void read(LL &x)
    {
        x=0; char c=getchar();
        while(!isdigit(c)) c=getchar();
        while(isdigit(c)) { x=x*10+c-'0'; c=getchar(); }
    }
    
    void add(int u,int v,LL w)
    {
        to[++tot]=v; nxt[tot]=front[u]; front[u]=tot; val[tot]=w; from[tot]=u;
        to[++tot]=u; nxt[tot]=front[v]; front[v]=tot; val[tot]=0; from[tot]=v;
        //cout<<u<<' '<<v<<' '<<w<<'
    ';
    }
    
    void rebuild(LL mid)
    {
        tot=1;
        memset(front,0,sizeof(front));
        for(int i=1;i<=m;++i) add(src,i,mid*attack[i]);
        for(int i=1;i<=n;++i) add(m+i,decc,recovery[i]);
        for(int i=1;i<=m;++i)
            for(int j=1;j<=n;++j)
                if(mp[i][j]) add(i,m+j,recovery[j]);
    }
    
    bool bfs()
    {
        queue<int>q;
        for(int i=src;i<=decc;++i) lev[i]=decc;
        lev[decc]=0;
        q.push(decc);
        int now,t;
        while(!q.empty())
        {
            now=q.front();
            q.pop();
            for(int i=front[now];i;i=nxt[i])
            {
                t=to[i];
                if(lev[t]==decc && val[i^1])
                {
                    lev[t]=lev[now]+1;
                    q.push(t);
                }
            }
        }
        return lev[src]!=decc;
    }
    
    LL augment()
    {
        int now=decc;
        LL flow=inf;
        int i;
        while(now!=src)
        {
            i=path[now];
            flow=min(flow,val[i]);
            now=from[i];
        }
        now=decc;
        while(now!=src)
        {
            i=path[now];
            val[i]-=flow;
            val[i^1]+=flow;
            now=from[i];
        }
        return flow;
    }
    
    LL isap(int mid)
    {
        LL flow=0;
        if(!bfs()) return 0;
        memset(num,0,sizeof(num));
        for(int i=src;i<=decc;++i) num[lev[i]]++,cur[i]=front[i];
        int now=src,t;
        while(lev[src]<=decc)
        {
            if(now==decc)
            {
                flow+=augment();
                now=src;
            }
            bool advanced=false;
            for(int i=cur[now];i;i=nxt[i])
            {
                t=to[i];
                if(val[i]>0 && lev[t]==lev[now]-1)
                {
                    advanced=true;
                    path[t]=i;
                    cur[now]=i;
                    now=t;
                    break;
                }
            }
            if(!advanced)
            {
                int mi=decc-1;
                for(int i=front[now];i;i=nxt[i])
                    if(val[i]) mi=min(mi,lev[to[i]]);
                if(!--num[lev[now]]) break;
                num[lev[now]=mi+1]++;
                cur[now]=front[now];
                if(now!=src) now=from[path[now]];
            }
        }
        return flow;
    }
    
    bool check(int mid)
    {
        rebuild(mid);
        return isap(mid)==sum;
    }
    
    int main()
    {
        read(n); read(m);
        decc=n+m+1;
        for(int i=1;i<=n;++i) 
        {
            read(recovery[i]);
            recovery[i]*=10000;
            sum+=recovery[i];
        }
        for(int i=1;i<=m;++i) 
        {
            read(attack[i]);
            //attack[i]*=1000;
        }
        for(int i=1;i<=m;++i)
            for(int j=1;j<=n;++j)
                read(mp[i][j]);
        LL l=0,r=1000000000,mid,ans;
        while(l<=r)
        {
            mid=l+r>>1;
            if(check(mid)) ans=mid,r=mid-1;
            else l=mid+1;
        }
        printf("%.3lf",ans*1.0/10000);
    }

    3993: [SDOI2015]星际战争

    Time Limit: 10 Sec  Memory Limit: 128 MBSec  Special Judge
    Submit: 1629  Solved: 736
    [Submit][Status][Discuss]

    Description

     3333年,在银河系的某星球上,X军团和Y军团正在激烈地作战。在战斗的某一阶段,Y军团一共派遣了N个巨型机器人进攻X军团的阵地,其中第i个巨型机器人的装甲值为Ai。当一个巨型机器人的装甲值减少到0或者以下时,这个巨型机器人就被摧毁了。X军团有M个激光武器,其中第i个激光武器每秒可以削减一个巨型机器人Bi的装甲值。激光武器的攻击是连续的。这种激光武器非常奇怪,一个激光武器只能攻击一些特定的敌人。Y军团看到自己的巨型机器人被X军团一个一个消灭,他们急需下达更多的指令。为了这个目标,Y军团需要知道X军团最少需要用多长时间才能将Y军团的所有巨型机器人摧毁。但是他们不会计算这个问题,因此向你求助。

    Input

    第一行,两个整数,N、M。

    第二行,N个整数,A1、A2…AN。
    第三行,M个整数,B1、B2…BM。
    接下来的M行,每行N个整数,这些整数均为0或者1。这部分中的第i行的第j个整数为0表示第i个激光武器不可以攻击第j个巨型机器人,为1表示第i个激光武器可以攻击第j个巨型机器人。

    Output

     一行,一个实数,表示X军团要摧毁Y军团的所有巨型机器人最少需要的时间。输出结果与标准答案的绝对误差不超过10-3即视为正确。

    Sample Input

    2 2
    3 10
    4 6
    0 1
    1 1

    Sample Output

    1.300000

    HINT

     【样例说明1】


    战斗开始后的前0.5秒,激光武器1攻击2号巨型机器人,激光武器2攻击1号巨型机器人。1号巨型机器人被完全摧毁,2号巨型机器人还剩余8的装甲值;

    接下来的0.8秒,激光武器1、2同时攻击2号巨型机器人。2号巨型机器人被完全摧毁。

    对于全部的数据,1<=N, M<=50,1<=Ai<=105,1<=Bi<=1000,输入数据保证X军团一定能摧毁Y军团的所有巨型机器人
  • 相关阅读:
    SpringMVC框架学习笔记(一)
    Spring框架学习笔记(四)
    Spring框架学习笔记(三)
    Spring框架学习笔记(二)
    Spring框架学习笔记(一)
    单点登录与权限管理本质:cookie安全问题
    单点登录与权限管理本质:单点登录介绍
    单点登录与权限管理本质:HTTP重定向
    单点登录与权限管理本质:session和cookie介绍
    「单点登录与权限管理」系列概述
  • 原文地址:https://www.cnblogs.com/TheRoadToTheGold/p/8029478.html
Copyright © 2011-2022 走看看