POJ 2195 Going Home / HDU 1533（最小费用最大流模板）

题目大意：

有一个最大是100 * 100 的网格图，上面有 s 个 房子和人，人每移动一个格子花费1的代价，求最小代价让所有的人都进入一个房子。每个房子只能进入一个人。

算法讨论：

注意是KM 和 MCMF算法，我写的是MCMF算法，一开始想的是连10000个点，但是不会连那些大众点之间的边，只会连超级点和普通点之间的边。后来觉得只要连房子点和

人点就可以了。连从人到房子的边，容量是1，花费是他们之间的曼哈顿距离，然后超级源点和超级汇点像上面那样连接，注意连点的时候把他们每个点都具体化一下，就是把点值

都精确到一个连续的范围内去。然后做从超级源点到超级汇点的MCMF算法就可以了。至于那10000个之间的连边，觉得虽然效率不高，但是还是有必要考虑一下。大家有知道的撒

告诉一下。感谢万分。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>

using namespace std;

struct MCMF{
    static const int N = 200 * 200 + 5;
    static const int M = 200 * 200 * 4 + 100;
    static const int oo = 0x3f3f3f3f;
    
    int n, m, s, t, tot;
    int first[N], next[M];
    int u[M], v[M], cap[M], flow[M], cost[M];
    int dis[N], a[N], inque[N], pre[N];
    
    void Clear(){memset(first, -1, sizeof first);tot = 0;}
    
    void Add(int from, int to, int cp, int flw, int ct){
        u[tot] = from; v[tot] = to; cap[tot] = cp; flow[tot] = 0; cost[tot] = ct;
        next[tot] = first[u[tot]];
        first[u[tot]] = tot; ++ tot;
        u[tot] = to; v[tot] = from; cap[tot] = 0; flow[tot] = 0; cost[tot] = -ct;
        next[tot] = first[u[tot]];
        first[u[tot]] = tot; ++ tot;    
    }
    
    bool bfs(int &flw, int &ct){
        for(int i = 0; i <= n + 1; ++ i) dis[i] = oo;
        memset(inque, 0, sizeof inque);
        dis[s] = 0; pre[s] = 0; a[s] = oo; inque[s] = 1;
        
        queue <int> q;
        q.push(s);
        while(!q.empty()){
            int now = q.front(); q.pop();
            inque[now] = 0;
            
            for(int i = first[now]; i != -1; i = next[i]){
                if(cap[i] > flow[i] && dis[v[i]] > dis[now] + cost[i]){
                    dis[v[i]] = dis[now] + cost[i];
                    a[v[i]] = min(a[now], cap[i] - flow[i]);
                    pre[v[i]] = i;
                    if(!inque[v[i]]){
                        inque[v[i]] = 1; q.push(v[i]);
                    }
                }
            }
        }
        
        if(dis[t] == oo) return false;
        flw += a[t];
        ct += dis[t] * a[t];
        
        int now = t;
        while(now != s){
            flow[pre[now]] += a[t];
            flow[pre[now]^1] -= a[t];
            now = u[pre[now]];
        }
        return true; 
    }
    
    int MinCostMaxFlow(int s, int t){
        this->s = s;this->t = t;
        int flw = 0, ct = 0;
        while(bfs(flw, ct));
        return ct;
    }
}Net;

struct Position{
    int l, r, id;
    Position(int _l=0, int _r=0, int _id=0): l(_l), r(_r), id(_id){}
}mm[205], HH[205];

int ns, ms, cnt1, cnt2, tp1, tp2;
char str[105][105];

void Solve(){
        for(int i = 1; i <= tp1; ++ i){
            for(int j = 1; j <= tp2; ++ j){
                int x1 = mm[i].l, y1 = mm[i].r;
                int x2 = HH[j].l, y2 = HH[j].r;
                Net.Add(mm[i].id, HH[j].id, 1, 0, abs(x1-x2) + abs(y1-y2));
            }
        }
}

int main(){
    
    while(scanf("%d%d", &ns, &ms) && ns && ms){
        Net.Clear();
        cnt1 = cnt2 = 0;
        tp1 = tp2 = 0;
        for(int i = 1; i <= ns; ++ i)
            scanf("%s", str[i] + 1);
        for(int i = 1; i <= ns; ++ i){
            for(int j = 1; j <= ms; ++ j){
                if(str[i][j] == 'm') ++ tp1;
                else if (str[i][j] == 'H') ++ tp2;
            }
        }
        Net.n = tp1 + tp2;
        for(int i = 1; i <= ns; ++ i){
            for(int j = 1; j <= ms; ++ j){
                if(str[i][j] == 'm'){
                    ++ cnt1;
                    Net.Add(0, cnt1, 1, 0, 0);
                    mm[cnt1] = (Position){i, j, cnt1};
                }
            }
        }
        for(int i = 1; i <= ns; ++ i){
            for(int j = 1; j <= ms; ++ j){
                if(str[i][j] == 'H'){
                    ++ cnt2;
                    Net.Add(tp1 + cnt2, Net.n + 1, 1, 0, 0);
                    HH[cnt2] = (Position){i, j, tp1 + cnt2};
                }
            }
        }
        Solve();
        printf("%d
", Net.MinCostMaxFlow(0, Net.n + 1));
    }
    
    return 0;
}