HDU 1533 Going Home 费用流

乌鸡哈拉王

于 2018-04-28 00:11:58 发布

阅读量145

点赞数

CC 4.0 BY-SA版权

分类专栏：费用流

本文链接：https://blog.youkuaiyun.com/qq_41231363/article/details/80114972

费用流专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一种在二维矩阵中寻找让所有人进入房子最小花费的方法，通过构建费用流图并运用SPFA算法来求解最小费用最大流问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：在二维矩阵中 .代表空地 H代表房子 M代表人求让所有人都进入房子的最小花费定义人每移动单位距离花费为1

思路：费用流模板题，建立超级源点，与人链接，容量为1费用为零，房子与超级汇点相连，容量为1费用为零，每个人和每一栋房子都要建边，容量为一，费用为人走到哪里的最小费用，最小费用最大流，一般这种题二分图也完全可以解决，先留坑。

点击打开链接

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<map>
using namespace std;
const int inf = 0x7fffffff;
const int maxn = 1e5+5;
int N,M;
char grid[105][105];
int dis[maxn];
int vis[maxn];
int pre[maxn];
struct Edge{
    int u,v;
    int cap,cost,next;
}edge[maxn*4];
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) {//return 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];
    }
    printf("%d\n",mincost);
}
int get_num(int i,int j) {
    return (i-1)*M+j;
}
bool is_out(int x,int y) {
    if(x<1 || x>N || y<1 || y>M) {
        return 1;
    }
    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)) {
        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);
        }
}
/****



 再留一坑


这是一个最小费用最大流问题

//最大费用最小流只要在添加边的时候换一下位置就好了
//求最大费用最大流只需要把费用换成相反数，用最小费用最大流求解即可


*/