网络流学习笔记（二）—— 最小费用最大流

最小费用最大流：在保证最大流的前提下，让费用最小。

在求解最大流时，我们在残量网络上不断贪心地增广而得到了最大流。
现在边上多了费用，为了使最后总费用最小，我们自然能想到每次贪心地在残量网络上，沿着费用最小的那条路进行增广。
此时残量网络中的反向边费用应该是原边费用的相反数，以保证退流操作是可逆、正确的。
而此时图中就有可能出现负边权，所以只能使用 SPFA。

用 SPFA 先处理出最短路径（是费用的最短路）。
无论是正向边还是反向边，他的残量都不可能是负的且不能等于 0，因为残量为 0 就没有增广路了呀。
pre[i] 记录到点 i 的边。调用的时候类似 head[]。
増广时用这条路径的最短边处理残量。

#include <bits/stdc++.h>
#define mp make_pair

using namespace std;
typedef pair<int, int> par;
const int N = 5e4 + 5, inf = 0x7fffffff;

int n, m, s, t;
int head[N];

struct Edge {
    int u, to, next, w, cost;
}e[N << 1];

int cnt = 1;
void add(int a, int b, int c, int d) {
    e[++ cnt].to = b;
    e[cnt].u = a;
    e[cnt].w = c;
    e[cnt].cost = d;
    e[cnt].next = head[a];
    head[a] = cnt;  
}

int pre[N], vis[N], dis[N];
bool spfa(int x) {
    queue<int> q;
    memset(pre, 0, sizeof(pre));
    memset(vis, 0, sizeof(vis));
    for (int i = 1; i <= n; i ++) dis[i] = inf;

    dis[x] = 0, vis[x] = 1; q.push(x);
    while (!q.empty()) {
        int u = q.front(); q.pop(); vis[u] = 0; 
        for (int i = head[u]; i; i = e[i].next) {
            int v = e[i].to;
            if (e[i].w) {
                if (dis[u] + e[i].cost < dis[v]) { // 注意我们找的是费用的最短路 
                    dis[v] = dis[u] + e[i].cost; pre[v] = i;
                    if (!vis[v]) { vis[v] = 1; q.push(v); }
                }
            }
        } 
    }
    if(dis[t] == inf) return 0;
    return 1;
}

par mcmf() {
    int ans = 0, flow = 0, tem;
    while (spfa(s)) {
        tem = inf;
        for (int i = pre[t]; i; i = pre[e[i].u]) tem = min(tem, e[i].w);

        for (int i = pre[t]; i; i = pre[e[i].u]) {
            e[i].w -= tem;
            e[i ^ 1].w += tem;
            ans += tem * e[i].cost;
        }
        flow += tem;
    }
    return mp(flow, ans);
}

int main() {
    scanf("%d%d%d%d", &n, &m, &s, &t);
    for (int i = 1; i <= m; i ++){
        int u, v, w, f;
        scanf("%d%d%d%d", &u, &v, &w, &f);
        add(u, v, w, f), add(v, u, 0, -f);
    }
    par ans = mcmf();
    printf("%d %d\n", ans.first, ans.second);
    return 0;   
}