Going Home

裸的最小费用最大流，原点到每一个H连一条费用为0，流量为1的边；汇点到每个m连一条费用为0，流量为1的边，H和m之间连一条费用为两点间曼哈顿距离，流量为1的边，跑一边最小费用最大流就是结果了

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <string.h>
#include <math.h>
#include <queue>

const int maxn = 10000;
const int maxm = 100000;
const int INF = 0x3f3f3f3f;
struct Edge {
    int tar, next, cap, flow, cost;
}edge[maxm];
int head[maxn], tot;
int pre[maxn], dis[maxn];
bool vis[maxn];
int n, m, num, N, ans;
char c, map[150][150];

struct Index {
    int x, y;
    Index(int _x, int _y) {
        x = _x;
        y = _y;
    }
};
std::vector<Index> a, b;

void init(int n) {
    num = 0;
    tot = 0;
    memset(head, -1, sizeof(head));
    a.clear();
    b.clear();
}
void addedge(int u, int v, int cap, int cost) {
    edge[tot].tar = v;
    edge[tot].cap = cap;
    edge[tot].cost = cost;
    edge[tot].flow = 0;
    edge[tot].next = head[u];
    head[u] = tot++;
    edge[tot].tar = u;
    edge[tot].cap = 0;
    edge[tot].cost = -cost;
    edge[tot].flow = 0;
    edge[tot].next = head[v];
    head[v] = tot++;
}

bool spfa(int s, int t) {
    std::queue<int> q;
    for (int i = 0; i < N; i++) {
        dis[i] = INF;
        vis[i] = false;
        pre[i] = -1;
    }
    dis[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) {
            int v = edge[i].tar;
            if (edge[i].cap > edge[i].flow && dis[v] > dis[u]+edge[i].cost) {
                dis[v] = dis[u]+edge[i].cost;
                pre[v] = i;
                if (!vis[v]) {
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    if (pre[t] == -1) return false;
    else return true;
}

int minCostMaxflow(int s, int t, int &cost) {
    int flow = 0;
    cost = 0;
    while (spfa(s, t)) {
        int Min = INF;
        for (int i = pre[t]; i != -1; i = pre[edge[i^1].tar]) {
            if (Min > edge[i].cap-edge[i].flow)
                Min = edge[i].cap-edge[i].flow;
        }
        for (int i = pre[t]; i != -1; i = pre[edge[i^1].tar]) {
            edge[i].flow += Min;
            edge[i^1].flow -= Min;
            cost += edge[i].cost*Min;
        }
        flow += Min;
    }
    return flow;
}

int main() {
    while (scanf("%d %d", &n, &m) != EOF) {
        if (n == 0 && m == 0) break;
        init(n*m+2);
        for (int i = 0; i < n; i++) {
            c = getchar();
            for (int j = 0; j < m; j++) {
                map[i][j] = getchar();
                if (map[i][j] == 'H') {
                    num++;
                    a.push_back(Index(i, j));
                }
                if (map[i][j] == 'm') b.push_back(Index(i, j));
            }
        }
        N = num*2+2;
        for (int i = 1; i <= num; i++) {
            addedge(0, i, 1, 0);
            addedge(num+i, num*2+1, 1, 0);
        }
        for (int i = 0; i < num; i++)
            for (int j = 0; j < num; j++) {
                addedge(i+1, num+j+1, 1, abs(a[i].x-b[j].x)+abs(a[i].y-b[j].y));
            }
        ans = 0;
        minCostMaxflow(0, num*2+1, ans);
        printf("%d\n", ans);
    }
}