Luogu2570 ZJOI2010 贪吃的老鼠 二分答案+最大流

题目链接：https://www.luogu.org/problemnew/show/P2570

题意概述：

　　好像没什么好概述的.....很简洁？

分析：

　　首先想到二分时间，转化成判定性问题，在一定时间内可不可以把奶酪吃完。

　　对于判定性问题，能不能在限制下达成吃完这个指标，可以想到最大流来解决（求限制下吃蛋糕的最大体积）。

　　把蛋糕的生产和过期看成两个事件，可以发现在事件发生的间隔所有老鼠的行为不会有新的选择出现，即能吃的奶酪就那些，问题的性质不发生改变。那么按照事件的发生和结束把事件间隔的时间段离散成一个个点，具体来说这一步是把老鼠拆开了。

　　　　1.每个新点向时间段内存在的每个奶酪连边，容量为inf。

　　　　2.源点向每个老鼠的点连边，容量为si*len，si表示老鼠吃奶酪的速度，len表示时间段的长度。

　　　　3.每个奶酪向汇点连边，容量为奶酪的体积pi，只要奶酪向汇点连的边满流，那么奶酪就是吃完了。

　　不难发现这样建图保证了每个老鼠只能在同一时间吃一块奶酪，因为我们限定了老鼠吃奶酪的最大体积，只要吃的体积满足限制，那么就一定不会同一时间吃多块奶酪，反之不合法。

　　但是还没有保证一块奶酪只能被一只老鼠吃。此题最妙的地方就在对这里的处理，思考一下我们对上个限制的理解，只要限制了上界，那么就一定可以在合法意义下构造出一个方案！为了构造出合法方案，我们先把所有的速度降序排序，然后进行差分，把每只老鼠的速度变成v[i]=s[i]-s[i+1]。

　　　　1.原点向每只老鼠连边，容量为len*i*v[i]。（这里的限制包含了对ii小于i的老鼠的限制）

　　　　2.每只老鼠向奶酪连边，容量为len*v[i]。

　　　　3.每块奶酪向汇点连边，容量为p[i]。

　　解释一下，对于每只老鼠只能吃一块奶酪的限制，我们限制了所有老鼠吃奶酪总量的上界，因此一定可以构造出合法意义下的解。同事对于一个时间段内的奶酪，所有老鼠的速度最大为s[i]，两种情况达到最大值都是所有的边满流。

　　理解的关键：只要最后最大流满流，显然我们可以找到一种构造流量的方法，把差分之后的速度还原为原来的速度。还原流量的时候从小到大考虑。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<cctype>
using namespace std;
const int MAXN=35;
const double eps=1e-7;

int K,N,M,P[MAXN],R[MAXN],D[MAXN],S[MAXN];
double sump;
struct NET{
    static const int maxn=2005;
    static const int maxm=120000;
    static const double inf=1e9;
    struct edge{ int from,to,next; double cap,flow; }E[maxm];
    int n,s,t,first[maxn],np,d[maxn],gap[maxn],cur[maxn],fl[maxn];
    struct event{
        double p; int id;
        friend bool operator < (event x,event y){
            return x.p<y.p;
        }
    }e[65]; bool vis[35];
    NET(){ n=np=0,s=2001,t=2002; }
    void add_edge(int u,int v,double cap){
        E[++np]=(edge){u,v,first[u],cap,0};
        first[u]=np;
        E[++np]=(edge){v,u,first[v],0,0};
        first[v]=np;
    }
    void build(double m){
        memset(first,0,sizeof(first));
        np=n=0;
        for(int i=1;i<=N;i++) add_edge(++n,t,P[i]);
        int cnt=0;
        for(int i=1;i<=N;i++){
            e[++cnt]=(event){R[i],i};
            e[++cnt]=(event){D[i]+m,i};
        } 
        sort(e+1,e+cnt+1);
        memset(vis,0,sizeof(vis));
        int i=1,k=0;
        vis[e[1].id]^=1;
        while(i<cnt&&e[i+1].p-e[i].p<eps) vis[e[++i].id]^=1;
        double last=e[i++].p;
        while(i<=cnt){
            for(int j=1;j<=M;j++){
                add_edge(s,n+k*M+j,j*S[j]*(e[i].p-last));
                for(int l=1;l<=N;l++)
                    if(vis[l]) add_edge(n+k*M+j,l,S[j]*(e[i].p-last));
            }
            vis[e[i].id]^=1;
            while(i<cnt&&e[i+1].p-e[i].p<eps) vis[e[++i].id]^=1;
            k++,last=e[i++].p;
        }
        n+=k*M+2;
    }
    void BFS(){
        queue<int>q;
        for(int i=1;i<=n-2;i++) d[i]=n;
        d[s]=d[t]=n;
        q.push(t); d[t]=0;
        while(!q.empty()){
            int i=q.front(); q.pop();
            for(int p=first[i];p;p=E[p].next){
                int j=E[p].to,pp=(p-1^1)+1;
                if(d[j]==n&&fabs(E[pp].cap-E[pp].flow)>eps) d[j]=d[i]+1,q.push(j);
            }
        }
    }
    double augment(){
        int now=t; double flow=inf;
        while(now!=s){
            flow=min(flow,E[fl[now]].cap-E[fl[now]].flow);
            now=E[fl[now]].from;
        }
        now=t;
        while(now!=s){
            E[fl[now]].flow+=flow,E[(fl[now]-1^1)+1].flow-=flow;
            now=E[fl[now]].from;
        }
        return flow;
    }
    double ISAP(){
        memcpy(cur,first,sizeof(cur));
        memset(gap,0,sizeof(gap));
        BFS();
        for(int i=1;i<=n-2;i++) gap[d[i]]++;
        gap[d[s]]++,gap[d[t]]++;
        int now=s; double flow=0;
        while(d[s]<n){
            if(now==t) flow+=augment(),now=s;
            bool ok=0;
            for(int p=cur[now];p;p=E[p].next){
                int j=E[p].to;
                if(fabs(E[p].cap-E[p].flow)>eps&&d[j]+1==d[now]){
                    ok=1,fl[j]=cur[now]=p,now=j;
                    break;
                }
            }
            if(!ok){
                int minl=n;
                for(int p=first[now];p;p=E[p].next){
                    int j=E[p].to;
                    if(fabs(E[p].cap-E[p].flow)>eps&&d[j]+1<minl) minl=d[j]+1;
                }
                if(--gap[d[now]]==0) break;
                gap[d[now]=minl]++;
                cur[now]=first[now];
                if(now!=s) now=E[fl[now]].from;
            }
        }
        return flow;
    }
}net;

void data_in()
{
    scanf("%d%d",&N,&M);
    for(int i=1;i<=N;i++) scanf("%d%d%d",&P[i],&R[i],&D[i]);
    for(int i=1;i<=M;i++) scanf("%d",&S[i]);
}
bool check(double mid)
{
    net.build(mid);
    return fabs(net.ISAP()-sump)<eps;
}
bool cmp(int x,int y){ return x>y; }
void work()
{
    sort(S+1,S+M+1,cmp);
    for(int i=1;i<M;i++) S[i]=S[i]-S[i+1];
    sump=0;
    for(int i=1;i<=N;i++) sump+=P[i];
    double A=0,B=sump/S[M]+1.0,mid,ans;
    while(B-A>=eps){
        mid=(A+B)/2;
        if(check(mid)) ans=mid,B=mid;
        else A=mid;
    }
    printf("%f
",ans);
}
int main()
{
    scanf("%d",&K);
    for(int i=1;i<=K;i++){
        data_in();
        work();
    }
    return 0;
}