洛谷 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

555555本蒟蒻还不会zkw费用流，就先贴Edmond_Karp+SPFA和Primal_Dual的代码吧。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <vector>
 #include <queue>
 using namespace std;

 struct edge {
     int to,cap,cost,rev;
 };

 typedef pair<int,int> P;
 const int maxn=, maxm=, INF=0x7F7F7F7F;
 int n,m;
 vector <edge> G[maxn+];

 edge make_edge(int to, int cap, int cost, int rev) {
     edge x;
     x.to=to, x.cap=cap, x.cost=cost, x.rev=rev;
     return x;
 }

 void add_edge(int from, int to, int cap, int cost) {
     G[from].push_back(make_edge(to,cap,cost,G[to].size()));
     G[to].push_back(make_edge(from,,-cost,G[from].size()-));
 }

 void init(int &s, int &t) {
     scanf("%d%d%d%d",&n,&m,&s,&t);
     for (int i=; i<=m; i++) {
         int u,v,w,f;
         scanf("%d%d%d%d",&u,&v,&w,&f);
         add_edge(u,v,w,f);
     }
 }

 namespace EK_SPFA {
     int dis[maxn+];
     int prev[maxn+];
     int pree[maxn+];

     void bfs(int s) {
         bool mark[maxn+];
         memset(dis,0x7F,sizeof(dis));
         memset(prev,-,sizeof(prev));
         memset(pree,-,sizeof(pree));
         memset(mark,,sizeof(mark));
         queue <int> q;
         dis[s]=;
         q.push(s);
         while (!q.empty()) {
             int x=q.front();
             q.pop();
             mark[x]=false;
             for (int i=; i<G[x].size(); i++) {
                 edge &e=G[x][i];
                 if (e.cap>&&dis[x]+e.cost<dis[e.to]) {
                     dis[e.to]=dis[x]+e.cost;
                     prev[e.to]=x;
                     pree[e.to]=i;
                     if (!mark[e.to]) {
                         mark[e.to]=true;
                         q.push(e.to);
                     }
                 }
             }
         }
     }

     P min_cost_max_flow(int s, int t) {
         int flow=, cost=;
         for(;;) {
             bfs(s);
             if (dis[t]==INF)
                 return make_pair(flow,cost);
             int d=INF;
             for (int i=t; prev[i]!=-; i=prev[i])
                 d=min(d,G[prev[i]][pree[i]].cap);
             flow+=d;
             cost+=d*dis[t];
             for (int i=t; prev[i]!=-; i=prev[i]) {
                 edge &e=G[prev[i]][pree[i]];
                 e.cap-=d;
                 G[e.to][e.rev].cap+=d;
             }
         }
     }
 }

 namespace Primal_Dual {
     int dis[maxn+];
     int h[maxn+];
     int prev[maxn+];
     int pree[maxn+];

     void bfs(int s) {
         priority_queue <P, vector<P>, greater<P> > q;
         bool vis[maxn+];
         memset(vis,,sizeof(vis));
         memset(dis,0x7F,sizeof(dis));
         memset(prev,-,sizeof(prev));
         memset(pree,-,sizeof(pree));
         dis[s]=;
         q.push(make_pair(,s));
         while (!q.empty()) {
             int val=q.top().first, x=q.top().second;
             q.pop();
             if (vis[x]) continue;
             vis[x]=true;
             for (int i=; i<G[x].size(); i++) {
                 edge &e=G[x][i];
                 if (e.cap>&&dis[x]+e.cost+h[x]-h[e.to]<dis[e.to]&&!vis[e.to]) {
                     dis[e.to]=dis[x]+e.cost+h[x]-h[e.to];
                     prev[e.to]=x;
                     pree[e.to]=i;
                     q.push(make_pair(dis[e.to],e.to));
                 }
             }
         }
     }

     P min_cost_max_flow(int s, int t) {
         int flow=, cost=;
         memset(h,,sizeof(h));
         for(;;) {
             bfs(s);
             if (dis[t]==INF)
                 return make_pair(flow,cost);
             for (int i=; i<=n; i++)
                 h[i]+=dis[i];
             int d=INF;
             for (int i=t; prev[i]!=-; i=prev[i])
                 d=min(d,G[prev[i]][pree[i]].cap);
             flow+=d;
             cost+=d*h[t];
             for (int i=t; prev[i]!=-; i=prev[i]) {
                 edge &e=G[prev[i]][pree[i]];
                 e.cap-=d;
                 G[e.to][e.rev].cap+=d;
             }
         }
     }
 }

 int main() {
     int s,t;
     init(s,t);
     P ans=Primal_Dual::min_cost_max_flow(s,t);
     printf("%d %d\n",ans.first,ans.second);
     return ;
 }