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=;
 const double eps=1e-;

 int K,N,M,P[MAXN],R[MAXN],D[MAXN],S[MAXN];
 double sump;
 struct NET{
     static const int maxn=;
     static const int maxm=;
     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[]; bool vis[];
     NET(){ n=np=,s=,t=; }
     void add_edge(int u,int v,double cap){
         E[++np]=(edge){u,v,first[u],cap,};
         first[u]=np;
         E[++np]=(edge){v,u,first[v],,};
         first[v]=np;
     }
     void build(double m){
         memset(first,,sizeof(first));
         np=n=;
         for(int i=;i<=N;i++) add_edge(++n,t,P[i]);
         int cnt=;
         for(int i=;i<=N;i++){
             e[++cnt]=(event){R[i],i};
             e[++cnt]=(event){D[i]+m,i};
         }
         sort(e+,e+cnt+);
         memset(vis,,sizeof(vis));
         int i=,k=;
         vis[e[].id]^=;
         while(i<cnt&&e[i+].p-e[i].p<eps) vis[e[++i].id]^=;
         double last=e[i++].p;
         while(i<=cnt){
             for(int j=;j<=M;j++){
                 add_edge(s,n+k*M+j,j*S[j]*(e[i].p-last));
                 for(int l=;l<=N;l++)
                     if(vis[l]) add_edge(n+k*M+j,l,S[j]*(e[i].p-last));
             }
             vis[e[i].id]^=;
             while(i<cnt&&e[i+].p-e[i].p<eps) vis[e[++i].id]^=;
             k++,last=e[i++].p;
         }
         n+=k*M+;
     }
     void BFS(){
         queue<int>q;
         for(int i=;i<=n-;i++) d[i]=n;
         d[s]=d[t]=n;
         q.push(t); d[t]=;
         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-^)+;
                 if(d[j]==n&&fabs(E[pp].cap-E[pp].flow)>eps) d[j]=d[i]+,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]-^)+].flow-=flow;
             now=E[fl[now]].from;
         }
         return flow;
     }
     double ISAP(){
         memcpy(cur,first,sizeof(cur));
         memset(gap,,sizeof(gap));
         BFS();
         for(int i=;i<=n-;i++) gap[d[i]]++;
         gap[d[s]]++,gap[d[t]]++;
         int now=s; double flow=;
         while(d[s]<n){
             if(now==t) flow+=augment(),now=s;
             bool ok=;
             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]+==d[now]){
                     ok=,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]+<minl) minl=d[j]+;
                 }
                 if(--gap[d[now]]==) 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=;i<=N;i++) scanf("%d%d%d",&P[i],&R[i],&D[i]);
     for(int i=;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+,S+M+,cmp);
     for(int i=;i<M;i++) S[i]=S[i]-S[i+];
     sump=;
     for(int i=;i<=N;i++) sump+=P[i];
     double A=,B=sump/S[M]+1.0,mid,ans;
     while(B-A>=eps){
         mid=(A+B)/;
         if(check(mid)) ans=mid,B=mid;
         else A=mid;
     }
     printf("%f\n",ans);
 }
 int main()
 {
     scanf("%d",&K);
     for(int i=;i<=K;i++){
         data_in();
         work();
     }
     return ;
 }