网络流_spfa最小费用最大流

最大流：

　　不断搜索增广路，寻找最小的容量-流量，得到最大流量，但最大流量在有花费时不一定是最小花费。

最小费用最大流

算法思想：

　　采用贪心的思想，每次找到一条从源点到达汇点的花费最小的路径，增加流量，直到无法找到一条从源点到达汇点的路径，算法结束。

　　由于最大流量有限，每执行一次循环流量都会增加，因此该算法肯定会结束，且同时流量也必定会达到网络的最大流量；同时由于每次都是增加的最小的花费，即当前的最小花费是所有到达当前流量flow时的花费最小值，因此最后的总花费最小。

附上洛谷P3381模板题：

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

 const int INF=0x7f7f7f7f;
 const int MAXN=;

 struct Edge
 {
     int u,v,w,c,next;//u起点,v终点,w容量,c花费,next下一条边
 }E[MAXN];
 int node,head[MAXN];
 int pre[MAXN],cost[MAXN],vis[MAXN];
 int s,t;
 int n,m,ans1,ans2;

 void insert(int u,int v,int w,int c)
 {
     E[++node]=(Edge){u,v,w,c,head[u]};
     head[u]=node;
     E[++node]=(Edge){v,u,,-c,head[v]};
     head[v]=node;
 }

 bool spfa()
 {
     queue<int> Q;
     memset(cost,0x7f,sizeof(cost));
     Q.push(s);
     cost[s]=;vis[s]=;
     while(!Q.empty())
     {
         int q=Q.front();Q.pop();
         for(int i=head[q];i;i=E[i].next)
             if(E[i].w&&cost[q]+E[i].c<cost[E[i].v])
             {
                 cost[E[i].v]=cost[q]+E[i].c;
                 pre[E[i].v]=i;
                 if(!vis[E[i].v])
                 {
                     Q.push(E[i].v);
                     vis[E[i].v]=;
                 }
             }
         vis[q]=;
     }
     return cost[t]!=INF;
 }

 void mcf()
 {
     int minn=INF;
     for(int i=pre[t];i;i=pre[E[i].u])
         minn=min(minn,E[i].w);
     for(int i=pre[t];i;i=pre[E[i].u])
     {
         ans2+=minn*E[i].c;
         E[i].w-=minn;
         E[i^].w+=minn;
     }
     ans1+=minn;
 }

 int main()
 {
     scanf("%d%d%d%d",&n,&m,&s,&t);
     for(int i=;i<=m;i++)
     {
         int u,v,w,c;
         scanf("%d%d%d%d",&u,&v,&w,&c);
         insert(u,v,w,c);
     }
     while(spfa()) mcf();
     printf("%d %d",ans1,ans2);//ans1最大流 ans2最小费用
     return ;
 }