题意：有一个矩阵，某些格有人，某些格有房子，每个人可以上下左右移动，问给每个人进一个房子，所有人需要走的距离之和最小是多少。
貌似以前见过很多这样类似的题，都不会，现在知道是用KM算法做了
KM算法目前还没弄懂，先套模板做
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
#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
#include<math.h>
using namespace std;
const int MAXN=;
const int INF=0x3fffffff;
int g[MAXN][MAXN],match1[MAXN],match2[MAXN];
int KM(int m,int n)
{
int i,j,k,p,q;
int l1[MAXN],l2[MAXN];
int s[MAXN],t[MAXN];
int ret=;
for(i=;i<m;i++)
{
l1[i]=-INF;
for(j=;j<n;j++)
if(g[i][j]>l1[i])
l1[i]=g[i][j];
if(l1[i]==-INF) return -;//无法匹配
}
for(i=;i<n;i++)l2[i]=; memset(match1,-,sizeof(match1));
memset(match2,-,sizeof(match2));
for(i=;i<m;i++)
{
memset(t,-,sizeof(t));
for(s[p=q=]=i;p<=q&&match1[i]<;p++)
for(k=s[p],j=;j<n&&match1[i]<;j++)
if(l1[k]+l2[j]==g[k][j]&&t[j]<)
{
s[++q]=match2[j],t[j]=k;
if(s[q]<)
for(p=j;p>=;j=p)
match2[j]=k=t[j],p=match1[k],match1[k]=j;
} if(match1[i]<)
{
for(i--,p=INF,k=;k<=q;k++)
for(j=;j<n;j++)
if(t[j]<&&l1[s[k]]+l2[j]-g[s[k]][j]<p)
p=l1[s[k]]+l2[j]-g[s[k]][j]; for(j=;j<n;j++)if(t[j]>=)l2[j]+=p;
for(k=;k<=q;k++)l1[s[k]]-=p;
}
}
for(i=;i<m;i++)
{
if(match1[i]<)return -;//无法匹配
if(g[i][match1[i]]<=-INF)return -;
ret+=g[i][match1[i]];
}
return ret;
}
struct Node
{
int x,y;
};
Node node1[MAXN],node2[MAXN];
char str[MAXN];
int main()
{
int n,m;
int nx,ny;
while(scanf("%d%d",&n,&m)!=EOF)
{
if(n==&&m==)break;
nx=;
ny=;
for(int i=;i<n;i++)
{
scanf("%s",&str);
for(int j=;j<m;j++)
{
if(str[j]=='m')
{
node1[nx].x=i;
node1[nx].y=j;
nx++;
}
else if(str[j]=='H')
{
node2[ny].x=i;
node2[ny].y=j;
ny++;
}
}
}
for(int i=;i<nx;i++)
for(int j=;j<ny;j++)
{
g[i][j]=-abs(node1[i].x-node2[j].x)-abs(node1[i].y-node2[j].y);
}
printf("%d\n",-KM(nx,ny));
}
return ;
}
/*
POJ 2195 Going Home
邻接矩阵形式最小费用最大流
*/ #include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std; //************************************************************
//最小费用最大流算法
//SPFA求最短路
//邻接矩阵形式
//初始化:cap:容量，没有边为0
//cost:耗费，对称形式，没有边的也为0
//c是最小费用
//f是最大流
//*******************************************************
const int MAXN=;
const int INF=0x3fffffff;
int cap[MAXN][MAXN];//容量，没有边为0
int flow[MAXN][MAXN];
//耗费矩阵是对称的，有i到j的费用，则j到i的费用为其相反数
int cost[MAXN][MAXN]; int n;//顶点数目0~n-1
int f;//最大流
int c;//最小费用
int start,end;//源点和汇点 bool vis[MAXN];//在队列标志
int que[MAXN];
int pre[MAXN];
int dist[MAXN];//s-t路径最小耗费
bool SPFA()
{
int front=,rear=;
for(int u=;u<=n;u++)
{
if(u==start)
{
que[rear++]=u;
dist[u]=;
vis[u]=true;
}
else
{
dist[u]=INF;
vis[u]=false;
}
}
while(front!=rear)
{
int u=que[front++];
vis[u]=false;
if(front>=MAXN)front=;
for(int v=;v<=n;v++)
{
if(cap[u][v]>flow[u][v]&&dist[v]>dist[u]+cost[u][v])
{
dist[v]=dist[u]+cost[u][v];
pre[v]=u;
if(!vis[v])
{
vis[v]=true;
que[rear++]=v;
if(rear>=MAXN)rear=;
}
}
}
}
if(dist[end]>=INF)return false;
return true;
} void minCostMaxflow()
{
memset(flow,,sizeof(flow));
c=f=;
while(SPFA())
{
int Min=INF;
for(int u=end;u!=start;u=pre[u])
Min=min(Min,cap[pre[u]][u]-flow[pre[u]][u]);
for(int u=end;u!=start;u=pre[u])
{
flow[pre[u]][u]+=Min;
flow[u][pre[u]]-=Min;
}
c+=dist[end]*Min;
f+=Min;
}
}
//************************************************************ struct Node
{
int x,y;
};
Node node1[MAXN],node2[MAXN];
char str[MAXN][MAXN];
int main()
{
//freopen("in.txt","r",stdin);
//freopen("out.txt","w",stdout);
int N,M;
while(scanf("%d%d",&N,&M))
{
if(N==&&M==)break;
int tol1=,tol2=;
for(int i=;i<N;i++)
{
scanf("%s",&str[i]);
for(int j=;j<M;j++)
{
if(str[i][j]=='m')
{
tol1++;
node1[tol1].x=i;
node1[tol1].y=j;
}
else if(str[i][j]=='H')
{
tol2++;
node2[tol2].x=i;
node2[tol2].y=j;
}
}
}
start=;
n=tol1+tol2+;
end=tol1+tol2+;
memset(cap,,sizeof(cap));
memset(cost,,sizeof(cost));
for(int i=;i<=tol1;i++)
{
cost[][i]=cost[i][]=;
cap[][i]=;
}
for(int i=;i<=tol2;i++)
{
cost[tol1+i][end]=;
cap[tol1+i][end]=;
}
for(int i=;i<=tol1;i++)
for(int j=;j<=tol2;j++)
{
cost[i][tol1+j]=abs(node1[i].x-node2[j].x)+abs(node1[i].y-node2[j].y);
cost[tol1+j][i]=-cost[i][tol1+j];
cap[i][tol1+j]=;
}
minCostMaxflow();
printf("%d\n",c);
}
return ;
}
/*
POJ 2195 Going Home
邻接表形式最小费用最大流
*/ #include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std; const int MAXN=;
const int MAXE=;
const int INF=0x3f3f3f3f;
struct Edge
{
int from;
int to;
int next;
int re;//记录逆边的下标
int cap;//容量
int cost;//费用
}edge[MAXE];
int pre[MAXN];
int head[MAXN];
bool vis[MAXN];
int que[MAXN];
int dist[MAXN];
int tol;//边的总数
void add(int u,int v,int ca,int co)
{
edge[tol].from=u;
edge[tol].to=v;
edge[tol].cap=ca;
edge[tol].cost=co;
edge[tol].re=tol+;
edge[tol].next=head[u];
head[u]=tol++; edge[tol].from=v;//加逆边
edge[tol].to=u;
edge[tol].cap=;
edge[tol].cost=-co;
edge[tol].re=tol-;
edge[tol].next=head[v];
head[v]=tol++;
}
int n;
int start;
int end;
bool SPFA()
{
int front=,rear=;
for(int v=;v<=n;v++)
{
if(v==start)
{
que[rear++]=v;
vis[v]=true;
dist[v]=;
}
else
{
dist[v]=INF;
vis[v]=false;
}
}
while(front!=rear)
{
int u=que[front++];
vis[u]=false;
if(front>=MAXN)front=;
for(int i=head[u];i!=-;i=edge[i].next)
{
int v=edge[i].to;
if(edge[i].cap&&dist[v]>dist[u]+edge[i].cost)
{
dist[v]=dist[u]+edge[i].cost;
pre[v]=i;
if(!vis[v])
{
que[rear++]=v;
vis[v]=true;
if(rear>=MAXN)rear=;
}
}
}
}
if(dist[end]==INF)return false;
return true;
}
int c;//费用
int f;//最大流 void minCostMaxflow()
{
c=f=;
int u,p;
while(SPFA())
{
int Min=INF;
for(u=end;u!=start;u=edge[p].from)
{
p=pre[u];
Min=min(Min,edge[p].cap);
}
for(u=end;u!=start;u=edge[p].from)
{
p=pre[u];
edge[p].cap-=Min;
edge[edge[p].re].cap+=Min; }
c+=dist[end]*Min;
f+=Min;
}
} struct Node
{
int x,y;
};
Node node1[MAXN],node2[MAXN];
char str[MAXN][MAXN];
int main()
{
// freopen("in.txt","r",stdin);
//freopen("out.txt","w",stdout);
int N,M;
while(scanf("%d%d",&N,&M))
{
if(N==&&M==)break;
int tol1=,tol2=;
for(int i=;i<N;i++)
{
scanf("%s",&str[i]);
for(int j=;j<M;j++)
{
if(str[i][j]=='m')
{
tol1++;
node1[tol1].x=i;
node1[tol1].y=j;
}
else if(str[i][j]=='H')
{
tol2++;
node2[tol2].x=i;
node2[tol2].y=j;
}
}
}
start=;
n=tol1+tol2+;
end=tol1+tol2+; //加边之前一定要初始化
tol=;//边数
memset(head,-,sizeof(head));//一定要初始化为-1 for(int i=;i<=tol1;i++)
{
add(,i,,);
}
for(int i=;i<=tol2;i++)
{
add(tol1+i,end,,);
}
for(int i=;i<=tol1;i++)
for(int j=;j<=tol2;j++)
{
int temp=abs(node1[i].x-node2[j].x)+abs(node1[i].y-node2[j].y);
add(i,tol1+j,,temp);
}
minCostMaxflow();
printf("%d\n",c);
}
return ;
}