HDU-#1533 Going Home（二分图最佳完美匹配+KM）

题目大意：给出一张N*M的地图，上面有H（代表房子），m（代表人）。现在要给这些人分配房子，但是移动需要花费。求最小花费的匹配值。

解题思路：这是一道典型的二分图最佳完美匹配题，要求每个人都要分到且最小花费最小。而KM算法是求最大值的，因此我们在存取边权的时候将边权存为其负数，即w[i][j]=-w[i][j]，计算边权采取先将房子和人的坐标分别存放在左右两个边集，然后计算每个人到每个房子的曼哈顿距离作为其边权。而最后进行输出时直接输出其相反数即为所求。详见code。

题目来源：http://acm.hdu.edu.cn/showproblem.php?pid=1533

code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int MAXN = 100+10;
const int inf = 0x3fffffff;
int n,d,val,N,M,mn,hn;
bool sx[MAXN],sy[MAXN]; //sx[i],sy[i]为左/右第i个点是否已标记
int match[MAXN],w[MAXN][MAXN]; //match为右边第i个编号，w为对应的边权值
int lx[MAXN],ly[MAXN]; //顶标
char map[MAXN][MAXN];

struct node{
    int x,y;
}h[MAXN],m[MAXN];

int ABS(int x){return x<0?-x:x;}

bool dfs (int u){
    sx[u] = true;  //将左顶标访问标记
	for (int v=1; v <=hn; v++){ //对右顶标进行遍历匹配
		if (!sy[v] && lx[u]+ly[v]==w[u][v]){  //如果没有访问过且满足是最大边权值
			sy[v] = true; //将右顶标访问标记
			if (match[v] == -1 || dfs (match[v])){ //v点是否为孤立点，若v不是孤立点时dfs(match[v])寻找v所对应顶标的增广路
				match[v] = u; //如果能找到另一条增广路径就可以使v变成孤立点，从而使增广路径的长度加1
				return true;
			}
		}
	}
	return false;
}

int KM (){ //二分图最佳匹配KM算法
	int i,j,k,sum = 0;
	memset (ly,0,sizeof(ly)); //构造可行顶标：将左顶标初始化为0，
	for (i =1;i<=mn;i++){ //右顶标有则初始化为最大边权值，没有则初始化为负无穷
		lx[i] = -inf;
		for (j=1;j<=hn;j++)
			if (lx[i] < w[i][j])
				lx[i] = w[i][j];
	}
	memset (match, -1, sizeof(match));
	for (i=1; i<=mn;i++){
		while(1){
			memset (sx, false, sizeof(sx)); //初始化左右访问标记
			memset (sy, false, sizeof(sy));
			if (dfs(i)) break;  //存在完美匹配，则算法终止
            else {//否则修改顶标使得相等的子图的边变多，有更大机会存在完美匹配
                d = inf; //初始化修改顶标的数值，即两边加上和减去的值d
                for (j=1; j<=mn;j++) if (sx[j])
                    for (k =1; k<=hn;k++) if (!sy[k])
                            d = min(d, lx[j]+ly[k]-w[j][k]); //计算d值，左顶标实际减小值比d小，则不会有新边进入
                if (d == inf) //找不到完美匹配
                    return -1;
                for (j=1;j<=mn;j++) //将左边顶标减少一个d
                    if (sx[j])
                        lx[j] -= d;
                for (j=1;j<=hn;j++) //将右边顶标加上同样的值
                    if (sy[j])
                        ly[j] += d;
            }
		}
	}
	for (i=1; i<=mn;i++) //最后对满足条件的边权求和可得
		if (match[i] > -1)
			sum += w[match[i]][i];
	return -sum;  //输出相反数即为最小值
}

int main(){
    while(scanf("%d%d",&N,&M)!=EOF && (N||M)){
        mn=hn=0;
        memset(w,-inf,sizeof(w));//初始化
        for(int i=0;i<N;i++) 
            for(int j=0;j<M;j++){
                cin>>map[i][j];
                if(map[i][j]=='H'){ //获取房子的边集
                    h[++hn].x=i;
                    h[hn].y=j;
                }
                if(map[i][j]=='m'){ //获取人的边集
                    m[++mn].x=i;
                    m[mn].y=j;
                }
            }
        for(int i=1;i<=mn;i++) //计算边权，即每个人到每个房子的曼哈顿距离
            for(int j=1;j<=hn;j++){
                val=ABS(h[j].x-m[i].x)+ABS(h[j].y-m[i].y); //曼哈顿距离
                w[i][j]=-val;  //由于要求最小值，而KM算法是求最大值，因此边权存入负值
            }
        printf("%d\n",KM());
    }
    return 0;
}