[ZJOI2010]贪吃的老鼠 网络流

～～～题面～～～

题解：

这是一道强题emmmm，做法非常巧妙，，，我也是看了好久大佬题解才看明白一点

首先考虑没有限制的情况，即n个老鼠可以在同一时刻吃同一块奶酪

对各个时间段拆点，连奶酪 ---> 老鼠（反过来也是一样的，只不过不方便），相连的奶酪要符合时间段的限制，

相当于把老鼠拆成很多个小时刻，连向这个时刻它可以吃的奶酪，流量为它在这段时间内可以吃的奶酪总量，

限流可以在汇点到老鼠的路径上进行。

但这个并不能满足同一时刻一块奶酪只能被一个老鼠吃这个条件，因此我们对老鼠再拆点，

把每个老鼠拆成的小时刻再根据速度差分，

比如8 4 2 1，四只老鼠。差分后就是：

8 - 4 = 4；

4 - 2 = 2；

2 - 1 = 1；

1 - 1 = 1；

然后按照编号来定权值

流量就为编号 * 速度（差分后） * 时间；

为什么这样？

8 = 4 + 2 + 1 + 1

4 = 2 + 1 + 1

2 = 1 + 1

1 = 1

可以很明显看到这是一个三角形，且每层都是相同的数字，对应到我们差分数组，对于每个差分后的速度，刚好有编号个，

这样就可以保证总的流量合法了。

那为什么这样可以保证同一时刻只有一只老鼠呢？

可以这样感性的理解：

注意到任意一只老鼠都可以由差分数组凑出，那么不管网络流怎样跑出答案，我们都可以通过分解一下流量，加加减减之类的数学方法凑成这几只老鼠，因此是合法的。

也就是说网络流跑出的东西也许跟原图不一样，但它可以用来判断是否合法（满流即合法），这就够了。

因此我们二分答案，每次都重新建图，跑最大流，满流为true，else 为 false。

代码有点长（打的isap），改成dinic应该会短很多

(数组开这么小是卡常后的结果，，，，）

 #include<bits/stdc++.h>
 using namespace std;
 #define R register int
 #define AC 5000
 #define ac 20000
 #define eps 1e-6
 int x, n, m, T, cnt, tmp, ss, tt;
 int p[AC], v[AC], last[AC];
 double all, ll, rr, mid, ans, addflow;
 double r[AC], d[AC], haveflow[ac], t[AC];
 int Head[AC], Next[ac], date[ac], tot;
 int good[AC], have[AC], c[AC];
 int q[AC], tail, head;
 /*神奇的网络流，，，，
 对每个时间点进行离散化*/
 inline int read()
 {
     int x = ;char c = getchar();
     while(c > '' || c < '') c = getchar();
     while(c >= '' && c <= '') x = x *  + c - '', c = getchar();
     return x;
 }

 inline void upmin(double &a, double b)
 {
     if(b < a) a = b;
 }

 inline void add(int f, int w, double S)
 {
     date[++tot] = w, Next[tot] = Head[f], haveflow[tot] = S, Head[f] = tot;
     date[++tot] = f, Next[tot] = Head[w], Head[w] = tot;
     //printf("%d ---> %d %.4lf\n",f,w,S);
 }

 bool bfs()
 {
     int x, now;
     head = tail = ;
     c[tt] = , have[] = , q[++tail] = tt;
     while(head < tail)
     {
         x = q[++head];
         for(R i = Head[x]; i ; i = Next[i])
         {
             now = date[i];
             if(haveflow[i ^ ] && !c[now])
             {
                 c[now] = c[x] + ;
                 q[++tail] = now;
                 ++have[c[now]];
             }
         }
     }
     memcpy(good, Head, sizeof(Head));
     return c[ss];
 }

 void aru()
 {
     while(x != ss)
     {
         haveflow[last[x]] -= addflow;
         haveflow[last[x] ^ ] += addflow;
         x = date[last[x] ^ ];
     }
     ans += addflow;
 }

 double isap()
 {
     int now; bool done;
     x = ss, addflow = INT_MAX;
     while(c[ss] != ac + )
     {
         if(x == tt) aru(), addflow = INT_MAX;
         done=false;
         for(R i = good[x]; i ; i = Next[i])
         {
             now = date[i];
             if(c[now] == c[x] -  && haveflow[i])
             {
                 last[now] = i;
                 upmin(addflow, haveflow[i]);
                 good[x] = i;
                 done = true;
                 x = now;
             }
         }
         if(!done)
         {
             int go = ac;
             for(R i = Head[x]; i ; i = Next[i])
             {
                 now = date[i];
                 if(haveflow[i] && c[now]) go = c[now];
             }
             if(!(--have[c[x]])) break;
             ++have[c[x] = go + ];
             good[x] = Head[x];
             if(x != ss) x = date[last[x] ^ ];//这是回到上一个节点啊
         }
     }
     return ans;
 }

 inline bool cmp(double a, double b)
 {
     return a > b;
 }

 void pre()
 {
     tot = , all = ;
     n = read() ,m = read();
     for(R i = ; i <= n; i++)
     {
         p[i] = read(), r[i] = read(), d[i] = read();
         all += (double)p[i];
     }
     for(R i = ; i <= m; i++) v[i] = read();
     sort(v + , v + m + , cmp);//error！！！老鼠是m只！！！！不是n只！！！
     rr = (double) all / (double)v[] + 1.0, ll = ;
     for(R i = ; i < m; i++) v[i] -= v[i + ];//对速度差分
 }       

 void build()
 {
     tot = , ans = ;
     memset(Head, , sizeof(Head));//应该要放这里重置吧
     memset(have, , sizeof(have));
     memset(c, , sizeof(c));
     for(R i = ; i <= n; i++)
     {
         add(ss, i, p[i]);
         t[ * i - ] = r[i], t[ * i] = d[i] + mid;//为离散化做准备
     }
     sort(t + , t +  * n + );//准备离散化了
     cnt =  , tmp = n;//因为不能和前n个奶酪的编号重了
     int a =  * n;
     t[a + ] = INT_MAX;//不然最后一个点进不来
     for(R i = ; i <= a; i++)
         if(t[i + ] - t[i] > eps) t[++cnt] = t[i];//去重
     for(R i = ; i <= m; i++)//枚举老鼠
     {
         for(R j = ; j <= cnt; j++)//因为要两个时间点才组成一个时间段
         {
             ++tmp;
             add(tmp, tt, i * v[i] * (t[j] - t[j - ]));//连离散化的老鼠到汇点
             for(R k = ; k <= n; k++)//枚举奶酪
             {
                 if(r[k] - t[j-] < eps && (d[k] + mid - t[j] > - eps))
                     add(k, tmp, v[i] * (t[j] - t[j - ]));//连奶酪向老鼠
             }//r可以小于t（早就开始了），所以负数也合法，后面是同理的，只是移项了tarjan123

         }
     }
 }

 void half()
 {
     ss =  * m * n + n + , tt = ss + ;//error!!!ss是要2 * m * n + n + 1啊
     while(rr - ll > eps)
     {
         mid = (rr + ll) / 2.0;
         build();
         if(bfs() && all - isap() < eps) rr = mid;
         else ll = mid;
         //printf("%.4lf\n",ans);
         //printf("%.4lf %.4lf\n\n",ll,rr);
     }
     printf("%lf\n", ll);
 }

 void work()
 {
     T=read();
     while(T--)
     {
         pre();
         half();
     }

 }

 int main()
 {
 //    freopen("in.in","r",stdin);
     //freopen("cheese.out","w",stdout);
     work();
 //    fclose(stdin);
     //fclose(stdout);
     return ;
 }