POJ2195 Going Home —— 最大权匹配 or 最小费用最大流

题目链接：https://vjudge.net/problem/POJ-2195

Going Home

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 24015		Accepted: 12054

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

Source

Pacific Northwest 2004

题意：

给出一张n*m的图，其中里面有数量相等的人和房屋。下雨了，要为每个人安排一座房屋，且每个房屋只能容纳一个人。问：怎样安排，才能使得总的路程最短（不用考虑房屋与人的阻碍问题，即两点距离直接是曼哈顿距离）？

题解：

最大权匹配的裸题，把权值取反即可。或者用最小费用最大流去做也可以。

最大权匹配：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <cmath>
 #include <queue>
 #include <stack>
 #include <map>
 #include <string>
 #include <set>
 using namespace std;
 typedef long long LL;
 const int INF = 2e9;
 const LL LNF = 9e18;
 const int mod = 1e9+;
 const int MAXN = 1e2+;

 int nx, ny;
 int g[MAXN][MAXN];
 int linker[MAXN], lx[MAXN], ly[MAXN];
 int slack[MAXN];
 bool visx[MAXN], visy[MAXN];

 bool DFS(int x)
 {
     visx[x] = true;
     for(int y = ; y<=ny; y++)
     {
         if(visy[y]) continue;
         int tmp = lx[x] + ly[y] - g[x][y];
         if(tmp==)
         {
             visy[y] = true;
             if(linker[y]==- || DFS(linker[y]))
             {
                 linker[y] = x;
                 return true;
             }
         }
         else
             slack[y] = min(slack[y], tmp);
     }
     return false;
 }

 int KM()
 {
     memset(linker, -, sizeof(linker));
     memset(ly, , sizeof(ly));
     for(int i = ; i<=nx; i++)
     {
         lx[i] = -INF;
         for(int j = ; j<=ny; j++)
             lx[i] = max(lx[i], g[i][j]);
     }

     for(int x = ; x<=nx; x++)
     {
         for(int i = ; i<=ny; i++)
             slack[i] = INF;
         while(true)
         {
             memset(visx, , sizeof(visx));
             memset(visy, , sizeof(visy));

             if(DFS(x)) break;
             int d = INF;
             for(int i = ; i<=ny; i++)
                 if(!visy[i])
                     d = min(d, slack[i]);

             for(int i = ; i<=nx; i++)
                 if(visx[i])
                     lx[i] -= d;
             for(int i = ; i<=ny; i++)
             {
                 if(visy[i]) ly[i] += d;
                 else slack[i] -= d;
             }
         }
     }

     int res = ;
     for(int i = ; i<=ny; i++)
         if(linker[i]!=-)
             res += g[linker[i]][i];
     return res;
 }

 int house[MAXN][], man[MAXN][];
 int main()
 {
     int n, m;
     char str[MAXN];
     while(scanf("%d%d",&n,&m)&&(m||n))
     {
         nx  = , ny = ;
         for(int i = ; i<=n; i++)
         {
             scanf("%s", str+);
             for(int j = ; j<=m; j++)
             {
                 if(str[j]=='H') house[++nx][] = i, house[nx][] = j;
                 else if(str[j]=='m') man[++ny][] = i, man[ny][] = j;
             }
         }

         memset(g, , sizeof(g));
         for(int i = ; i<=nx; i++)
         for(int j = ; j<=ny; j++)
             g[i][j] = -(abs(house[i][]-man[j][])+abs(house[i][]-man[j][]));

         int ans = -KM();
         printf("%d\n", ans);
     }
 }

最小费用最大流：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <cmath>
 #include <queue>
 #include <stack>
 #include <map>
 #include <string>
 #include <set>
 using namespace std;
 typedef long long LL;
 const int INF = 2e9;
 const LL LNF = 9e18;
 const int mod = 1e9+;
 const int MAXN = 1e3+;

 struct Edge
 {
     int to, next, cap, flow, cost;
 }edge[<<];
 int tot, head[MAXN];
 int pre[MAXN], dis[MAXN];
 bool vis[MAXN];
 int N;

 void init(int n)
 {
     N = n;
     tot = ;
     memset(head, -, sizeof(head));
 }

 void add(int u, int v, int cap, int cost)
 {
     edge[tot].to = v;  edge[tot].cap = cap;  edge[tot].cost = cost;
     edge[tot].flow = ;   edge[tot].next = head[u];   head[u] = tot++;

     edge[tot].to = u;   edge[tot].cap = ;  edge[tot].cost = -cost;
     edge[tot].flow = ; edge[tot].next = head[v];   head[v] = tot++;
 }

 bool spfa(int s, int t)
 {
     queue<int>q;
     for(int i = ; i<N; i++)
     {
         dis[i] = INF;
         vis[i] = false;
         pre[i] = -;
     }

     dis[s] = ;
     vis[s] = true;
     q.push(s);
     while(!q.empty())
     {
         int u  = q.front();
         q.pop();
         vis[u] = false;
         for(int i = head[u]; i!=-; i = edge[i].next)
         {
             int v = edge[i].to;
             if(edge[i].cap>edge[i].flow && dis[v]>dis[u]+edge[i].cost)
             {
                 dis[v] = dis[u]+edge[i].cost;
                 pre[v] = i;
                 if(!vis[v])
                 {
                     vis[v] = true;
                     q.push(v);
                 }
             }
         }
     }
     if(pre[t]==-) return false;
     return true;
 }

 int minCostMaxFlow(int s, int t, int &cost)
 {
     int flow = ;
     cost = ;
     while(spfa(s,t))
     {
         int Min = INF;
         for(int i = pre[t]; i!=-; i = pre[edge[i^].to])
         {
             if(Min>edge[i].cap-edge[i].flow)
                 Min = edge[i].cap-edge[i].flow;
         }
         for(int i = pre[t]; i!=-; i = pre[edge[i^].to])
         {
             edge[i].flow += Min;
             edge[i^].flow -= Min;
             cost += edge[i].cost*Min;
         }
         flow += Min;
     }
     return flow;
 }

 int house[MAXN][], man[MAXN][];
 int main()
 {
     int n, m;
     char str[MAXN];
     while(scanf("%d%d",&n,&m)&&(m||n))
     {
         int nx  = , ny = ;
         for(int i = ; i<=n; i++)
         {
             scanf("%s", str+);
             for(int j = ; j<=m; j++)
             {
                 if(str[j]=='H') house[++nx][] = i, house[nx][] = j;
                 else if(str[j]=='m') man[++ny][] = i, man[ny][] = j;
             }
         }

         init(nx+ny+);
         for(int i = ; i<=nx; i++)
         for(int j = ; j<=ny; j++)
             add(i,nx+j,,abs(house[i][]-man[j][])+abs(house[i][]-man[j][]));

         for(int i = ; i<=nx; i++) add(,i,,);
         for(int i = ; i<=ny; i++) add(nx+i,nx+ny+,,);

         int mincost;
         minCostMaxFlow(, nx+ny+, mincost);
         printf("%d\n", mincost);
     }
 }