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=+;
 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*];//边数要自己估计，不然就会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]=;
     flow[s]=INF;
     cost[s]=;

     while(!que.empty())
     {
         int x=que.front();
         que.pop_front();
         inq[x]=;
         for(int i=; 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]=;
                     que.push_back(e.to);
                 }
             }
         }
     }
     return cost[e];
 }

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

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

         int ed=e-;//连e点那条边不清空，可以保证每次至多1流。
         while(ed!=s)
         {
             int t=path[ed];
             edge[t].flo++;
             edge[t^].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-; i>=; i--)    vect[i].clear();
         memset(edge, , sizeof(edge));
         edge_cnt=;
         int cnt=;
         vector<pii> vect_h,vect_m;

         for(int i=; i<=n; i++)
             for(int j=; 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=; i<vect_m.size(); i++)
         {
             int a=vect_m[i].first, b=vect_m[i].second;
             for(int j=; 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+,cnt+j+,dis,,);
                 add_node(cnt+j+,i+,-dis,,);
             }
         }

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

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

AC代码