最小费用最大流

转载自这里
最小费用最大流
  通过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<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
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<int> 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);
    }
}

推荐阅读更多精彩内容