HDU 1533 Going Home （最小费用流）

题意：

　　一个矩阵n*m，其中有k个房子和k个人，k个人分别必须走到任意一个房子中（匹配），但是权值就是长度（非欧拉距离），求匹配完的权之和。

思路：

　　建图方法是，首先将k个人和k个房子分别抽出来到集合X和Y中，计算两两之间的距离，X到Y有一条边，费用为正，容量为1；Y到X也有一条边，费用为负，容量为0（其实两条边就是相反的）。添加一个源点0号到X集，添加一个汇点2*k+1号到Y集，这些费用都是0，容量都是1。

　　建完图就用正常的方法（EK+SPFA）来解决就行了。由于我想要让每次增广路只找到流为1的路径，所以我在2*k+1号点后面还加个点2*k+2，仅1条边，费用为0，容量为1。这样每次spfa至多也只有1流量通过到汇点了。（可不用此法，将每次spfa所得cost[end]*flow[end]就行了，因为可能流过的并不止1流量。）

　　

#include <bits/stdc++.h>
#define LL long long
#define pii pair<int,int>
#define INF 0x7f7f7f7f
using namespace std;
const int N=10000+20;
vector<int> vect[N];
int flow[N], cost[N], path[N], inq[N], edge_cnt;
struct node
{
    int from;
    int to;
    int val;
    int cap;
    int flo;
}edge[N*4];//边数要自己估计，不然就会RE


void add_node(int from,int to, int val, int cap, int flo)
{
    edge[edge_cnt].from=from;
    edge[edge_cnt].to=to;
    edge[edge_cnt].val=val;
    edge[edge_cnt].cap=cap;
    edge[edge_cnt].flo=flo;
    vect[from].push_back(edge_cnt++);
}

int spfa(int s,int e)
{
    deque<int> que;
    que.push_back(s);
    inq[s]=1;
    flow[s]=INF;
    cost[s]=0;

    while(!que.empty())
    {
        int x=que.front();
        que.pop_front();
        inq[x]=0;
        for(int i=0; i<vect[x].size(); i++)
        {
            node e=edge[vect[x][i]];
            if(e.cap>e.flo && cost[e.to]>cost[e.from] + e.val)
            {
                cost[e.to]=cost[x]+ e.val;//每次的流最多只是1。
                path[e.to]=vect[x][i];
                flow[e.to]=min(flow[e.from], e.cap-e.flo);
                if(!inq[e.to])
                {
                    inq[e.to]=1;
                    que.push_back(e.to);
                }
            }
        }
    }
    return cost[e];
}

int cal(int s,int e)
{
    int ans=0;
    while(true)
    {
        memset(flow, 0, sizeof(flow));
        memset(cost, 0x7f, sizeof(cost));
        memset(path, 0, sizeof(path));
        memset(inq, 0, sizeof(inq));

        if(spfa(s,e)==INF) return ans;
        ans+=cost[e]; 

        int ed=e-1;//连e点那条边不清空，可以保证每次至多1流。
        while(ed!=s)
        {
            int t=path[ed];
            edge[t].flo++;
            edge[t^1].flo--;
            ed=edge[t].from;
        }
    }
}

int main()
{
    freopen("input.txt", "r", stdin);
    int n, m;char ch;
    while(~scanf("%d%d",&n,&m),n+m)
    {
        for(int i=N-1; i>=0; i--)    vect[i].clear();
        memset(edge, 0, sizeof(edge));
        edge_cnt=0;
        int cnt=0;
        vector<pii> vect_h,vect_m;

        for(int i=1; i<=n; i++)
            for(int j=1; j<=m; j++)
            {
                cin>>ch;
                if(ch=='H')    vect_h.push_back(make_pair(i,j)),cnt++;
                if(ch=='m')    vect_m.push_back(make_pair(i,j));
            }


        for(int i=0; i<vect_m.size(); i++)
        {
            int a=vect_m[i].first, b=vect_m[i].second;
            for(int j=0; j<vect_h.size(); j++)
            {
                int c=vect_h[j].first, d=vect_h[j].second;
                int dis=abs(c-a)+abs(d-b);

                add_node(i+1,cnt+j+1,dis,1,0);
                add_node(cnt+j+1,i+1,-dis,0,0);
            }
        }

        for(int i=0; i<vect_m.size(); i++)            //添加源点
        {
            add_node(0,i+1,0,1,0);
            add_node(i+1,0,0,0,0);

        }
        for(int j=0; j<vect_h.size(); j++)          //添加汇点
        {
            add_node(cnt+j+1,cnt*2+1,0,1,0);
            add_node(cnt*2+1,cnt+j+1,0,0,0);
        }
        add_node(cnt*2+1,cnt*2+2, 0, 1, 0);     //这是为了每次只流过1。再汇点后面再加个汇点，容量是1，但是每次spfa后都不增加flow。
        add_node(cnt*2+2,cnt*2+1, 0, 0, 0);
        cout<<cal(0,cnt*2+2)<<endl;
    }
    return 0;
}