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;
}