网络流--最小费用最大流MCMF算法

转载：http://www.cnblogs.com/Missa/archive/2013/04/19/3030512.html

在一个网络中每段路径都有“容量”和“费用”两个限制的条件下，此类问题的研究试图寻找出：流量从A到B，如何选择路径、分配经过路径的流量，可以达到所用的费用最小的要求。如n辆卡车要运送物品，从A地到B地。由于每条路段都有不同的路费要缴纳，每条路能容纳的车的数量有限制，最小费用最大流问题指如何分配卡车的出发路径可以达到费用最低，物品又能全部送到。

 1 //最小费用最大流模版.求最大费用最大流建图时把费用取负即可。 2 //无向边转换成有向边时需要拆分成两条有向边。即两次加边。 3 const int maxn = 1010; 4 const int maxm = 1000200; 5 const int inf = 1000000000; 6 struct Edge 7 { 8     int v, cap, cost, next; 9 }p[maxm << 1];10 int e, sumFlow, n, m, st, en;11 int head[maxn], dis[maxn], pre[maxn];12 bool vis[maxn];13 void init()14 {15     e=0;16     memset(head,-1,sizeof(head));17 }18 void addEdge(int u,int v,int cap,int cost)19 {20     p[e].v = v; p[e].cap = cap; p[e].cost = cost;21     p[e].next = head[u]; head[u] = e++;22     p[e].v = u; p[e].cap = 0; p[e].cost = - cost;23     p[e].next = head[v]; head[v] = e++;24 }25 bool spfa(int s,int t, int n)26 {27     int u,v;28     queue<int>q;29     memset(vis,false,sizeof(vis));30     memset(pre,-1,sizeof(pre));31     for(int i = 0; i <= n; ++i) 32         dis[i] = inf;33     vis[s] = true;34     dis[s] = 0;35     q.push(s);36     while(!q.empty())37     {38         u = q.front();39         q.pop();40         vis[u] = false;41         for(int i = head[u]; i != -1; i = p[i].next)42         {43             v = p[i].v;44             if(p[i].cap && dis[v] > dis[u] + p[i].cost)45             {46                 dis[v] = dis[u] + p[i].cost;47                 pre[v] = i;48                 if(!vis[v])49                 {50                     q.push(v);51                     vis[v]=true;52                 }53             }54         }55      }56      if(dis[t] == inf) 57          return false;58      return true;59 }60 int MCMF(int s,int t,int n)61 {62     int flow = 0; // 总流量63     int minflow, mincost;64     mincost=0;65     while(spfa(s,t,n))66     {67         minflow = inf + 1;68         for(int i = pre[t]; i != -1; i = pre[p[i^1].v])69             if(p[i].cap < minflow)70                 minflow = p[i].cap;71         flow += minflow;72         for(int i=pre[t];i!=-1;i=pre[p[i^1].v])73         {74             p[i].cap -= minflow;75             p[i^1].cap += minflow;76         }77         mincost += dis[t] * minflow;78     }79     sumFlow = flow; // 最大流80     return mincost;81 }

如果理解了最大流连续增广路算法的思维， 理解这个算法还是很简单的。
结构体存储信息：
分别为边的起点、终点、容量、当前流量、费用、下一条边的编号。
[cpp] view plain copy
struct Edge  
{  
    int from, to, cap, flow, cost, next;  
};  
Edge edge[MAXM];  
int head[MAXN], edgenum;  


算法实现过程：
1，每次查找是否 存在源点到汇点的可增广路径，并用pre[ i ]记录路径上到达点i 的 边 的编号。这里的路径指的是 —— 源点到汇点的最短路（边权为费用） 且 路径上所有边都不能满流；
2，若存在这样的路径，从汇点沿着pre数组向前找，找到该路径上可以增广的流量Min（当然是所有边中剩余流量最小的）。再从汇点遍历一次，正向边增加流量Min，反向边减少Min，总费用累加Min * edge[i].cost，总流量累加Min。
模板：
建图没有写，毕竟图论建图没有模板 o(╯□╰)o
[cpp] view plain copy
#include <cstdio>  
#include <cstring>  
#include <queue>  
#include <stack>  
#include <vector>  
#include <cmath>  
#include <cstdlib>  
#include <algorithm>  
#define MAXN 200+10  
#define MAXM 80000+100  
#define INF 0x3f3f3f3f  
using namespace std;  
struct Edge  
{  
    int from, to, cap, flow, cost, next;  
};  
Edge edge[MAXM];  
int head[MAXN], edgenum;  
int pre[MAXN];//记录增广路径上 到达点i的边的编号  
int dist[MAXN];  
bool vis[MAXN];  
int N, M;//点数 边数  
int source, sink;//超级源点 超级汇点  
void init()  
{  
    edgenum = 0;  
    memset(head, -1, sizeof(head));  
}  
void addEdge(int u, int v, int w, int c)  
{  
    Edge E1 = {u, v, w, 0, c, head[u]};  
    edge[edgenum] = E1;  
    head[u] = edgenum++;  
    Edge E2 = {v, u, 0, 0, -c, head[v]};  
    edge[edgenum] = E2;  
    head[v] = edgenum++;  
}  
bool SPFA(int s, int t)//寻找花销最少的路径  
{  
    //跑一遍SPFA 找s——t的最少花销路径 且该路径上每一条边不能满流  
    //若存在 说明可以继续增广，反之不能  
    queue<int> Q;  
    memset(dist, INF, sizeof(dist));  
    memset(vis, false, sizeof(vis));  
    memset(pre, -1, sizeof(pre));  
    dist[s] = 0;  
    vis[s] = true;  
    Q.push(s);  
    while(!Q.empty())  
    {  
        int u = Q.front();  
        Q.pop();  
        vis[u] = false;  
        for(int i = head[u]; i != -1; i = edge[i].next)  
        {  
            Edge E = edge[i];  
            if(dist[E.to] > dist[u] + E.cost && E.cap > E.flow)//可以松弛 且 没有满流  
            {  
                dist[E.to] = dist[u] + E.cost;  
                pre[E.to] = i;//记录前驱边 的编号  
                if(!vis[E.to])  
                {  
                    vis[E.to] = true;  
                    Q.push(E.to);  
                }  
            }  
        }  
    }  
    return pre[t] != -1;//可达返回true  
}  
void MCMF(int s, int t, int &cost, int &flow)  
{  
    flow = 0;//总流量  
    cost = 0;//总费用  
    while(SPFA(s, t))//每次寻找花销最小的路径  
    {  
        int Min = INF;  
        //通过反向弧 在源点到汇点的最少花费路径 找最小增广流  
        for(int i = pre[t]; i != -1; i = pre[edge[i^1].to])  
        {  
            Edge E = edge[i];  
            Min = min(Min, E.cap - E.flow);  
        }  
        //增广  
        for(int i = pre[t]; i != -1; i = pre[edge[i^1].to])  
        {  
            edge[i].flow += Min;  
            edge[i^1].flow -= Min;  
            cost += edge[i].cost * Min;//增广流的花销  
        }  
        flow += Min;//总流量累加  
    }  
}  
int main()  
{  
    while(scanf("%d%d", &N, &M), N||M)  
    {  
        init();  
        getMap();//建图   
        int cost, flow;//最小费用 最大流  
        MCMF(source, sink, cost, flow);  
        printf("%d %d\n", cost, flow);//最小费用 最大流  
    }  
    return 0;  
}