[LOJ.AC]#117. 有源汇有上下界最小流

题目描述

n 个点，m 条边，每条边 e 有一个流量下界 $\text{lower}(e)$ 和流量上界 $\text{upper}(e)$，给定源点 $s$ 与汇点 $t$，求源点到汇点的最小流。

输入格式

第一行两个正整数 $n$、$m$、$s$、$t$。

之后的 $m$ 行，每行四个整数 $s$、$t$、$\text{lower}$、$\text{upper}$。

输出格式

如果无解，输出一行 please go home to sleep。

否则输出最小流。

样例

样例输入
7 12 6 7
6 1 0 2147483647
1 7 0 2147483647
6 2 0 2147483647
2 7 0 2147483647
6 3 0 2147483647
3 7 0 2147483647
6 4 0 2147483647
4 7 0 2147483647
6 5 0 2147483647
5 7 0 2147483647
5 1 1 2147483647
3 4 1 2147483647
样例输出
2

数据范围与提示
$1≤n≤50003,1≤m≤125003$

题解：

rep(i, E) {
    //scanf("%d%d%d%d", &x, &y, &b, &c);
    read(x);read(y);read(b);read(c);
    add_edge(x, y, c - b);
    add_edge(x, T, b);
    add_edge(S, y, b);
}
max_flow(S, T);
add_edge(t, s, INF);
max_flow(S, T);

处理掉流量下限后，我们要尽量让 s 发出到 t 的流量少，所以先对（超级源汇点） S 到 T 跑最大流，优先 S 发出到 T 的流量，当然很可能不会满流，然后 add_edge(t, s, INF)，然后对 S 到 T 再跑最大流，如果满流，那么 s 流出 或 t 流入的总流量（不包括添加的那条 (t, s, INF) 边）就是答案。
严格证明表示不会，在网上爬了好多文章，也没有看谁有证明过程。

当然也可以二分 添加的 t -> s 边的容量上限，这方法显然是没毛病的。

AC code

#include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
//#include <unordered_map>
//#include <unordered_set>
#include <vector>
//#pragma comment(linker, "/STACK:336777216")
using namespace std;

#define mp make_pair
#define pb push_back
#define se second
#define fi first
#define rep(i, n) for(int i = 0; i < n; ++i)

typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair<int, int> pii;

const int MOD = (int)1e9 + 7;
const int INF = 0x3f3f3f3f;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;
const db PI = acos(-1.0);
const db EPS = 1e-10;


const int MAXS = 64 * 1024 * 1024;
char buf[MAXS], *ch;
void read(int &x) {
    int t = 1;
    while(*ch <= 32) ++ch;
    //if(*ch == '-') ++ch, t = -1;
    for(x = 0; *ch >= '0'; ++ch) x = x * 10 + *ch - 48;
    //x = t * x;
}
void read_init() {
    fread(buf, sizeof(char), MAXS, stdin);
    ch = buf;
}


const int MAXV = 50030<<1;
const int MAXE = 125030*6;

int V, E;

struct edge{
    int to, cap, nxt;
    edge() {}
    edge(const int _to, const int _cap, const int _nxt) {
        to = _to;
        cap = _cap;
        nxt = _nxt;
    }
}dat[MAXE];

int head[MAXV], lever[MAXV], iter[MAXV], tail;

void add_edge(int from, int to, int cap) {
    dat[tail] = edge(to, cap, head[from]);
    head[from] = tail++;
    dat[tail] = edge(from, 0, head[to]);
    head[to] = tail++;
}

queue<int> que;
void bfs(int s, int t) {
    memset(lever, 0xff, sizeof(int) * (t + 1));
    lever[s] = 0;
    que.push(s);
    while(!que.empty()) {
        int v = que.front(); que.pop();
        for(int i = head[v]; ~i; i = dat[i].nxt) {
            edge &e = dat[i];
            if(lever[e.to] < 0 && e.cap > 0) {
                lever[e.to] = lever[v] + 1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int u, int t, int f) {
    if(u == t) return f;
    for(int &v = iter[u]; ~v; v = dat[v].nxt) {
        edge &e = dat[v];
        if(lever[e.to] > lever[u] && e.cap > 0) {
            int d = dfs(e.to, t, min(e.cap, f));
            if(d > 0) {
                e.cap -= d;
                dat[v^1].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s, int t) {
    int res = 0, f;
    while(true) {
        bfs(s, t);
        if(lever[t] < 0) return res;
        memcpy(iter, head, sizeof(int) * (t + 1));
        while((f = dfs(s, t, INF))) res += f;
    }
}

int main()
{
    read_init();
    //scanf("%d%d", &V, &E);
    int s, t;
    read(V); read(E); read(s); read(t);
    int S = 0, T = V<<1|1;
    memset(head, 0xff, sizeof(head));
    tail = 0;
    int x, y, b, c;
    rep(i, E) {
        //scanf("%d%d%d%d", &x, &y, &b, &c);
        read(x);read(y);read(b);read(c);
        add_edge(x, y, c - b);
        add_edge(x, T, b);
        add_edge(S, y, b);
    }
    max_flow(S, T);
    add_edge(t, s, INF);
    max_flow(S, T);
    int _flow = 0;
    bool ans = true;
    for(int v = head[S]; ~v && ans; v = dat[v].nxt) {
        if(dat[v].cap != 0) ans = false;
    }
    for(int v = dat[head[s]].nxt; ~v && ans; v = dat[v].nxt) {
        _flow += dat[v^1].cap;
    }
    if(ans) {
        printf("%d\n", _flow);
    } else {
        puts("please go home to sleep");
    }
    return 0;
}