洛谷P3381 最小费用最大流模板

https://www.luogu.org/problem/P3381

题目描述

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

输入格式

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

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

输出格式

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

 输入 

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

 输出

50 280

 #include<stdio.h>
 #include<string.h>
 #include<queue>
 #define mem(a, b) memset(a, b, sizeof(a))
 using namespace std;
 const int MAXN = 1e5 + ;
 const int inf = 0x3f3f3f3f;

 int n, m, st, ed;//点数 边数 源点 汇点
 int vis[MAXN], dis[MAXN], flow[MAXN];//源点到i点的花费和流量
 int pre[MAXN];//每个点的前驱
 int last[MAXN]; //每个点连的前一条边
 int mincost, maxflow;
 queue<int> Q;

 struct Edge
 {
     int to, next, flow, dis;//费用作为 dis 来跑最短路
 }edge[MAXN];
 int head[MAXN], cnt;

 void add(int a, int b, int c, int d) //要用到 ^ 操作 所以边从 0 开始
 {
     edge[++ cnt].to = b;
     edge[cnt].next = head[a];
     edge[cnt].flow = c;
     edge[cnt].dis = d;
     head[a] = cnt;
 }

 bool spfa(int st, int ed)
 {
     mem(dis, inf), mem(flow, inf), mem(vis, );//找到最大流以及最短路（最少费用）
     Q.push(st);
     vis[st] = ;
     dis[st] = ;
     pre[ed] = -;
     while(!Q.empty())
     {
         int now = Q.front();
         Q.pop();
         vis[now] = ;
         for(int i = head[now]; i != -; i = edge[i].next)
         {
             if(edge[i].flow >  && dis[edge[i].to] > dis[now] + edge[i].dis)
             {
                 dis[edge[i].to] = dis[now] + edge[i].dis;
                 pre[edge[i].to] = now;//记录更新后的新前驱
                 last[edge[i].to] = i;//记录更新后的新的前一条边 为了回溯来更新边的流量
                 flow[edge[i].to] = min(flow[now], edge[i].flow);//找出最大流
                 if(!vis[edge[i].to])
                 {
                     vis[edge[i].to] = ;
                     Q.push(edge[i].to);
                 }
             }
         }
     }
     return pre[ed] != -;
 }

 void min_cost_max_flow()
 {
     while(spfa(st, ed))
     {
         int now = ed;
         maxflow += flow[ed];
         mincost += flow[ed] * dis[ed];
         while(now != st)//从汇点回溯更新边剩下的流量
         {
             edge[last[now]].flow -= flow[ed];
             edge[last[now] ^ ].flow += flow[ed];
             now = pre[now];
         }
     }
 }

 int main()
 {
     mem(head, -), cnt = -;
     scanf("%d%d%d%d", &n, &m, &st, &ed);
     for(int i = ; i <= m; i ++)
     {
         int a, b, c, d;
         scanf("%d%d%d%d", &a, &b, &c, &d); //有向边起点 终点 容量 单位费用
         add(a, b, c, d);
         add(b, a, , -d);//反向边流量为 0 ，花费为 负的
     }
     min_cost_max_flow();
     printf("%d %d\n", maxflow, mincost);
     return ;
 }

最小费用最大流模板