hdu1533 Going Home km算法解决最小权完美匹配

Going Home

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 5539    Accepted Submission(s): 2907

Problem 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

/**
题目:hdu1533 Going Home km算法解决最小权完美匹配
链接：http://acm.hdu.edu.cn/showproblem.php?pid=1533
题意：lv
思路：最优匹配(最大权完美匹配) km算法

如果是求最小权完美匹配，那么将所有权值取相反数，然后求得最大权，输出最大权的相反数即可。
*/

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
using namespace std;
const int MAXN = ;
const int INF = 0x3f3f3f3f;

int love[MAXN][MAXN];   // 记录每个妹子和每个男生的好感度
int ex_girl[MAXN];      // 每个妹子的期望值
int ex_boy[MAXN];       // 每个男生的期望值
bool vis_girl[MAXN];    // 记录每一轮匹配匹配过的女生
bool vis_boy[MAXN];     // 记录每一轮匹配匹配过的男生
int match[MAXN];        // 记录每个男生匹配到的妹子 如果没有则为-1
int slack[MAXN];        // 记录每个汉子如果能被妹子倾心最少还需要多少期望值

int N;//左侧顶点数=右侧顶点数=N;

bool dfs(int girl)
{
    vis_girl[girl] = true;

    for (int boy = ; boy < N; ++boy) {

        if (vis_boy[boy]) continue; // 每一轮匹配 每个男生只尝试一次

        int gap = ex_girl[girl] + ex_boy[boy] - love[girl][boy];

        if (gap == ) {  // 如果符合要求
            vis_boy[boy] = true;
            if (match[boy] == - || dfs( match[boy] )) {    // 找到一个没有匹配的男生 或者该男生的妹子可以找到其他人
                match[boy] = girl;
                return true;
            }
        } else {
            slack[boy] = min(slack[boy], gap);  // slack 可以理解为该男生要得到女生的倾心 还需多少期望值 取最小值 备胎的样子【捂脸
        }
    }

    return false;
}

int KM()
{
    memset(match, -, sizeof match);    // 初始每个男生都没有匹配的女生
    memset(ex_boy, , sizeof ex_boy);   // 初始每个男生的期望值为0

    // 每个女生的初始期望值是与她相连的男生最大的好感度
    for (int i = ; i < N; ++i) {
        ex_girl[i] = love[i][];
        for (int j = ; j < N; ++j) {
            ex_girl[i] = max(ex_girl[i], love[i][j]);
        }
    }

    // 尝试为每一个女生解决归宿问题
    for (int i = ; i < N; ++i) {

        fill(slack, slack + N, INF);    // 因为要取最小值 初始化为无穷大

        while () {
            // 为每个女生解决归宿问题的方法是 ：如果找不到就降低期望值，直到找到为止

            // 记录每轮匹配中男生女生是否被尝试匹配过
            memset(vis_girl, false, sizeof vis_girl);
            memset(vis_boy, false, sizeof vis_boy);

            if (dfs(i)) break;  // 找到归宿 退出

            // 如果不能找到 就降低期望值
            // 最小可降低的期望值
            int d = INF;
            for (int j = ; j < N; ++j)
                if (!vis_boy[j]) d = min(d, slack[j]);

            for (int j = ; j < N; ++j) {
                // 所有访问过的女生降低期望值
                if (vis_girl[j]) ex_girl[j] -= d;

                // 所有访问过的男生增加期望值
                if (vis_boy[j]) ex_boy[j] += d;
                // 没有访问过的boy 因为girl们的期望值降低，距离得到女生倾心又进了一步！
                else slack[j] -= d;
            }
        }
    }

    // 匹配完成 求出所有配对的好感度的和
    int res = ;
    for (int i = ; i < N; ++i)
        res += love[ match[i] ][i];

    return res;
}
int f[MAXN][MAXN];
char mp[MAXN][MAXN];
typedef pair<int,int> P;
vector<P> a, b;
int dis(int i,int j)
{
    return abs(a[i].first-b[j].first)+abs(a[i].second-b[j].second);
}
int main()
{
    int n, m;
    while (scanf("%d%d",&n,&m)==) {//N外部变量
        if(n==&&m==) break;
        a.clear(), b.clear();
        for(int i = ; i < n; i++){
            scanf("%s",mp[i]);
            for(int j = ; j < m; j++){
                if(mp[i][j]=='m'){
                    a.push_back(P(i,j));
                }
                if(mp[i][j]=='H'){
                    b.push_back(P(i,j));
                }
            }
        }
        N = a.size();
        for (int i = ; i < N; ++i)
            for (int j = ; j < N; ++j)
                love[i][j] = -dis(i,j);

        printf("%d\n", -KM());
    }
    return ;
}