POJ 2195(费用流)

POJ 2195

题目大意

给你一个$N*M​$的地图，上面有房子”H”,人“m”,空地“.”。房子和人数相同，将人移动一格花费为1，问将将地图变为一个房子上恰好一人的最小花费。（在移动的过程中可以出现多个人在一个格子上面的情况）。

分析

这道题出现在费用流的专题里做法就很明显了。

人是多源点，房子是多汇点，建图如下：
超级源点到每个人的容量为1，花费为0；房子到超级汇点也是容量为1，花费为0.
其他点与点之间的容量无限大，花费为1.
这样就是求从超级源点到超级汇点的最小费用最大流了。
我的代码中对节点的编号以图中左上为1，右下为$N*M$

总结

打过n几次网络流和spfa的代码后，20多分钟就把这题代码完成了，debug两分钟就一次AC了，这道题也没太多细节需要处理的。还是多写题才能熟练啊

好久没有这么快AC一道题了，泪。。。

代码

#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<map>
#include<algorithm>
#include<set>
using namespace std;
const int INF=0x7fffffff;
const int MAXN=100005;
int N,M;
char grid[105][105];
int dis[MAXN];
int vis[MAXN];
int pre[MAXN];
struct Edge
{
      int u;
      int v;
      int cap;
      int cost;
      int next;
}edge[4*MAXN];
int edgecount;
int head[MAXN];
void Init()
{
      memset(head,-1,sizeof(head));
      edgecount=0;
}
void Add_edge(int u,int v,int cap,int cost)
{
      edge[edgecount].u=u;edge[edgecount].v=v;edge[edgecount].cap=cap;
      edge[edgecount].cost=cost;edge[edgecount].next=head[u];
      head[u]=edgecount++;
      edge[edgecount].u=v;edge[edgecount].v=u;edge[edgecount].cap=0;
      edge[edgecount].cost=-cost;edge[edgecount].next=head[v];
      head[v]=edgecount++;
}
bool spfa(int s,int t ,int n)//0表示没有增广路
{
      for(int i=0;i<=n;i++)
      {
            dis[i]=INF;
            vis[i]=0;
            pre[i]=-1;
      }
      dis[s]=0;
      vis[s]=1;
      queue<int> Q;
      Q.push(s);
      while(!Q.empty())
      {
            int u=Q.front();
            Q.pop();
            vis[u]=0;
            for(int k=head[u];k!=-1;k=edge[k].next)
            {
                  int v=edge[k].v;
                  int cost=edge[k].cost;
                  if(edge[k].cap && dis[v]> dis[u]+cost)
                  {
                        dis[v]=dis[u]+cost;
                        pre[v]=k;
                        if(!vis[v])
                        {
                              vis[v]=1;
                              Q.push(v);
                        }
                  }
            }
      }
      if(dis[t]==INF)return 0;
      return 1;
}
void MCMF(int s,int t,int n)
{
      int minflow;
      int mincost=0;
      while(spfa(s,t,n))
      {
            minflow=INF;
            for(int k=pre[t];k!=-1;k=pre[edge[k].u])
            {
                  minflow=min(minflow,edge[k].cap);
            }
            for(int k=pre[t];k!=-1;k=pre[edge[k].u])
            {
                  edge[k].cap-=minflow;
                  edge[k^1].cap+=minflow;
            }
            mincost+=dis[t];
      }
      cout<<mincost<<endl;
}
int get_num(int i,int j)//第i行第j列格子的编号
{
      return (i-1)*M+j;
}
bool is_out(int x,int y)
{
      if(x<1 || x>N || y<1 || y>M)return 1;
      else return 0;
}
void Build()//建图
{
      for(int i=1;i<=N;i++)
      {
            for(int j=1;j<=M;j++)
            {
                  if(!is_out(i-1,j))Add_edge(get_num(i,j),get_num(i-1,j),INF,1);
                  if(!is_out(i+1,j))Add_edge(get_num(i,j),get_num(i+1,j),INF,1);
                  if(!is_out(i,j-1))Add_edge(get_num(i,j),get_num(i,j-1),INF,1);
                  if(!is_out(i,j+1))Add_edge(get_num(i,j),get_num(i,j+1),INF,1);

                  if(grid[i][j]=='m')Add_edge(0,get_num(i,j),1,0);
                  else if(grid[i][j]=='H')Add_edge(get_num(i,j),N*M+1,1,0);
            }
      }
}
int main()
{
    while(scanf("%d%d",&N,&M)!=EOF)
    {
          if(N==0 && M==0)break;
          for(int i=1;i<=N;i++)
                 for(int j=1;j<=M;j++)
                 {
                     scanf("%c",&grid[i][j]);
                     while(grid[i][j]==' ' || grid[i][j]=='\n') scanf("%c",&grid[i][j]);
                 }
          Init();
          Build();
          MCMF(0,N*M+1,N*M+2);
    }
    return 0;
}