【网络流】【最小费用最大流】【spfa::EK】【建图】POJ 2195 Going Home

【题目】http://poj.org/problem?id=2195

【题意】一个N行M列的矩阵，其中“.”代表空地，“H”代表房子，“m”代表人，其中有 n 个房子和 n 个人。现在要求每个人进入其中的一间房子，且每人每走一步需要支付1美元。求最小需要花费多少美元能让所有人都进入到房子中（每个人只能进入一间房子，每个房子只能容纳一个人）。

【参考】https://blog.csdn.net/u012860063/article/details/41792973

【思路】建图，1个超级源点通往所有的m点，cost是0，cap是1；所有的m点通往所有的H点，cost是曼哈顿距离，cap是1；所有的H点通往超级汇点，cost是0，cap是1。跑最小费用最大流。

【最小费用最大流】1：最大流的dfs换成spfa(队列优化Bellman-Ford)，dis存cost。判断取边的时候加上条件：流量小于容量。

                                2：外面还是这么走。

【代码】还是不是很理解...

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
using namespace std;
const int MAXN=10000;
const int MAXM=100000;
const int INF=0x3f3f3f3f;
struct node1
{
    int to,next,cap,flow,cost;
    int x,y;
} edge[MAXM];
struct node2
{
    int x, y;
} HH[MAXN],MM[MAXN];
int head[MAXN],tol;
int pre[MAXN],dis[MAXN];
bool vis[MAXN];
int n,m;
int ch=0,cm=0;
char mp[MAXN][MAXN];

void init()
{
    ch=cm=tol=0;
    memset(head,-1,sizeof(head));
}

//左端点，右端点，容量，花费
void addedge(int u, int v, int cap, int cost)
{

    edge[tol].to=v,edge[tol].cap=cap;
    edge[tol].cost=cost,edge[tol].flow=0;
    edge[tol].next=head[u];
    head[u]=tol++;

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

bool spfa(int s, int t)
{
    queue<int>q;
    for(int i=0; i<MAXN; i++)
    {
        dis[i]=INF;
        vis[i]=0;
        pre[i]=-1;
    }
    dis[s]=0,vis[s]=1;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        for(int i=head[u]; i!=-1; 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]=1;
                    q.push(v);
                }
            }
        }
        q.pop();
        vis[u]=0;
    }
    if(pre[t]==-1)
        return 0;
    return 1;
}

//返回的是最大流， cost存的是最小费用
int minCostMaxflow(int s, int t, int &cost)
{
    int flow = 0;
    cost = 0;
    while(spfa(s,t))
    {
        int Min=INF;
        for(int i=pre[t]; i!=-1; i=pre[edge[i^1]. to])
        {
            if(Min>edge[i].cap-edge[i]. flow)
                Min=edge[i].cap-edge[i]. flow;
        }
        for(int i=pre[t]; i!=-1; i=pre[edge[i^1].to])
        {
            edge[i].flow +=Min;
            edge[i^1].flow-=Min;
            cost+=edge[i].cost*Min;
        }
        flow+=Min;
    }
    return flow;
}

int main()
{

    while(~scanf("%d%d",&n,&m))
    {
        if(n==0&&m==0)
            break;
        init();
        for(int i=0; i<n; i++)
        {
            scanf("%s",mp[i]);
            for(int j=0; j<m; j++)
            {
                if(mp[i][j]=='H')
                {
                    HH[ch].x=i;
                    HH[ch++].y=j;
                }
                else if(mp[i][j]=='m')
                {
                    MM[cm].x=i;
                    MM[cm++].y=j;
                }
            }
        }
        int beg=0;//超级起点
        int end=2*ch+1;//超级汇点
        for(int i=0; i<cm; i++)
        {
            addedge(beg,i+1,1,0);//超级起点,容量为1，花费为0
            for(int j=0; j<ch; j++)
            {
                int tt=abs(HH[i].x-MM[j].x)+abs(HH[i].y-MM[j].y);
                addedge(i+1,j+1+ch,1,tt);
            }
            addedge(i+1+ch,end,1,0);//超级汇点容量为1，花费为0
        }
        int ans=0;
        minCostMaxflow(beg,end,ans);
        printf("%d\n",ans);
    }
    return 0;
}