网络流_spfa最小费用最大流

最大流：

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

最小费用最大流

算法思想：

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

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

附上洛谷P3381模板题：

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

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

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,0,-c,head[v]};
    head[v]=node;
}

bool spfa()
{
    queue<int> Q;
    memset(cost,0x7f,sizeof(cost));
    Q.push(s);
    cost[s]=0;vis[s]=1;
    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]=1;
                }
            }
        vis[q]=0;
    }
    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^1].w+=minn;
    }
    ans1+=minn;
}

int main()
{
    scanf("%d%d%d%d",&n,&m,&s,&t);
    for(int i=1;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 0;
}