poj 2195 Going Home（最小费最大流）

poj 2195 Going Home

Description
On a grid map there are n little men and n houses. In each unit time, every little man can move one unit step, either horizontally, or vertically, to an adjacent point. For each little man, you need to pay a $1 travel fee for every step he moves, until he enters a house. The task is complicated with the restriction that each house can accommodate only one little man.

Your task is to compute the minimum amount of money you need to pay in order to send these n little men into those n different houses. The input is a map of the scenario, a ‘.’ means an empty space, an ‘H’ represents a house on that point, and am ‘m’ indicates there is a little man on that point.

You can think of each point on the grid map as a quite large square, so it can hold n little men at the same time; also, it is okay if a little man steps on a grid with a house without entering that house.

Input
There are one or more test cases in the input. Each case starts with a line giving two integers N and M, where N is the number of rows of the map, and M is the number of columns. The rest of the input will be N lines describing the map. You may assume both N and M are between 2 and 100, inclusive. There will be the same number of ‘H’s and ‘m’s on the map; and there will be at most 100 houses. Input will terminate with 0 0 for N and M.

Output
For each test case, output one line with the single integer, which is the minimum amount, in dollars, you need to pay.

Sample Input

2 2
.m
H.
5 5
HH..m
…..
…..
…..
mm..H
7 8
…H….
…H….
…H….
mmmHmmmm
…H….
…H….
…H….
0 0

Sample Output

2
10
28

题目大意：给你一个N × M的含有“H”， “m”。 “.”的二维图。“H”代表HOME。 “m”代表man，“.”代表空。man到HOME的距离为两点坐标的X坐标之差的绝对值加上Y坐标之差的绝对值。man的数量与HOME的数量同样。

如今。问，要是全部的man都回到HOME走的最短的路程总和为多少。

解题思路：还是建图的问题。依据这张二位的图，建一张流图。设置一个超级源点，连向全部的man,容量为1。设置一个超级汇点。使全部的HOME都连向超级汇点，容量为1。

把全部的HOME都拆成两个点。连接的容量为1。每一个房子仅仅能住一个人。

每一个man连向全部的房子，容量为1。费用为二维图上，man点到HOME点的距离。图建完以后。求最小费最大流。

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

const int N = 505;
const int NN = 105;
const int MM = 15005;
const int INF = 0x3f3f3f3f;
const int OF = 100;
const int FIN = 500;
typedef long long ll;

int n, m, cntH, cntM, s, t;
struct Node{
    int x, y;
}H[NN], M[NN];
char gra[NN][NN];
int pre[N], inq[N]; 
ll a[N], d[N];
struct Edge{
    int from, to;
    ll cap, flow;
    ll cos;
};

vector<Edge> edges;
vector<int> G[MM];

void init() {
    for (int i = 0; i < MM; i++) G[i].clear();
    edges.clear();
}

void addEdge(int from, int to, ll cap, ll flow, ll cos) {
    edges.push_back((Edge){from, to, cap, 0, cos});
    edges.push_back((Edge){to, from, 0, 0, -cos});
    int m = edges.size();
    G[from].push_back(m - 2);
    G[to].push_back(m - 1);
}

int getDis(int x, int y) {
    return abs(M[x].x - H[y].x) + abs(M[x].y - H[y].y);
}

void input() {
    cntH = cntM = 0;
    for (int i = 0; i < n; i++) scanf("%s", gra[i]);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (gra[i][j] == 'H') {
                H[cntH].x = i;
                H[cntH++].y = j;
            } else if (gra[i][j] == 'm') {
                M[cntM].x = i;  
                M[cntM++].y = j;
            }
        }   
    }
    for (int i = 1; i <= cntH; i++) {
        addEdge(i, i + OF, 1, 0, 0);    
    }
    for (int i = 1; i <= cntM; i++) {
        for (int j = 1; j <= cntH; j++) {
            addEdge(i + 2 * OF, j, 1, 0, getDis(i - 1, j - 1)); 
        }
    }
    for (int i = 1; i <= cntM; i++) {
        addEdge(0, i + 2 * OF, 1, 0, 0);
    }
    for (int i = 1; i <= cntH; i++) {
        addEdge(i + OF, t, 1, 0, 0);    
    }
}

int BF(int s, int t, ll& flow, ll& cost) {
    queue<int> Q;
    memset(inq, 0, sizeof(inq));
    memset(a, 0, sizeof(a));
    memset(pre, 0, sizeof(pre));
    for (int i = 0; i < N; i++) d[i] = INF;
    d[s] = 0;
    a[s] = INF;
    inq[s] = 1;
    int flag = 1;
    pre[s] = 0;
    Q.push(s);
    while (!Q.empty()) {
        int u = Q.front(); Q.pop();
        inq[u] = 0;
        for (int i = 0; i < G[u].size(); i++) {
            Edge &e = edges[G[u][i]];
            if (e.cap > e.flow && d[e.to] > d[u] + e.cos) {
                d[e.to] = d[u] + e.cos;
                a[e.to] = min(a[u], e.cap - e.flow);
                pre[e.to] = G[u][i];
                if (!inq[e.to]) {
                    inq[e.to] = 1;
                    Q.push(e.to);
                }
            }   
        }
        flag = 0;
    }
    if (d[t] == INF) return 0;
    flow += a[t];
    cost += (ll)d[t] * (ll)a[t];
    for (int u = t; u != s; u = edges[pre[u]].from) {
        edges[pre[u]].flow += a[t];
        edges[pre[u]^1].flow -= a[t];
    }
    return 1;
}

int MCMF(int s, int t, ll& cost) {
    ll flow = 0;
    cost = 0;       
    while (BF(s, t, flow, cost));
    return flow;
}

int main() {
    while (scanf("%d %d\n", &n, &m) == 2, n, m) {
        s = 0, t = FIN;
        init();
        input();
        ll cost;
        MCMF(s, t, cost);   
        printf("%lld\n", cost);
    }   
    return 0;
}