[zjoi2010]cheese

题目：

                 贪吃的老鼠(cheese.c/cpp/pas/in/out)

                                         时限：每个测试点10秒

[问题描述]

          奶酪店里最近出现了m只老鼠！它们的目标就是把生产出来的所有奶酪都吃掉。奶酪店中一天会生产n块奶酪，其中第i块的大小为pi，会在第ri秒被生产出来，并且必须在第di秒之前将它吃掉。第j只老鼠吃奶酪的速度为sj，因此如果它单独吃完第i快奶酪所需的时间为pi/sj。老鼠们吃奶酪的习惯很独特，具体来说：

         (1) 在任一时刻，一只老鼠最多可以吃一块奶酪；

         (2) 在任一时刻，一块奶酪最多被一只老鼠吃。

          由于奶酪的保质期常常很短，为了将它们全部吃掉，老鼠们需要使用一种神奇的魔法来延长奶酪的保质期。将奶酪的保质期延长T秒是指所有的奶酪的di变成di+T。同时，使用魔法的代价很高，因此老鼠们希望找到最小的T使得可以吃掉所有的奶酪。

[输入数据]

          输入文件的第一行包含一个整数K，表示输入文件中数据的组数。

          每组数据的第一行包含两个整数n和m，分别表示奶酪和老鼠的数量。接下来的n行每行包含三个整数pi,ri,di。最后m行每行包含一个整数，表示sj。pi,ri,di,sj的含义如上文所述。

 [输出数据]

         输出文件中包含K行，每行包含一个实数，表示你找到的最小的T。你的答案和标准答案的绝对误差不应超过。

 

输入样例

2

2 2

13 0 4

10 1 3

4

2

1 1

1 0 2

1

 输出样例

0.5

0

 样例说明

  第一组数据中：

       l 第0到第1秒：第一只老鼠吃第一块奶酪；

       l 第1到第3.5秒：

       - 第一只老鼠吃第二块奶酪；

       - 第二只老鼠吃第一块奶酪；

       l 第3.5到第4.5秒：第一只老鼠吃第一块奶酪。

[数据范围]

 

思路：

  很好的一道题。。可惜我太弱了。。只想到要二分+网络流判定。。然后就什么也不会了。。只能看了题解。。

  本题比较难的是一个时间点只能有一只老鼠，而一个老鼠一个时间点只能吃一个。。

   朴素的建图是：

       让S向每个奶酪连边，流量为pi

       把老鼠按照时间段拆点，然后对于每个点， 向T连边，流量为该时间段能吃掉的奶酪数量

       并且把奶酪向每个时间段的老鼠连边，流量为流量为该时间段能吃掉的奶酪数量

       最后判断是否满流。。

   但是，这样会出现有一个时间点有两只老鼠吃完的情况。。。怎么办？

   题解就很巧了。。

   我们对老鼠吃的速度也进行分段， 每段为对于前一只老鼠的速度差。。

   试想一下，如果一个奶酪一个时间段（长度为T）内有若干只老鼠吃了，不妨设为为3只老鼠，a1，a2，a3，并且速度为s1,s2,s3, 同样假设s1< s2 < s3,

   那么是不是这一段时间内老鼠吃了T1*s1 + T2（s2-s1） + T3*(s3-s2) 

   那是不是就可以把老鼠某个时间段吃的方案等价于多少个速度差吃的方案~~

   so，构图如下：

            让S向每个奶酪连边，流量为pi

 

                 对于每个速度段（第j段为sj）进行拆点为vij'按照时间段(假设时间长为t)拆点，然后对于每个点， 向T连边，流量为该时间段该速度段sj在t时间内的产（sj*t*j）

 

                 并且把奶酪向每个时间段的速度段vij连边，流量为sj*t

 

                 最后判断是否满流。。

    这样一来，每个速度段在每个时间段最多只有出现一个，这样就满足一对一的情况。。

    好吧。。说的很混乱。。直接上代码吧。。

 

code：

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <vector>
#define maxn 1200
#define Inf 0x3fffffff
#define maxm 210000
#define eps 1e-8
#define M0(a) memset(a, 0, sizeof(a))
using namespace std;
int cmp(double x, double y){
    return fabs(x - y) <= eps;
}
int sgn(double x){
    return (x > eps) - (x < -eps); 
}
struct oo{
      int y, next;
      double f;
};
struct MaxFlow{
       int n, S, T, tot;
       int son[maxn], dist[maxn], gap[maxn];
       oo e[maxm];
       double sap(int x, double aug){
           if (x == T) return aug;
           int mind = n;
           double sum = 0, f;
           for (int p = son[x]; p != -1; p = e[p].next){
                  int y = e[p].y;
                  if (dist[y] + 1 == dist[x] && e[p].f){
                       f = sap(y, min(e[p].f, aug - sum));
                       e[p].f -= f;
                       e[p^1].f += f;
                       sum += f;
                       if (sum == aug || dist[S] >= n) return sum;
                  }
                  if (e[p].f) mind = min(mind, dist[y]);
           }
           if (!sum){
               if (!(--gap[dist[x]])) dist[S] = n;
               ++gap[dist[x] = mind + 1];
           }
           return sum;
       }

       void add(int x, int y, double f){
            e[tot].y = y; e[tot].f = f;
            e[tot].next = son[x]; son[x] = tot++;
            e[tot].y = x; e[tot].f = 0;
            e[tot].next = son[y]; son[y] = tot++;
       }

       void init(int S, int T, int n){
            memset(son, -1, sizeof(son));
            tot = 0;
            this->S = S, this->T = T, this->n = n;
       }
       double maxflow(){
            M0(gap);
            M0(dist);
            gap[0] = n;
            double ans = 0;
            while (dist[S] < n) ans += sap(S, Inf);
            return ans;
       }
} F;
int n, m, p[maxn], r[maxn], d[maxn], s[maxn];

void init(){
     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]);
     sort(s+1, s+1+m, greater<int>());
     for (int i = 1; i < m; ++i) 
         s[i] -= s[i+1];
}

int check(double add){
    vector<double> v;
    for (int i = 1; i <= n; ++i)
         v.push_back(r[i]), v.push_back(d[i]+add);
    sort(v.begin(), v.end());
    v.erase(unique(v.begin(), v.end(), cmp), v.end());
    int S = 0,  T = m*(v.size()-1)+n+1;
    F.init(0, T, T+1);
    for (int i = 1; i <= n; ++i)
       F.add(S, i, p[i]);
    for (int i = 0; i + 1 < (int)v.size(); ++i){
         double dur = v[i+1]-v[i];
         for (int j = 1; j <= m; ++j)
             F.add(i * m + n + j, T, j*s[j]*dur);
         for (int j = 1; j <= n; ++j) 
             if (sgn(r[j]-v[i]) <= 0 && sgn(d[j]+add-v[i+1]) >= 0)
                for (int k = 1; k <= m; ++k)
                    F.add(j, n+i*m+k, dur*s[k]);   
    }
    double sum = 0;
    for (int i = 1; i <= n; ++i)
       sum += p[i];
    double flow = F.maxflow();
    return sgn(flow - sum) == 0; 
}

void solve(){
     double l = 0, r = 3000000;
     for (int i = 0; i < 40; ++i){
         double mid = (l + r) / 2.0;
         check(mid) ? r = mid : l = mid;
     }
     printf("%.7lf\n", l);     
}

int main(){
    freopen("a.in", "r", stdin);
    freopen("a.out", "w", stdout);
    int T;
    scanf("%d", &T);
    while (T--){
          init();
          solve();      
    }
}