BZOJ 3130: [Sdoi2013]费用流

Description

Alice和Bob在图论课程上学习了最大流和最小费用最大流的相关知识。
最大流问题：给定一张有向图表示运输网络，一个源点S和一个汇点T，每条边都有最大流量。一个合法的网络流方案必须满足：(1)每条边的实际流量都不超过其最大流量且非负；(2)除了源点S和汇点T之外，对于其余所有点，都满足该点总流入流量等于该点总流出流量；而S点的净流出流量等于T点的净流入流量，这个值也即该网络流方案的总运输量。最大流问题就是对于给定的运输网络，求总运输量最大的网络流方案。

上图表示了一个最大流问题。对于每条边，右边的数代表该边的最大流量，左边的数代表在最优解中，该边的实际流量。需要注意到，一个最大流问题的解可能不是唯一的。 对于一张给定的运输网络，Alice先确定一个最大流，如果有多种解，Alice可以任选一种；之后Bob在每条边上分配单位花费（单位花费必须是非负实数），要求所有边的单位花费之和等于P。总费用等于每一条边的实际流量乘以该边的单位花费。需要注意到，Bob在分配单位花费之前，已经知道Alice所给出的最大流方案。现茌Alice希望总费用尽量小，而Bob希望总费用尽量大。我们想知道，如果两个人都执行最优策略，最大流的值和总费用分别为多少。
Input

第一行三个整数N，M，P。N表示给定运输网络中节点的数量，M表示有向边的数量，P的含义见问题描述部分。为了简化问题，我们假设源点S是点1，汇点T是点N。
接下来M行，每行三个整数A，B，C，表示有一条从点A到点B的有向边，其最大流量是C。

Output

第一行一个整数，表示最大流的值。
第二行一个实数，表示总费用。建议选手输出四位以上小数。
Sample Input
3 2 1

1 2 10

2 3 15
Sample Output
10

10.0000

HINT

【样例说明】

对于Alice，最大流的方案是固定的。两条边的实际流量都为10。

对于Bob，给第一条边分配0.5的费用，第二条边分配0.5的费用。总费用

为：10 × 0.5 + 10 × 0.5=10。可以证明不存在总费用更大的分配方案。

【数据规模和约定】

对于20%的测试数据：所有有向边的最大流量都是1。

对于100%的测试数据：N < = 100，M < = 1000。

对于l00%的测试数据：所有点的编号在I..N范围内。1 < = 每条边的最大流

量 < = 50000。1 < = P < = 10。给定运输网络中不会有起点和终点相同的边。

题解
第一问不会的出门左转网络流入门……
第二问不会的我也不会……

不闹了 。 首先根据贪心 ， Bob一定会把所有的P的单价分配到实际流量最大的边上。
稍微证明一下：
假设Bob在实际流量最大的边上分配了x的单价（0 <= x && x < P） 那么会有P-x的单价分配到其他边上 ，设实际流量最大的边的实际流量是 v_max ，那么对于其他边的v ， 有v <= v_max
相当于每次从最大流量的边上取走一个单位的流量就会损失 v_max - v 的费用。Bob当然不会这么做啦。。

那么剩下的就简单了 。 二分一个最大的流量 ， 强制让他的最大流量 <= mid , 跑一边Dinic ， 判断能否满流 ， 注意 ， 最后要×P才是费用 ， 本蒟蒻就是死在这个地方……

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
const int N = 110 , M = 1100;
inline int read()
{
    register int x = 0 , f = 0; register char c = getchar();
    while(c < '0' || c > '9') f |= c == '-' , c = getchar();
    while(c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0' , c = getchar();
    return f ? -x : x;
}
int n , m , P , cnt = 1 , S , T;
int head[N] , d[N];
struct edge{ int v , nex; long long c , C; } e[M<<1];
inline void add(int u , int v , long long c) { e[++cnt].v = v; e[cnt].nex = head[u]; e[cnt].C = c; head[u] = cnt; e[++cnt].v = u; e[cnt].nex = head[v] , e[cnt].C = 0; head[v] = cnt; return ; }
 
queue<int> q;
int bfs()
{
    for(int i = 1 ; i <= n ; ++i) d[i] = 0; d[1] = 1; q.push(1);
    while(q.size())
    {
        int x = q.front(); q.pop();
        for(int i = head[x] , v; i ; i = e[i].nex)
        {
            v = e[i].v; if(e[i].c == 0 || d[v]) continue;
            d[v] = d[x] + 1; q.push(v);
        }
    }
    return d[n];
}
 
long long dfs(int x , long long flow)
{
    if(x == T || flow == 0) return flow;
    long long res = 0 , k;
    for(int i = head[x] ,v ; i ; i = e[i].nex)
    {
        v = e[i].v; if(e[i].c == 0 || d[v] != d[x] + 1) continue;
        k = dfs(v , min(e[i].c , flow));
        if(k) 
        {
            e[i].c -= k; e[i^1].c += k; res += k; flow -= k;
            if(flow == 0) return res;
        }
        else d[v] = 0;
    }
    return res;
}
 
long long Dinic()
{
    long long ans = 0;
    while(bfs()) ans += dfs(S , 1e18);
    return ans;
}
 
inline long long Abs(long long x) { return x < 0 ? -x : x; }
 
int check(long long k , long long Max)
{
    for(int i = 2 ; i <= cnt ; i += 2) e[i].c = min(e[i].C , k) , e[i^1].c = 0;
    long long ans = Dinic();
    return ans == Max;
}
 
int main()
{
    n = read(); m = read(); P = read(); S = 1; T = n;
    for(int i = 1 , u , v , c; i <= m ; ++i) u = read() , v = read() , c = read() , add(u , v , (long long)c * 100000);
    for(int i = 2 ; i <= cnt ; i += 2) e[i].c = e[i].C , e[i^1].c = 0;
    long long l = 0 , r = 1e18 , mid , ans = -1 , Max = Dinic();
    printf("%lld
" , Max / 100000);
    while(l <= r)
    {
        mid = (l + r) >> 1;
        if(check(mid , Max)) r = mid - 1 , ans = mid; else l = mid + 1;
    }
    printf("%f
" , (double)ans * P / 100000.0); return 0; // 居然没有乘P……
}