[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 = 0;char c = getchar();
    while(c > '9' || c < '0') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', 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 = 0;
    c[tt] = 1, have[1] = 1, q[++tail] = tt;
    while(head < tail)
    {
        x = q[++head];
        for(R i = Head[x]; i ; i = Next[i])
        {
            now = date[i];
            if(haveflow[i ^ 1] && !c[now])
            {
                c[now] = c[x] + 1;
                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] ^ 1] += addflow;
        x = date[last[x] ^ 1];
    }
    ans += addflow;
}

double isap()
{
    int now; bool done;
    x = ss, addflow = INT_MAX;
    while(c[ss] != ac + 1)
    {
        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] - 1 && 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 + 1];
            good[x] = Head[x];
            if(x != ss) x = date[last[x] ^ 1];//这是回到上一个节点啊  
        }
    }    
    return ans;
}

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

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

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

void half()
{
    ss = 2 * m * n + n + 1, tt = ss + 1;//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 0;
}