bzoj3993 [SDOI2015]星际战争（double网络流）

题目链接

分析：
这道题竟然是Round 1，我觉得我完了。。。

这道题异常的刁钻：时间是double类型的
我的第一个反应就是二分答案
显然答案是具有单调性的，因此可以二分答案

如果知道了攻击时间，那么每个激光输出的总伤害就可以确定了
问题就变成了类似于bzoj2756 奇怪的游戏的模型

二分图，
X部是机器人，Y部是激光
S向X连边，容量是ta的装甲值，Y向T连边，容量是这段时间的伤害输出
X和Y之间的连边依照输入的攻击矩阵，容量为INF
跑完最大流之后，判断是否大于所有机器人的装甲值之和

tip

一开始担心精度问题，看了一眼前辈的blog，其中一句话可谓是醍醐灌顶：

为了防止精度问题，我们可以先*1000000

精度精度，我们可以乘一个大数来解决
（然而这道题是可以直接用double完成的）

第一遍写完了之后，拍了一下，发现只有40%的数据是对的
后来发现是变量搞错了（m*n的矩阵）

有的前辈直接修改图上的流量，然而这样还要回复流量，比较麻烦

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>

using namespace std;

const double INF=1e9;
const double eps=1e-7;
const int N=55;
int A[N],B[N],n,m,s,t,cur[N<<1],st[N<<1],tot;
int mp[N][N],deep[N<<1];
double sum;
struct node{
    double v;
    int y,nxt;
};
node way[N*N*2];

int dcmp(double x)
{
    if (fabs(x)<eps) return 0;
    else if (x<0) return -1;
    else return 1;
}

void add(int u,int w,double z)
{
    tot++;
    way[tot].y=w;way[tot].v=z;way[tot].nxt=st[u];st[u]=tot;
    tot++;
    way[tot].y=u;way[tot].v=0.0;way[tot].nxt=st[w];st[w]=tot;
}

void build(double X)
{
    for (int i=1;i<=n;i++) add(i+m,t,(double)A[i]);    //机器人 
    for (int i=1;i<=m;i++) add(s,i,(double)B[i]*X);    //激光 
    for (int i=1;i<=m;i++)  
        for (int j=1;j<=n;j++)
            if (mp[i][j])
                add(i,j+m,INF);   //X部是激光，Y部是机器人
}

int bfs(int s,int t)
{
    queue<int> Q;
    Q.push(s);
    memset(deep,-1,sizeof(deep));
    for (int i=s;i<=t;i++) cur[i]=st[i];
    deep[s]=1;
    while (!Q.empty())
    {
        int now=Q.front(); Q.pop();
        for (int i=st[now];i!=-1;i=way[i].nxt)
            if (dcmp(way[i].v)>0&&deep[way[i].y]==-1)
            {
                deep[way[i].y]=deep[now]+1;
                if (way[i].y==t) return 1;
                Q.push(way[i].y);
            }
    }
    return 0;
}

double dfs(int now,int t,double limit)
{
    if (now==t||dcmp(limit)==0) return limit;
    double f,flow=0.0;
    for (int i=cur[now];i!=-1;i=way[i].nxt)
    {
        cur[now]=i;
        if (dcmp(way[i].v)>0&&deep[way[i].y]==deep[now]+1&&(f=dfs(way[i].y,t,min(limit,way[i].v))))
        {
            flow+=f;
            limit-=f;
            way[i].v-=f;way[i^1].v+=f;
            if (dcmp(limit)==0) break;
        }
    }
    return flow;    
}

double dinic(int s,int t)
{
    double ans=0;
    while (bfs(s,t))
        ans+=dfs(s,t,INF);
    return ans;
}

int pd(double X)
{
    memset(st,-1,sizeof(st)); tot=-1;
    build(X);
    double tt=dinic(s,t);
    if (dcmp(tt-sum)>=0) return 1;
    else return 0;
}

double erfen(double L,double R)
{
    double M,ans=0;
    while (R-L>eps)
    {
        M=(R+L)/2.0;
        if (pd(M))
           ans=M,R=M;
        else L=M;
    }
    return ans;
}

int main()
{
    scanf("%d%d",&n,&m);
    sum=0; s=0; t=n+m+1;
    for (int i=1;i<=n;i++) scanf("%d",&A[i]),sum+=(double)A[i];
    for (int i=1;i<=m;i++) scanf("%d",&B[i]);
    for (int i=1;i<=m;i++) 
        for (int j=1;j<=n;j++) scanf("%d",&mp[i][j]);

    printf("%0.6lf",erfen(0.0,sum));
    return 0;
}