POJ 2195 Going Home(KM或费用流)

题意：给一个字符矩阵，m表示man，H表示house。人和房子个数相等。一个房子只能住一个人，要求所有人走到空的房子，每走一步花费1，要求总的花费最小，输出最小值。

解法1：KM，给定一个带权的二分图，求权值最大的完美匹配。O(N^3),N为人的数量

题意要求总花费最小，用KM只需要把花费弄成相反数（负数），再运行KM算法，求出后结果是一个负的最大值，输出它的相反数就是正的最小了。

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <string.h>
#include <map>
#include <set>
using namespace std;
#define maxn 505
#define inff 1<<30
char ch[maxn][maxn];
struct node
{
    int x,y;
}mat[maxn];
int e[maxn][maxn];
int n,m,tot;
int abs(int x)
{
    if(x<0)
    return -x;
    else return x;
}
int t[maxn],s[maxn],lx[maxn],ly[maxn],r[maxn];
int match(int i)
{
    int j;
    s[i]=1;
    for(j=1;j<tot;j++)
    {
        if(lx[i]+ly[j]==e[i][j]&&!t[j])
        {
            t[j]=1;
            if(!r[j]||match(r[j]))
            {
                r[j]=i;
                return 1;
            }
        }
    }
    return 0;
}
void update()
{
    int a=inff;
    for(int i=1;i<tot;i++)
    {
        if(s[i])
        for(int j=1;j<tot;j++)
            if(!t[j])a=min(a,lx[i]+ly[j]-e[i][j]);
    }
    for(int i=1;i<tot;i++)
    {
        if(s[i])
            lx[i]-=a;
        if(t[i])
            ly[i]+=a;
    }
}
void km()
{
    int i,j;
   for(i=1;i<tot;i++)
   {
       r[i]=lx[i]=ly[i]=0;
       for(j=1;j<tot;j++)
       {
           lx[i]=max(lx[i],e[i][j]);
       }
   }
   for(i=1;i<tot;i++)
   {
       while(1)
       {
           memset(s,0,sizeof s);
           memset(t,0,sizeof t);
           if(match(i))break;
           else update();

       }
   }
}
int main()
{
    int i,j,num;
   while(scanf("%d%d",&n,&m)!=EOF)
   {
       if(n==0&&m==0)break;
       tot=1;
       memset(e,0,sizeof e);
       for(i=0;i<n;i++)
       {
           scanf("%s",ch[i]);
           for(j=0;j<m;j++)
            if(ch[i][j]=='m')mat[tot].x=i,mat[tot++].y=j;
       }
       num=tot;
       for(i=0;i<n;i++)
        for(j=0;j<m;j++)
        if(ch[i][j]=='H')
        mat[num].x=i,mat[num++].y=j;
       for(i=1;i<tot;i++)
       {
           for(j=tot;j<num;j++)
           {
               e[i][j-tot+1]=-abs(mat[i].x-mat[j].x)-abs(mat[i].y-mat[j].y);
               //cout<<e[i][j-tot+1]<<" ";
           }
          // cout<<endl;
       }

       km();
       int ans=0;
       for(j=1;j<tot;j++)
       {
            ans+=e[r[j]][j];
       }

       printf("%d\n",-ans);

   }
  return 0;
}

解法2：费用流，建立一个超级源点（0）和一个总汇点（num+1,num是最大点的编号）。

源点和人的容量为1，花费为 0

房子和汇点的容量为1，花费为0

人和房子花费（距离）其实就是他们横纵坐标对应相减再相加，容量为1。

因为所有容量为1，时间复杂度为O(min(n^2/3,m^1/2)*m)，n为总的点数，m为总的边数

#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define MAXN 505
#define MAXM 505*500*2
#define LL long long
#define INF 0x3f7f7f7f
const double eps = 1e-10;
struct Edge
{
    int from,to,cap,flow,cost;
    Edge(int from=0,int to=0,int cap=0,int flow=0,int cost=0)
    {
        this->from=from;
        this->to=to;
        this->cap=cap;
        this->flow=flow;
        this->cost=cost;
    }
};
vector<Edge>edges;
vector<int>g[MAXN];
bool vis[MAXN];
int dis[MAXN];
int pre[MAXN];
int a[MAXN];
int n,m,s,t;
void init()
{
    for(int i=0;i<MAXN;i++)
    {
        g[i].clear();
    }
    edges.clear();
}
void add(int from,int to,int cap,int cost)
{
    edges.push_back(Edge(from,to,cap,0,cost));
    edges.push_back(Edge(to,from,0,0,-cost));
    int m=edges.size();
    g[from].push_back(m-2);
    g[to].push_back(m-1);
}
bool spfa(int &flow,int &cost)
{
    int i;
    for(i=0;i<MAXN;i++)
        dis[i]=INF;
    memset(vis,0,sizeof(vis));
    queue<int>q;
    q.push(s);
    dis[s]=0;
    vis[s]=1;
    pre[s]=0;
    a[s]=INF;
   while(!q.empty())
   {
       int u=q.front();
       q.pop();
       vis[u]=0;
       int sz=g[u].size();
       for(i=0;i<sz;i++)
       {
           Edge &e=edges[g[u][i]];
           if(e.cap>e.flow&&dis[e.to]>dis[u]+e.cost)
           {
               dis[e.to]=dis[u]+e.cost;
               pre[e.to]=g[u][i];
               a[e.to]=min(a[u],e.cap-e.flow);
               if(!vis[e.to])
               {
                   vis[e.to]=1;
                   q.push(e.to);
               }
           }
       }
   }
   if(dis[t]==INF)
    return false;
   flow+=a[t];
   cost+=dis[t]*a[t];
   int v=t;
   while(v!=s)
   {
       edges[pre[v]].flow+=a[t];
       edges[pre[v]^1].flow-=a[t];
       v=edges[pre[v]].from;
   }
   return true;
}

int minCost()
{
    int flow=0,cost=0;
    while(spfa(flow,cost));
    return cost;
}
struct node
{
    node(int x=0,int y=0):x(x),y(y){}
    int x,y;
};
int ABS(int x)
{
    return x>0?x:-x;
}
struct node p[MAXN*MAXN];
char maze[MAXN][MAXN];
int main()
{
    int i,j,tot,num;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0&&m==0)break;
        tot=num=0;
        for(i=1;i<=n;i++)
        {
            scanf("%s",maze[i]+1);
            for(j=1;j<=m;j++)
            {
                if(maze[i][j]=='m')
                    p[++tot]=node(i,j);
            }
        }
        num=tot;
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=m;j++)
            {
                if(maze[i][j]=='H')
                    p[++num]=node(i,j);
            }
        }
        init();
        for(i=1;i<=tot;i++)
        {
            for(j=tot+1;j<=num;j++)
            {
                int len=ABS(p[i].x-p[j].x)+ABS(p[i].y-p[j].y);
               // cout<<"\\"<<len<<endl;
                add(i,j,1,len);
            }
        }
        for(i=1;i<=tot;i++)
            add(0,i,1,0);
        for(i=tot+1;i<=num;i++)
            add(i,num+1,1,0);
        s=0,t=num+1;
        cout<<minCost()<<endl;
    }
    return 0;
}