hdu 1533 Going Home (最小费用流)

解题思路：可以很明显的看出来最小费用流的模型，还可以使用KM算法做。

AC代码：

/*
* @Author: wchhlbt
* @Last Modified time: 2017-11-20
*/

//#include <bits/stdc++.h>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <limits>
#include <climits>
#include <cstdio>

#define inf 0x3f3f3f3f
#define pb push_back
#define AA first
#define BB second
#define ONES(x) __builtin_popcount(x)
#define _ << " " <<
using namespace std;

typedef pair<int, int> P;
typedef long long ll ;
int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};
const double eps =1e-3;
const int mod = 1000000007;
const double PI = acos(-1.0);
inline int read(){ int num; scanf("%d",&num); return num;}
const int maxn = 202;

struct Edge{
int to,cap,cost,rev; //终点、容量、费用、反向边
Edge(){}
Edge(int t,int c,int ct,int r) : to(t),cap(c),cost(ct),rev(r) {}
};
struct MinCostFlow
{
int n; //顶点数 顶点编号从 0 - n-1
int s,t; //源端点和目的端点
int f; //流量为f
//maxn ≥ n
vector<Edge> G[maxn]; //图的邻接表
int dist[maxn]; //最短距离
int prevv[maxn],preve[maxn]; //最短路中的前驱节点和对应的边

void init(int n,int s,int t,int f)
{
this->n = n, this->s = s, this->t = t, this->f = f;
for(int i = 0; i<n; i++) G[i].clear();
}

//向图中增加一条从from到to容量为cap费用为cost的边
void add_edge(int from,int to,int cap,int cost){
G[from].push_back( Edge(to,cap,cost,G[to].size()) );
G[to].push_back( Edge(from,0,-cost,G[from].size()-1) );
}
//求解从s到t流量为f的最小费用流，如果不能再增广则返回-1
int min_cost_flow(){
int res = 0;
while(f > 0){ //用Bellman-Ford算法求s到t的最短路
memset(dist,inf,sizeof dist);
dist[s] = 0;
bool update = true;
while(update){
update = false;
for(int v = 0 ; v < n ; v++){
if(dist[v] == inf)
continue;
for(int i = 0 ; i < G[v].size() ; i++){
Edge &e = G[v][i];
if(e.cap > 0 && dist[e.to] > dist[v] + e.cost){
dist[e.to] = dist[v] + e.cost;
prevv[e.to] = v;
preve[e.to] = i;
update = true;
}
}
}
}
if(dist[t] == inf) //不能再增广
return res;
int d = f;
for(int v = t; v != s ; v = prevv[v])
d = min(d,G[prevv[v]][preve[v]].cap);
f -= d;
res += d * dist[t];
for(int v = t ; v != s ; v = prevv[v]){
Edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
}MCF;

char s[111][111];
vector<P> man;
vector<P> house;

int main()
{
int n,m;
while(~scanf("%d%d",&n,&m) && n+m){
man.clear();
house.clear();
for(int i = 0; i<n; i++){
scanf("%s",s+i);
}
for(int i = 0; i<n; i++){
for(int j = 0; j<m; j++){
if(s[i][j] == 'm' )
man.pb(make_pair(i,j));
if(s[i][j] == 'H')
house.pb(make_pair(i,j));
}
}
int l = man.size();
int r = house.size();

MCF.init(l+r+2,0,l+r+1,l);
for(int i = 0; i<man.size(); i++){
MCF.add_edge(0,1+i,1,0);
for(int j = 0; j<house.size(); j++){
MCF.add_edge(1+i,l+j+1,1,abs(house[j].AA-man[i].AA) + abs(house[j].BB - man[i].BB));
}
}
for(int i = 0; i<r; i++)
MCF.add_edge(l+i+1,l+r+1,1,0);

printf("%d\n",MCF.min_cost_flow());
}
return 0;
}