最小费用最大流(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 = ;
 const int MAXM = ;
 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 * ];

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

 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 = , 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 = ; i <= n ; i++ ) {
         dist[i] = INF, inq[i] = ;
     }
     queue<int>que;
     que.push(s), inq[s] = , dist[s] = ;
     incf[s] = 0x3f3f3f3f;
     while(!que.empty()) {
         int now = que.front();
         que.pop();
         inq[now] = ;
         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 >  && 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] = ;
                 }
             }
         }
     }
     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 ^ ].cap += incf[t];
         x = edge[pos ^ ].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 = ; 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 = ;
         minCostMaxFlow(s, t);
         printf("%d %d\n", max_flow, min_cost);
     }

     return ;
 }