【进阶——最小费用最大流】hdu 1533 Going Home （费用流）Pacific Northwest 2004

题意：

给一个n*m的矩阵，其中由k个人和k个房子，给每个人匹配一个不同的房子，要求所有人走过的曼哈顿距离之和最短。

输入：

多组输入数据。

每组输入数据第一行是两个整型n, m，表示矩阵的长和宽。

接下来输入矩阵。

输出：

输出最短距离。

题解：

标准的最小费用最大流算法，或者用KM算法。由于这里是要学习费用流，所以使用前者。

最小费用最大流，顾名思义，就是在一个网络中，不止存在流量，每单位流量还存在一个费用。由于一个网络的最大流可能不止一种，所以，求出当前网络在流量最大的情况下的最小花费。

直接百度百科最小费用最大流算法，可以看到两种思路——

1. 先求出最大流。然后寻找是否存在路径，可以使这个网络在最大流不变的情况下减小费用。如果存在，则改变网络。不停迭代，知道不存在更优的路径为止——但是我还没有找到这种方法的实现方式。我自己也没有试着实现。
2. 在网络之外构造一个新图，这张图记录已经存在的路径的长度（即此路径单位流量的费用），需要注意的是路径是有向路径（反向路径的长度是正向路径的相反数，原因和最大流中每选择一条边，都要给网络构造）。然后寻找增广路径（也就是从源点到汇点的一条路），这条路同时满足在构造的图是最短路。然后按照求最大流的方法修改原网络，反复迭代，保证每次找到的增广路都是当前残余网络在构造的图中的最短路。那么最终得到的最大流一定是最小费用最大流（贪心大法）。

以上是算最小费用最大流的方法。

具体的算法，可以使用EK+spfa算法来实现。

针对这道题，我们需要先构造网络。

我们设0节点为源点，接下来1——k节点为人，k+1——2*k为房子，2*k+1为汇点。

源点到每个人连一条边，每个人到每个房子连一条边，每个房子到汇点连一条边（不要忘了是有向边），每条边的权为1。

接下来构造费用图。源点到每个人一条边，权值为0，每个人到每个房子一条边，权值为它们之间的曼哈顿距离。每个放在到汇点一条边，权值为0。

然后带到算法里计算。

实现见代码——

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
using namespace std;

const int N = 110;
const int M = 100000010;

struct Node
{
    int x, y;
}man[N], house[N];                      //人，房子的横纵坐标

char mp[N][N];
int cost[2*N][2*N], flow[2*N][2*N];     //距离图和流网络
int pre[2*N], low[2*N], dis[2*N];       //分别记录当前节点的父节点，当前路径的最小流量，spfa中的最短距离
bool vis[2*N];                          //标记当前节点是否在队列中
int n, m;
int ans;
int mn, hs, k, kk;                      //分别表示人的数量+1，房子的数量+1，人的数量，邻接矩阵每一维的大小

void init()
{
    mn = 1, hs = 1;
    for(int i = 0; i < n; i++)
    {
        scanf("%s", mp[i]);
        for(int j = 0; j < m; j++)
        {
            if(mp[i][j] == 'm') {man[mn].x = i; man[mn++].y = j;}
            if(mp[i][j] == 'H') {house[hs].x = i; house[hs++].y = j;}
        }
    }
    k = hs-1;
    kk = 2*k+1;
    for(int i = 0; i < kk; i++)
    {
        for(int j = 0; j < kk; j++) cost[i][j] = M;
    }
    memset(flow, 0, sizeof(flow));
    for(int i = 1; i <= k; i++)
    {
        for(int j = k+1; j < kk; j++)
        {
            cost[i][j] = abs(man[i].x-house[j-k].x)+abs(man[i].y-house[j-k].y);     //人到房子的距离为曼哈顿距离
            cost[j][i] = -cost[i][j];                                               //反向距离
            flow[i][j] = 1;                                                         //人到房子的流网络
        }
        cost[i][0] = cost[0][i] = 0;                                                //源点到人，人到源点的距离
        flow[0][i] = 1;                                                             //源点到人的流网络
        cost[i+k][kk] = cost[kk][i+k] = 0;                                          //汇点到房子，房子到汇点的距离
        flow[i+k][kk] = 1;                                                          //房子到汇点的流网络
    }
    ans = 0;
}

int Min(int x, int y)
{
    return x < y ? x : y;
}

bool spfa()
{
    for(int i = 0; i <= kk; i++)
    {
        dis[i] = M;
        pre[i] = -1;
        vis[i] = 0;
        low[i] = M;
    }
    queue<int> que;
    que.push(0);
    vis[0] = 1;
    dis[0] = 0;
    while(!que.empty())
    {
        int p = que.front();
        que.pop();
        vis[p] = 0;
        for(int i = 0; i <= kk; i++)
        {
            if(flow[p][i] && dis[i] > dis[p]+cost[p][i])
            {
                dis[i] = dis[p]+cost[p][i];
                pre[i] = p;
                low[i] = Min(low[p], flow[p][i]);
                if(!vis[i])
                {
                    vis[i] = 1;
                    que.push(i);
                }
            }
        }
    }
    return dis[kk] != M;
}

void work()
{
    while(spfa())       //如果存在路径，则计算流量
    {
        int x = kk;
        while(pre[x] != -1)
        {
            flow[pre[x]][x] -= low[kk];
            flow[x][pre[x]] += low[kk];
            x = pre[x];
        }
        ans += dis[kk];     //计算距离和
    }
}

void outit()
{
    printf("%d
", ans);
}

int main()
{
    while(~scanf("%d%d", &n, &m) && (n+m))
    {
        init();
        work();
        outit();
    }
    return 0;
}