POJ - 2195 Going Home（最小费用最大流模板题）

参考自：http://www.cnblogs.com/gtarcoder/p/4890739.html

最小费用最大流

    通过EK，Dinic，ISAP算法可以得到网络流图中的最大流，一个网络流图中最大流的流量max_flow是唯一的，但是达到最大流量max_flow时每条边上的流量分配f是不唯一的。 
    如果给网络流图中的每条边都设置一个费用cost，表示单位流量流经该边时会导致花费cost。那么在这些流量均为max_flow的流量分配f中，存在一个流量总花费最小的最大流方案。 
即 min{sum(cost(i, j)*f(i,j) | (i, j)属于方案f中的边， f(i,j)为 边(i,j)上的流量， f为某一个最大流方案}。此即为最小费用最大流。

算法思想

    采用贪心的思想，每次找到一条从源点到达汇点的路径，增加流量，且该条路径满足使得增加的流量的花费最小，直到无法找到一条从源点到达汇点的路径，算法结束。 
    由于最大流量有限，每执行一次循环流量都会增加，因此该算法肯定会结束，且同时流量也必定会达到网络的最大流量；同时由于每次都是增加的最小的花费，即当前的最小花费是所有到达当前流量flow时的花费最小值，因此最后的总花费最小。

求解步骤

（1）找到一条从源点到达汇点的“距离最短”的路径，“距离”使用该路径上的边的单位费用之和来衡量。 
（2）然后找出这条路径上的边的容量的最小值f，则当前最大流max_flow扩充f，同时当前最小费用min_cost扩充 f*min_dist(s,t)。 
（3）将这条路径上的每条正向边的容量都减少f，每条反向边的容量都增加f。 
（4）重复（1）--（3）直到无法找到从源点到达汇点的路径。

需要注意几点： 
1、注意超级源点和超级终点的建立。 
2、初始化时，正向边的单位流量费用为cost[u][v]，那么反向边的单位流量费用就为-cost[u][v]。因为回流费用减少。 
3、费用cost数组和容量cap数组每次都要初始化为0。

    求解从源点到汇点的“最短”路径时，由于网络中存在负权边，因此使用SPFA来实现。

代码如下：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <sstream>
#define MAX_V 1005
#define INF 0x3f3f3f3f
using namespace std;
 
//最小费用最大流模版.求最大费用最大流建图时把费用取负即可。
//无向边转换成有向边时需要拆分成两条有向边。即两次加边。
const int maxn = 1010;
const int maxm = 1000200;
const int inf = 0x3f3f3f3f;
 
struct Edge {
    int v, cap, cost, next;
}p[maxm << 1];
 
int e, sumFlow, n, m, st, en;
int head[maxn], dis[maxn], pre[maxn];
bool vis[maxn];
void init() {
    e = 0;
    memset(head, -1, sizeof(head));
}
 
void addEdge(int u, int v, int cap, int cost) {
    p[e].v = v; p[e].cap = cap; p[e].cost = cost;
    p[e].next = head[u]; head[u] = e++;
    p[e].v = u; p[e].cap = 0; p[e].cost = -cost;
    p[e].next = head[v]; head[v] = e++;
}
 
bool spfa(int s,int t, int n) {
    int u, v;
    queue<int>q;
    memset(vis, false, sizeof(vis));
    memset(pre, -1, sizeof(pre));
    for(int i = 0; i <= n; i++)
        dis[i] = inf;
    vis[s] = true;
    dis[s] = 0;
    q.push(s);
    while(!q.empty()) {
        u = q.front();
        q.pop();
        vis[u] = false;
        for(int i = head[u]; i != -1; i = p[i].next) {
            v = p[i].v;
            if(p[i].cap && dis[v] > dis[u] + p[i].cost) {
                dis[v] = dis[u] + p[i].cost;
                pre[v] = i;
                if(!vis[v]) {
                    q.push(v);
                    vis[v] = true;
                }
            }
        }
     }
     if(dis[t] == inf)
         return false;
     return true;
}
 
int MCMF(int s, int t, int n) {
    int flow = 0; // 总流量
    int minflow, mincost;
    mincost = 0;
    while(spfa(s, t, n)) {
        minflow = inf + 1;
        for(int i = pre[t]; i != -1; i = pre[p[i^1].v]) {
            if(p[i].cap < minflow) {
                minflow = p[i].cap;
            }
        }
        flow += minflow;
        for(int i = pre[t]; i != -1; i = pre[p[i^1].v]) {
            p[i].cap -= minflow;
            p[i^1].cap += minflow;
        }
        mincost += dis[t] * minflow;
    }
    sumFlow = flow; // 最大流
    return mincost;
}
 
int x1[105], x2[105], yy[105], y2[105];
 
int main ()
{
    int t, kcase = 0;
    int N, M;
    while(~scanf("%d %d", &N, &M) && N && M) {
        int k1 = 0, k2 = 0;
        char str[105];
        for(int i = 0; i < N; i++) {
            scanf("%s", str);
            for(int j = 0; j < M; j++) {
                if(str[j] == 'm') {
                    x1[++k1] = i;
                    yy[k1] = j;
                }
                if(str[j] == 'H') {
                    x2[++k2] = i;
                    y2[k2] = j;
                }
            }
        }
        init();
        n = k1;
        //cout << k1;
        for(int i = 1; i <= n; i++) {
            addEdge(0, i, 1, 0);
            addEdge(n + i, n * 2 + 1, 1, 0);
            for(int j = 1; j <= n; j++) {
                int k = (abs(x1[i] - x2[j]) + abs(yy[i] - y2[j]));
                //cout << " " << w[i][j] ;
                addEdge(i, j + n, 1, k);
            }
            //cout <<endl;
        }
        int ans = MCMF(0, 2 * n + 1, 2 * n + 1);
        printf("%d\n", ans);
    }
    return 0;
}