POJ 2195--Going Home

最新推荐文章于 2025-06-01 16:07:59 发布
原创 最新推荐文章于 2025-06-01 16:07:59 发布 · 394 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#poj #算法 #算法导论 #图论

本文介绍了三种不同的最小费用最大流算法实现：Kuhn-Munkres算法（KM）、最短路径优先算法（SPFA）及贝尔曼-福特算法（Bellman-Ford）。通过实例讲解了如何使用这些算法来解决具体的匹配问题。

最小费用最大流问题，同POJ2516，此题较之要简单些，容量只为1， 花费为人到屋子的哈密顿距离，且二分匹配中X，Y规模一致。


KM:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
#define maxN 105
#define INF 0X7F7F

short cost[maxN][maxN];
short lx[maxN],ly[maxN];
char visx[maxN],visy[maxN];
short match[maxN];
short slack[maxN];
short minCost;
short N;

bool DFS(short x)
{
    short i,diff;
    visx[x] = true;
    for(i = 1;i <= N;i++)
    {
        if(!visy[i])
        {
            diff = lx[x]+ly[i]-cost[x][i];
            if(diff == 0)
            {
                visy[i] = true;
                if(match[i] == 0||DFS(match[i]))
                {
                    match[i] = x;
                    return 1;
                }
            }
            else if(slack[i] > diff)
            {
                slack[i] = diff;
            }
        }
    }
    return 0;
}

int KM()
{
    short i,j;
    short d;
    memset(match,0,sizeof(match));
    memset(lx,0X80,sizeof(lx));
    memset(ly,0,sizeof(ly));
    for(i = 1;i <= N;i++)
    {
        for(j = 1;j <= N;j++)
        {
            if(lx[i] < cost[i][j])
            {
                lx[i] = cost[i][j];
            }
        }
    }
    for(i = 1;i <= N;i++)
    {
        memset(slack,0X7F,sizeof(slack));
        while(1)
        {
            memset(visx,0,sizeof(visx));
            memset(visy,0,sizeof(visy));
            if(DFS(i))          //找到增广路径就跳出循环，没找到改标号
            {
                break;
            }
            d = INF;
            for(j = 1;j <= N;j++)
            {
                if(!visy[j]&&slack[j] < d)
                {
                    d = slack[j];
                }
            }
            for(j = 1;j <= N;j++)
            {
                if(visx[j])
                {
                    lx[j] -= d;
                }
                if(visy[j])
                {
                    ly[j] += d;
                }
                else
                {
                    slack[j] -= d;
                }
            }
        }
    }
    minCost = 0;
    for(i = 1;i <= N;i++)
    {
        minCost += cost[match[i]][i];
    }
    printf("%d\n",-1*minCost);
    return 0;
}

int main()
{
    int i,j,M;
    int mNum,houseNum;
    char c;
    short mXY[maxN][2],hXY[maxN][2];
    while(~scanf("%d%d",&N,&M)&&N)
    {
        minCost = 0;
        memset(cost,0,sizeof(cost));
        mNum = houseNum = 1;
        getchar();
        for(i = 1;i <= N;i++)
        {
            for(j = 1;j <= M;j++)
            {
                c = getchar();
                if(c == 'm')
                {
                    mXY[mNum][0] = i;
                    mXY[mNum++][1] = j;
                }
                else if(c == 'H')
                {
                    hXY[houseNum][0] = i;
                    hXY[houseNum++][1] = j;
                }
            }
            getchar();
        }
        N = --houseNum;
        for(i = 1;i <= houseNum;i++)
        {
            for(j = 1;j <= houseNum;j++)
            {
                cost[i][j] = -1*(abs(mXY[i][0]-hXY[j][0])+abs(mXY[i][1]-hXY[j][1]));
            }
        }
        KM();
    }
    return 0;
}


SPFA:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
#define maxN 105
#define INF 0X7F7F

int dest;
short capacity[(maxN)<<1][(maxN)<<1];
short cost[(maxN)<<1][(maxN)<<1];
short minCost;

short spfa(short* fa)
{
    short i,now;
    short minDis[(maxN)<<1];
    char vis[(maxN)<<1];
    memset(vis,0,sizeof(vis));
    memset(minDis,127,sizeof(minDis));
    minDis[0] = 0;
    queue<short> q;
    q.push(0);
    vis[0] = true;
    while(!q.empty())
    {
        now = q.front();
        q.pop();
        vis[now] = false;
        for(i = 1;i <= dest;i++)
        {
            if(capacity[now][i] > 0&&minDis[now]+cost[now][i] < minDis[i])
            {
                fa[i] = now;
                minDis[i] = minDis[now]+cost[now][i];
                if(!vis[i])
                {
                    q.push(i);
                    vis[i] = true;
                }
            }
        }
    }
    return minDis[dest];
}

int minCost_maxFlow()
{
    short x;
    short fa[(maxN)<<1];
    while(spfa(fa) != INF)
    {
        x = dest;
        while(x)
        {
            minCost += cost[fa[x]][x];
            capacity[fa[x]][x] = 0;
            capacity[x][fa[x]] = 1;
            x = fa[x];
        }
    }
    printf("%d\n",minCost);
    return 0;
}

int main()
{
    int i,j,N,M;
    int mNum,houseNum;
    char c;
    short mXY[maxN][2],hXY[maxN][2];
    while(~scanf("%d%d",&N,&M)&&N)
    {
        minCost = 0;
        memset(capacity,0,sizeof(capacity));
        memset(cost,0,sizeof(cost));
        mNum = houseNum = 1;
        getchar();
        for(i = 1;i <= N;i++)
        {
            for(j = 1;j <= M;j++)
            {
                c = getchar();
                if(c == 'm')
                {
                    mXY[mNum][0] = i;
                    mXY[mNum++][1] = j;
                }
                else if(c == 'H')
                {
                    hXY[houseNum][0] = i;
                    hXY[houseNum++][1] = j;
                }
            }
            getchar();
        }
        houseNum--;
        dest = (houseNum<<1)|1;
        for(i = 1;i <= houseNum;i++)
        {
            capacity[0][i] = capacity[houseNum+i][dest] = 1;
            for(j = 1;j <= houseNum;j++)
            {
                capacity[i][houseNum+j] = 1;
                cost[i][houseNum+j] = abs(mXY[i][0]-hXY[j][0])+abs(mXY[i][1]-hXY[j][1]);
                cost[houseNum+j][i] = -1*cost[i][houseNum+j];
            }
        }
        minCost_maxFlow();
    }
    return 0;
}

Bellman_Ford: 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
#define maxN 105
#define maxE 20200
#define INF 0X7F7F

int dest;
short capacity[(maxN)<<1][(maxN)<<1];
short cost[(maxN)<<1][(maxN)<<1];
short edges[maxE][2];
short edgeNum;
short minCost;

int generateEdge()
{
    edgeNum = 0;
    short i,j;
    for(i = 0;i < dest;i++)
    {
        for(j = 1;j <= dest;j++)
        {
            if(capacity[i][j] > 0)
            {
                edges[edgeNum][0] = i;
                edges[edgeNum++][1] = j;
            }
        }
    }
    return 1;
}
short bellman_ford(short* fa)
{
    short i,j;
    short x,y;
    short minDis[(maxN)<<1];
    char IsRelax;
    memset(minDis,0x7F,sizeof(minDis));
    minDis[0] = 0;
    for(i = 0;i < dest;i++)
    {
        IsRelax = false;
        for(j = 0;j < edgeNum;j++)
        {
            x = edges[j][0];
            y = edges[j][1];
            if(minDis[y] > minDis[x]+cost[x][y])
            {
                fa[y] = x;
                minDis[y] = minDis[x]+cost[x][y];
                IsRelax = true;
            }
        }
        if(!IsRelax)
            break;
    }
    return minDis[dest];
}

int minCost_maxFlow()
{
    short x;
    short fa[(maxN)<<1];
    while(generateEdge()&&bellman_ford(fa) != INF)
    {
        x = dest;
        while(x)
        {
            minCost += cost[fa[x]][x];
            capacity[fa[x]][x] = 0;
            capacity[x][fa[x]] = 1;
            x = fa[x];
        }
    }
    printf("%d\n",minCost);
    return 0;
}

int main()
{
    int i,j,N,M;
    int mNum,houseNum;
    char c;
    short mXY[maxN][2],hXY[maxN][2];
    while(~scanf("%d%d",&N,&M)&&N)
    {
        minCost = 0;
        memset(capacity,0,sizeof(capacity));
        memset(cost,0,sizeof(cost));
        mNum = houseNum = 1;
        getchar();
        for(i = 1;i <= N;i++)
        {
            for(j = 1;j <= M;j++)
            {
                c = getchar();
                if(c == 'm')
                {
                    mXY[mNum][0] = i;
                    mXY[mNum++][1] = j;
                }
                else if(c == 'H')
                {
                    hXY[houseNum][0] = i;
                    hXY[houseNum++][1] = j;
                }
            }
            getchar();
        }
        houseNum--;
        dest = (houseNum<<1)|1;
        for(i = 1;i <= houseNum;i++)
        {
            capacity[0][i] = capacity[houseNum+i][dest] = 1;
            for(j = 1;j <= houseNum;j++)
            {
                capacity[i][houseNum+j] = 1;
                cost[i][houseNum+j] = abs(mXY[i][0]-hXY[j][0])+abs(mXY[i][1]-hXY[j][1]);
                cost[houseNum+j][i] = -1*cost[i][houseNum+j];
            }
        }
        minCost_maxFlow();
    }
    return 0;
}


POJ 2195 Going Home (最佳完美匹配, 最小费用最大流)
yunyouxi0's blog
11-20 1345
题目类型  最优比率生成树 题目意思 给出最多 1000 个点与这些点之间的边的长度与花费　找一棵生成树　使　 Sum(边的花费) / Sum(边的长度) 的值最小　输出这个值 解题方法 01分数规划 -> 对于0-1分数规划的Dinkelbach算法的分析 这道题求的是最小值 设边的花费为行向量 [c1, c2, ... ,
二分图匹配(最小费用完美匹配) poj 2195 GoingHome
likaihua1989的专栏
09-05 1349
Going HomeTime Limit: 1000MS Memory Limit: 65536KTotal Submissions: 9224 Accepted: 4752DescriptionOn a grid map there are n little men and n houses. In each unit time, every little man can move one unit step, either horizontally, or vertically, to an adjac
POJ2195--Going Home
SCUT_Pein
05-23 718
Description On a grid map there are n little men and n houses. In each unit time, every little man can move one unit step, either horizontally, or vertically, to an adjacent point. For each little ma
掌握费用流算法：POJ2195-Going Home问题解答与实战
最新发布
weixin_42607969的博客
06-01 965
在讨论最小费用最大流问题之前，我们必须先了解流网络的基本概念。流网络是一个有向图，其中每条边都有一个非负容量上限，表示可以流过这条边的最大流量。流网络通常表示为G=(V, E)，其中V是顶点的集合，E是边的集合，每条边(u,v)∈E都有一个容量限制c(u,v)≥0。在流网络中，通常有一对特殊的顶点，即源点s（source）和汇点t（sink）。源点是流量的起点，而汇点是流量的终点。流在网络中的流动必须满足两个基本条件：流量守恒和容量限制。
POJ2195-Going Home
weixin_30835923的博客
11-07 90
传送门 题目大意：给定一些人和一些房子，人和房子一样多，求配对。配对代价就是人和房子的距离 思路：这是一个二分图的模型，带权二分图用KM算法即可 1 #include<cstdio> 2 #include<cstdlib> 3 #include<algorithm> 4 #include<cstring> 5 #...
poj2195--Going Home(最小费用最大流)
随风的专栏
08-20 1020
Going Home Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 17975   Accepted: 9155 Description On a grid map there are n little men and n houses. In each unit t
poj-2195-Going Home最小费用最大流
青竹梦
06-25 1113
重新切一遍最小费用最大流~~~ 这到题目的数据范围有问题，尽量开大就好了~~ #include #include #include #include #include using namespace std; #define INF 999999 struct list { int u; int v; int next; }node[1000001]; int num; int
POJ-2195-Going Home(最小费用最大流)
weixin_30693683的博客
08-05 144
链接: https://vjudge.net/problem/POJ-2195 题意: 黄弘毅突然兴致大发准备免费送房子，m表示人，H表示房子，每个房子只能进一个人，房子数等于人数。黄弘毅为了方便起见决定要让所有人到自己的房子的距离和最小，请问这个距离和是多少？ 思路: 最小费用最大流. 每个人连到每个房子. 代码: #include <iostream> #include ...
poj 2195 D - Going Home
Mr.HanChen
09-13 361
On a grid map there are n little men and n houses. In each unit time, every little man can move one unit step, either horizontally, or vertically, to an adjacent point. For each little man, you need t...
POJ-2195-Going Home
菜鸟的程序人生
08-13 812
POJ-2195-Going Home http://poj.org/problem?id=2195 最小费用最大流，假想一个源点，一个汇点 代码模仿网上的写的，还要再好好研究哇 #include #include #include #define maxn 300 #define INF 0x7fffffff int min(int x,int y) { return x<y?x:y;
poj2195 - Going Home
贰圣
09-04 1664
想看更多的解题报告:http://blog.youkuaiyun.com/wangjian8006/article/details/7870410                                   转载请注明出处：http://blog.youkuaiyun.com/wangjian8006 题目大意：图中有n个man和n个home，并且一个人只能住在一个房子里面，房子和人的个数是相等的。并且每个人
最小费用最大流算法解决POJ2195-Going Home问题
#### POJ2195-Going Home - POJ (Peking University Online Judge) 是北京大学的在线评测系统，它是一个提供算法和编程练习的平台，同时支持不同算法问题的在线提交与评测。 - 2195是POJ系统中一个特定问题的编号，...
POJ2195-Going Home【费用流】
08-30
【标题】"POJ2195-Going Home" 是一道来自北京大学在线判题系统POJ的编程题目，主要考察的是运用费用流算法解决实际问题的能力。这道题的中文名称是“回家”，通过题目我们可以推测它可能涉及到路径规划或者资源分配...
POJ 3264--Balanced Lineup（RMQ问题）
dingzuoer的专栏
11-04 2507
题意：给定一数组，
POJ 1419--Graph Coloring（最大团求二着色问题）
dingzuoer的专栏
07-26 1432
无向图中二着色，利用DFS以及简单的DP对最大团算法进行优化。。。
POJ 3621--Sightseeing Cows(0-1规划求最大密度)
dingzuoer的专栏
01-29 732
利用0-1规划中的二分以及Dinkelbach算法求解有向图中的最大密度问题，并且对此问题中的Dinkelbach算法的期望搜索迭代次数作了简要分析。
POJ 1836--Alignment(LIS,LCS)
dingzuoer的专栏
07-30 694
题意：要求一给定序列的子序列，使其中的元素至少能
POJ 2976--Dropping tests(Dinkelbach求0/1规划)
dingzuoer的专栏
01-27 677
利用二分法和Dinkelbach算法求0/1规划问题。
POJ 1459--Power Network(三种方法求最大流)
dingzuoer的专栏
07-26 648
不管用ford——fulkerson方法还是推送重贴标签，首先都不用管自环，显然一个最大流   是不会包括自环的，自环只会减少流量。然后反向边也不需要如算法导论中加入另外的   点进行处理。   ******为了减少内存，直接用容量的减少代表流量的增加，正向边容量减少多少，正向流   量就增加多少，同时增加相应的反向容量，意思就是说反向的能允许的流量增加，而如果   接下来的操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值