最小费用最大流(luogu P3381 【模板】最小费用最大流)

题目链接

题目描述

如题，给出一个网络图，以及其源点和汇点，每条边已知其最大流量和单位流量费用，求出其网络最大流和在最大流情况下的最小费用。

输入输出格式

输入格式：

第一行包含四个正整数N、M、S、T，分别表示点的个数、有向边的个数、源点序号、汇点序号。

接下来M行每行包含四个正整数ui、vi、wi、fi，表示第i条有向边从ui出发，到达vi，边权为wi（即该边最大流量为wi），单位流量的费用为fi。

输出格式：

一行，包含两个整数，依次为最大流量和在最大流量情况下的最小费用。

输入输出样例

输入样例#1： 

4 5 4 3
4 2 30 2
4 3 20 3
2 3 20 1
2 1 30 9
1 3 40 5

输出样例#1： 

50 280

费用流模板：

在最大流的前提下，费用最小。由EK算法扩展。EK每次用bfs增广，把bfs改成spfa找到一条花费最小的路径即可，然后拿这条路去优化答案。

不会EK的先去拿EK写道最大流，不会spfa的拿spfa写道最短路径在往下看。

然后建边的时候反向弧的费用为正向弧的相反数，走反向弧相当于不走这一段边，那么最短路径部分当然要消除这一段的影响。

AC代码

#include <bits/stdc++.h>


using namespace std;
const int MAXN = 5010;
const int MAXM = 50010;
const int INF = 0x7FFFFFFF;

int n, m, first[MAXN], s, t, sign;

int max_flow, min_cost;

struct Edge {
    int to, cap, cost, next;
} edge[MAXM * 2];

inline void init() {
    for(int i = 0; i <= n; i++ ) {
        first[i] = -1;
    }
    sign = 0;
}

inline void add_edge(int u, int v, int cap, int cost) {
    edge[sign].to = v, edge[sign].cap = cap, edge[sign].cost = cost;
    edge[sign].next = first[u], first[u] = sign ++;
    edge[sign].to = u, edge[sign].cap = 0, edge[sign].cost = -cost;
    edge[sign].next = first[v], first[v] = sign ++;
}

int dist[MAXN], inq[MAXN], pre[MAXN], incf[MAXN];

bool spfa(int s, int t) {
    for(int i = 1; i <= n ; i++ ) {
        dist[i] = INF, inq[i] = 0;
    }
    queue<int>que;
    que.push(s), inq[s] = 1, dist[s] = 0;
    incf[s] = 0x3f3f3f3f;
    while(!que.empty()) {
        int now = que.front();
        que.pop();
        inq[now] = 0;
        for(int i = first[now]; ~i; i = edge[i].next) {
            int to = edge[i].to, cap = edge[i].cap, cost = edge[i].cost;
            if(cap > 0 && dist[to] > dist[now] + cost) {
                dist[to] = dist[now] + cost;
                incf[to] = min(incf[now], cap);
                pre[to] = i;
                if(!inq[to]) {
                    que.push(to);
                    inq[to] = 1;
                }
            }
        }
    }
    return dist[t] != INF;
}

void update(int s, int t) {
    int x = t;
    while(x != s) {
        int pos = pre[x];
        edge[pos].cap -= incf[t];
        edge[pos ^ 1].cap += incf[t];
        x = edge[pos ^ 1].to;
    }
    max_flow += incf[t];
    min_cost += dist[t] * incf[t];
}

void minCostMaxFlow(int s, int t) {
    while(spfa(s, t)) {
        update(s, t);
    }
}

int main()
{
    while(~scanf("%d %d %d %d", &n, &m, &s, &t)) {
        init();
        for(int i = 1; i <= m; i++ ) {
            int u, v, cap, cost;
            scanf("%d %d %d %d", &u, &v, &cap, &cost);
            add_edge(u, v, cap, cost);
        }
        max_flow = min_cost = 0;
        minCostMaxFlow(s, t);
        printf("%d %d
", max_flow, min_cost);
    }

    return 0;
}