转载自这里
最小费用最大流
通过EK，Dinic，ISAP算法可以得到网络流图中的最大流，一个网络流图中最大流的流量max_flow是唯一的，但是达到最大流量max_flow时每条边上的流量分配f是不唯一的。
如果给网络流图中的每条边都设置一个费用cost，表示单位流量流经该边时会导致花费cost。那么在这些流量均为max_flow的流量分配f中，存在一个流量总花费最小的最大流方案。
即min{ sum( cost(i, j)*f(i,j) | (i, j) 属于方案f中的边， f(i,j)为 边(i,j)上的流量， f为某一个最大流方案}。此即为最小费用最大流。
算法思想
采用贪心的思想，每次找到一条从源点到达汇点的路径，增加流量，且该条路径满足使得增加的流量的花费最小，直到无法找到一条从源点到达汇点的路径，算法结束。
由于最大流量有限，每执行一次循环流量都会增加，因此该算法肯定会结束，且同时流量也必定会达到网络的最大流量；同时由于每次都是增加的最小的花费，即当前的最小花费是所有到达当前流量flow时的花费最小值，因此最后的总花费最小。
求解步骤
（1）找到一条从源点到达汇点的“距离最短”的路径，“距离”使用该路径上的边的单位费用之和来衡量。
（2）然后找出这条路径上的边的容量的最小值f，则当前最大流max_flow扩充f，同时当前最小费用min_cost扩充 f*min_dist(s,t)。
（3）将这条路径上的每条正向边的容量都减少f，每条反向边的容量都增加f。
（4）重复（1）--（3）直到无法找到从源点到达汇点的路径。
需要注意几点
1、注意超级源点和超级终点的建立。
2、初始化时，正向边的单位流量费用为cost[u][v]，那么反向边的单位流量费用就为-cost[u][v]。因为回流费用减少。
3、费用cost数组和容量cap数组每次都要初始化为0。
求解从源点到汇点的“最短”路径时，由于网络中存在负权边，因此使用SPFA来实现。
加上自己的一点见解:其实就是Edmonds_Karp算法中的BFS换成SPFA,同时边上有单位流量流经该边时的花费cost。每次求出可行流时,当前的最小费用就是最小距离*最大流流量。
A - Going Home
题意:
给出一个地图，H代表房子，m代表人，两者数量相等，人每移动一格花费1，每个房子只能住一个人,求所有人走到房子里所需要的最小花费。
题解:
很容易知道这是最优匹配问题,所以可以像最大匹配那样建图:
超级源点连向人,容量为1,单位费用流为0;
房子连超级汇点,容量为1,单位费用流为0;
二分图的边容量也为1,单位费用流为房子和人的哈密顿距离;
#include
#include
#include
#include
#include
using namespace std;
const int MAXN=250;
const int MAXE=21000;
const int INF=0x3f3f3f3f;
struct Node
{
int to,next,c,cost;
Node(){}
Node(int to,int next,int c,int cost):to(to),next(next),c(c),cost(cost){}
};
int head[MAXN],cnt;
Node edge[MAXE];
void addEdge(int u,int v,int c,int cost)
{
edge[cnt]=Node(v,head[u],c,cost);
head[u]=cnt++;
edge[cnt]=Node(u,head[v],0,-cost);
head[v]=cnt++;
}
int inque[MAXN],dis[MAXN],pre[MAXN];
bool BFS(int st,int ed,int &cost)
{
queue que;
que.push(st);
memset(inque,0,sizeof(inque));
memset(dis,INF,sizeof(dis));
dis[st]=0;
pre[st]=pre[ed]=-1;
int u,v;
while(!que.empty())
{
u=que.front();que.pop();
inque[u]=0;
for(int i=head[u];i!=-1;i=edge[i].next)
{
v=edge[i].to;
if(edge[i].c>0&&dis[v]>dis[u]+edge[i].cost)
{
dis[v]=dis[u]+edge[i].cost;
pre[v]=i;
if(inque[v]==0)
{
inque[v]=1;
que.push(v);
}
}
}
}
if(pre[ed]==-1) return false;
int flow=INF;
for(int i=pre[ed];i!=-1;i=pre[edge[i^1].to])
{
flow=min(flow,edge[i].c);
}
for(int i=pre[ed];i!=-1;i=pre[edge[i^1].to])
{
edge[i].c-=flow;
edge[i^1].c+=flow;
}
cost+=dis[ed]*flow;//累加最小费用
return true;
}
struct Object
{
int x,y;
Object(int x=0,int y=0):x(x),y(y){}
};
Object man[110],house[110];
int mcnt,hcnt;
char graph[110][110];
int main()
{
int n,m,cost,st,ed;
while(scanf("%d%d",&n,&m)!=EOF,n+m)
{
memset(head,-1,sizeof(head));
cost=cnt=mcnt=hcnt=0;
for(int i=1;i<=n;i++)
{
scanf("%s",graph[i]+1);
for(int j=1;j<=m;j++)
{
if(graph[i][j]=='m')
{
man[++mcnt]=Object(i,j);
}
else if(graph[i][j]=='H')
{
house[++hcnt]=Object(i,j);
}
}
}
st=0;ed=mcnt*2+1;
for(int i=1;i<=mcnt;i++)
{
addEdge(st,i,1,0);
for(int j=1;j<=hcnt;j++)
{
addEdge(i,mcnt+j,1,abs(man[i].x-house[j].x)+abs(man[i].y-house[j].y));
}
}
for(int i=1;i<=hcnt;i++)
{
addEdge(i+mcnt,ed,1,0);
}
while(BFS(st,ed,cost));
printf("%d\n",cost);
}
}