二分图最佳匹配 KM算法 Hdu2255奔小康赚大钱 + Poj 3565 Ants

最新推荐文章于 2022-03-10 13:32:35 发布
最新推荐文章于 2022-03-10 13:32:35 发布
阅读量1k 收藏
点赞数
分类专栏： 图论 文章标签： 二分图最佳匹配 KM算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whyorwhnt/article/details/9722211
版权

2014-10-4 更新 在最下面增加了基于邻接表的模板


理论：http://blog.sina.com.cn/s/blog_691ce2b701016reh.html

http://philoscience.iteye.com/blog/1754498

写模板的时候参考了上面两篇博文中的写法。

Hdu 2255 奔小康赚大钱

#include <cstdio>
#include <cstring>
#include <cmath>

const int N=310;   //每个集合的最大点数
const int INF=0x3f3f3f3f;

template<typename Type>
class KM_Matrix    //KM算法,邻接矩阵
{//求最大匹配边的总长及相应匹配。若求最小,加边时加负值
private:
	int nx,ny;  //nx,ny分别为x点集y点集的个数
	int link[N];   //link[a]=b代表 y集合中的a与x集合中的b匹配
	Type slack[N];    //优化
	bool visx[N],visy[N];
	Type lx[N],ly[N],w[N][N];    //lx,ly为顶标,w[][]记录各边权值

	bool DFS (int x)
	{
		visx[x]=true;
		for (int y=1;y<=ny;y++)
		{
			if (visy[y])
				continue;
			Type t = lx[x] + ly[y] - w[x][y];
			if (t==0)
//			if (fabs(t)<1e-10)     //注意精度
			{
				visy[y]=true;
				if (link[y] == -1 || DFS(link[y]))
				{
					link[y] = x;
					return true;
				}
			}
			else if (slack[y] > t)  //不在相等子图中slack 取最小的
				slack[y] = t;
		}
		return false;
	}
	
public:

	void Init (int _nx,int _ny)
	{
		nx=_nx;
		ny=_ny;
		memset (link,-1,sizeof(link));
		memset (ly,0,sizeof(ly));
		for (int i=0;i<=nx;i++)       //初始化,注意修改
			for (int j=0;j<=ny;j++)
				w[i][j]=INF;
	}

	void Add (int u,int v,Type val)  //加边
	{
		w[u][v]=val;
	}

	Type KM ()
	{
		int i,j;
		for (i=1;i<=nx;i++)      //lx初始化为与它关联边中最大的
			for (j=1,lx[i]=-INF;j<=ny;j++)
				if (w[i][j] > lx[i])
					lx[i] = w[i][j];
		for (int x=1;x<=nx;x++)
		{
			for (i=1;i<=ny;i++)
				slack[i] = INF;
			while (true)
			{
				memset (visx,false,sizeof(visx));
				memset (visy,false,sizeof(visy));
				if (DFS(x))     //若成功（找到了增广轨），则该点增广完成，进入下一个点的增广
					break;  //若失败（没有找到增广轨），则需要改变一些点的标号，使得图中可行边的数量增加。
               //方法为：将所有在增广轨中（就是在增广过程中遍历到）的X方点的标号全部减去一个常数d，
               //所有在增广轨中的Y方点的标号全部加上一个常数d
				Type d = INF;
				for (i=1;i<=ny;i++)
					if (visy[i]==false && d>slack[i])
						d = slack[i];
				for (i=1;i<=nx;i++) 
					if (visx[i])
						lx[i] -= d;
				for (i=1;i<=ny;i++)//修改顶标后，要把所有不在交错树中的Y顶点的slack值都减去d
					if (visy[i])
						ly[i] += d;
					else
						slack[i] -= d;
			}
		}
		Type res=0;
		for (i=1;i<=ny;i++)   //返回总长
			if (link[i] > -1)
				res += w[link[i]][i];
		return res;
	}

	void Output ()   //按照x集合的顺序输出匹配边的长度
	{
		for(int i=1;i<=nx;i++)  
			for(int j=1;j<=ny;j++)  
				if (link[j]==i)  
				{
					printf("%d\n",j);  
					break;  
				}  
	}

};

KM_Matrix<int> ob;

int main ()
{
	int n;
	while (~scanf ("%d",&n))
	{
		ob.Init(n,n);
		int i,j,t;
		for (i=1;i<=n;i++)
			for (j=1;j<=n;j++)
			{
				scanf("%d",&t);
				ob.Add(i,j,t);
			}
        printf ("%d\n",ob.KM());
	}
	return 0;
}

Poj 3565 Ants

思路参考：http://www.cnblogs.com/Missa/archive/2012/09/29/2708604.html

#include <cstdio>
#include <cstring>
#include <cmath>

const int N=105;   //每个集合的最大点数
const int INF=0x3f3f3f3f;

template<typename Type>
class KM_Matrix    //KM算法,邻接矩阵
{//求最大匹配边的总长及相应匹配。若求最小,加边时加负值
private:
	int nx,ny;  //nx,ny分别为x点集y点集的个数
	int link[N];   //link[a]=b代表 y集合中的a与x集合中的b匹配
	Type slack[N];    //优化
	bool visx[N],visy[N];
	Type lx[N],ly[N],w[N][N];    //lx,ly为顶标,w[][]记录各边权值

	bool DFS (int x)
	{
		visx[x]=true;
		for (int y=1;y<=ny;y++)
		{
			if (visy[y])
				continue;
			Type t = lx[x] + ly[y] - w[x][y];
			if (fabs(t)<1e-10)     //注意精度
			{
				visy[y]=true;
				if (link[y] == -1 || DFS(link[y]))
				{
					link[y] = x;
					return true;
				}
			}
			else if (slack[y] > t)  //不在相等子图中slack 取最小的
				slack[y] = t;
		}
		return false;
	}
	
public:

	void Init (int _nx,int _ny)
	{
		nx=_nx;
		ny=_ny;
		memset (link,-1,sizeof(link));
		memset (ly,0,sizeof(ly));
		for (int i=0;i<=nx;i++)       //初始化,注意修改
			for (int j=0;j<=ny;j++)
				w[i][j]=INF;
	}

	void Add (int u,int v,Type val)  //加边
	{
		w[u][v]=val;
	}

	Type KM ()
	{
		int i,j;
		for (i=1;i<=nx;i++)      //lx初始化为与它关联边中最大的
			for (j=1,lx[i]=-INF;j<=ny;j++)
				if (w[i][j] > lx[i])
					lx[i] = w[i][j];
		for (int x=1;x<=nx;x++)
		{
			for (i=1;i<=ny;i++)
				slack[i] = INF;
			while (true)
			{
				memset (visx,false,sizeof(visx));
				memset (visy,false,sizeof(visy));
				if (DFS(x))     //若成功（找到了增广轨），则该点增广完成，进入下一个点的增广
					break;  //若失败（没有找到增广轨），则需要改变一些点的标号，使得图中可行边的数量增加。
               //方法为：将所有在增广轨中（就是在增广过程中遍历到）的X方点的标号全部减去一个常数d，
               //所有在增广轨中的Y方点的标号全部加上一个常数d
				Type d = INF;
				for (i=1;i<=ny;i++)
					if (visy[i]==false && d>slack[i])
						d = slack[i];
				for (i=1;i<=nx;i++) 
					if (visx[i])
						lx[i] -= d;
				for (i=1;i<=ny;i++)//修改顶标后，要把所有不在交错树中的Y顶点的slack值都减去d
					if (visy[i])
						ly[i] += d;
					else
						slack[i] -= d;
			}
		}
		Type res=0;
/*		for (i=1;i<=ny;i++)   //返回总长
			if (link[i] > -1)
				res += w[link[i]][i];*/
		return res;
	}

	void Output ()   //按照x集合的顺序输出匹配边的长度
	{
		for(int i=1;i<=nx;i++)  
			for(int j=1;j<=ny;j++)  
				if (link[j]==i)  
				{
					printf("%d\n",j);  
					break;  
				}  
	}

};

KM_Matrix<double> ob;

struct Point
{
	double x,y;
	void Get ()
	{
		scanf("%lf%lf",&x,&y);
	}
	double Dis (const Point& b) const
	{
		return sqrt((x-b.x)*(x-b.x)+(y-b.y)*(y-b.y));
	}
}a[N],b[N];

int main ()
{
#ifdef ONLINE_JUDGE
#else
	freopen("read.txt","r",stdin);
#endif
	int n;
	while (~scanf("%d",&n))
	{
		ob.Init(n,n);
		int i;
		for (i=1;i<=n;i++)
			a[i].Get();
		for (i=1;i<=n;i++)
			b[i].Get();
		for (i=1;i<=n;i++)
			for (int j=1;j<=n;j++)
			{
				double len=a[i].Dis(b[j]);
				ob.Add(i,j,-len);
			}
		ob.KM();
		ob.Output();
		printf("\n");
	}
	return 0;
}

基于邻接表的模板，转自 http://paste.ubuntu.com/8489918/

/*
* this code is made by hdu_sxz
* Problem: 1223
* Verdict: Accepted
* Submission Date: 2014-10-03 20:49:11
* Time: 8MS
* Memory: 18316KB
*/
#pragma comment(linker,"/STACK:102400000,102400000")
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <string>
#include <math.h>
#include <queue>
#include <stack>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
const int maxn=505;
const int maxm=1000005;
const int INF=1000000000;
struct EdgeNode{int from,to,id,next;}edge[maxm];
int head[maxn],cnt,cost[maxn],vis[maxn];
void add(int x,int y,int id)
{
    edge[cnt].from=x;
    edge[cnt].to=y;
    edge[cnt].id=id;
    edge[cnt].next=head[x];
    head[x]=cnt++;
}
void init()
{
    cnt=0;
    memset(head,-1,sizeof(head));
}
int n,nx,ny,m;
int march[maxn],lx[maxn],ly[maxn],slack[maxn];
int visx[maxn],visy[maxn],w[maxn][maxn];
 
int dfs(int x)
{
    visx[x]=1;
    for(int y=1;y<=ny;y++)
    {
        if(visy[y])
            continue;
        int t=lx[x]+ly[y]-w[x][y];
        if(t==0)
        {
            visy[y]=1;
            if(march[y]==-1||dfs(march[y]))
            {
                march[y]=x;
                return 1;
            }
        }
        else if(slack[y]>t)
            slack[y]=t;
    }
    return 0;
}
 
int KM()
{
    int i,j;
    memset(march,-1,sizeof(march));
    memset(ly,0,sizeof(ly));
    for(i=1;i<=nx;i++)
        for(j=1,lx[i]=-INF;j<=ny;j++)
            if(w[i][j]>lx[i])
               lx[i]=w[i][j];
    for(int x=1;x<=nx;x++)
    {
        for(i=1;i<=ny;i++)slack[i]=INF;
        while(1)
        {
            memset(visx,0,sizeof(visx));
            memset(visy,0,sizeof(visy));
            if(dfs(x))break;
            int d=INF;
            for(i=1;i<=ny;i++)
                if(!visy[i]&&d>slack[i])
                    d=slack[i];
            for(i=1;i<=nx;i++)
                if(visx[i])
                    lx[i]-=d;
            for(i=1;i<=ny;i++)
                if(visy[i])
                    ly[i]+=d;
                else
                    slack[i]-=d;
        }
    }
    int res=0;
    for(i=1;i<=ny;i++)
        if(march[i]>-1)
            res+=w[march[i]][i];
    return res;
}
 
bool find(int x,int y,int id)
{
    if(x==y)return 1;
    vis[x]=1;
    for(int i=head[x];i!=-1;i=edge[i].next)
    {
        int v=edge[i].to;
        if(vis[v])continue;
        if(find(v,y,id)){
            if(cost[edge[i].id]>cost[id])
               w[edge[i].id][id]=cost[edge[i].id]-cost[id];
            return 1;
        }
    }
    return 0;
}
 
int main()
{
    int x,y,z,id,i;
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(i=1;i<n;i++){
            scanf("%d%d%d",&x,&y,&cost[i]);
            add(x,y,i);
            add(y,x,i);
        }
        memset(w,0,sizeof(w));
        for(i=n;i<=m;i++){
            scanf("%d%d%d",&x,&y,&cost[i]);
            memset(vis,0,sizeof(vis));
            find(x,y,i);
        }
        nx=n-1; ny=m;
        KM();
        for(i=1;i<n;i++)
        printf("%d\n",cost[i]-lx[i]);
        for(i=n;i<=m;i++)
        printf("%d\n",cost[i]+ly[i]);
    }
    return 0;
}


时雨晴天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二分图匹配实例代码及整理
12-26
二分图匹配实例代码及整理 1、匈牙利算法 HDU 1150 #include #include #include using namespace std; int m,n,k; int vis[105]; int mpt[105][105]; int use[105]; int hungary(int x) { for(int i=1;i<m;i++)...
KM算法入门
weixin_43984457的博客
04-01 4294
KM算法入门 在学习KM算法前，我们先感受一下匈牙利算法（由匈牙利数学家Edmonds提出）。 匈牙利算法 解决何种问题的呢 匈牙利算法是解决二分图的最大匹配度问题。 何为二分图 如果用染色法来判断的话，那么整幅图最后只会有两种颜色的元素；所谓二分图，就是可以划分为两个集合，且同一集合中的元素是互不相连的，不同集合中的元素是可以相连的。 下面我们通过一个简单的例子来说明： 现在...
网络流 增广路 入门很好的文章
weixin_30706691的博客
09-16 955
Edmonds_Karp 算法 (转) 找了好久终于在这个牛这里找到为什么反向边要加回流量的原因了， 因为是初学教程，所以我会尽量避免繁杂的数学公式和证明。也尽量给出了较为完整的代码。 本文的目标群体是网络流的初学者，尤其是看了各种NB的教程也没看懂怎么求最大流的小盆友们。本文的目的是，解释基本的网络流模型，最基础的最大流求法，即bfs找增广路法，也就是EK法，全名是Edmond...
【转载】KM算法原理+证明
Huah_2018的博客
03-22 875
KM算法原理+证明 原创 ...
km算法入门
weixin_30745553的博客
11-08 1146
本文知识均由笔者自学，文章有错误之处请不吝指出。 笔者刷数模题的时候有一道题考到了“二分图最大权分配”，需要用到KM算法，但是书上对KM算法的介绍又臭又长，更何况有些同学“匈牙利算法”也没学过（由匈牙利数学家Edmonds提出），自然难以理解所谓的KM算法。本文旨在用通俗易懂的语言，向读者介绍匈牙利算法和KM算法。 一、匈牙利算法 匈牙利算法用于解决什么问题？ 匈牙利算法用于解...
KM算法原理+证明
qq_25379821的博客
11-05 1万+
介绍 以匈牙利算法为基础，改善后用于求解带权二分图的求最佳匹配问题 百度百科中有KM算法的介绍，当中有证明过程：百度KM算法 最大权匹配 带权二分图的边权重和最大的匹配，如下图所示，最大和为102 最佳匹配 带权二分图的边权重和最大的完备匹配，如下图所示 显然，最佳匹配和最大权匹配并不一致，但如果把剩下的边补上，并且设置权重为零，那么二者可以统一起来 KM算法 下面讲...
HDU刷题地图+精选详细笔记
10-26
本人准备2020年保研机试时刷的题目（虽然最后机试取消了，...来自某中流985，在HDU和vjudge平台上大概刷了400道。本文件地图（excel表格）包含了绝大部分我刷过的题目，笔记中具有思路、代码、总结和心得。 大佬勿入！
hdu 1695 GCD（欧拉函数+容斥原理）.docx
10-29
hdu 1695 GCD（欧拉函数+容斥原理）.docx
二分图题解1
08-03
B HDU 5093 Battle ships题意给出一个n行m列的图，*代表海域，o代表冰水，#代表冰山，要想在海域中放置船，保证船与船之间不能相互看到，之间
【HDU 3993】田忌赛马 题解+勘误
12-14
【HDU 3993】田忌赛马 题解+勘误 题解这里就略写一下了，主要是勘误。 这道题是2011年之前的多校训练题，2020年的今天，我们一个集训队全部挂在上面了。最后在HDU看到了9年前的讨论区，才知道这题有如下问题： speed...
KM算法学习总结
weixin_42809924的博客
12-19 1896
匈牙利算法(Hungarian Algorithm)与KM算法(Kuhn-Munkres Algorithm)都用于求解任务分配问题。 目录基本概念与匈牙利算法KM算法算法过程补充总结 基本概念与匈牙利算法 KM算法中用到了匈牙利算法，可以先阅读下面这篇文章。 匈牙利算法 KM算法 算法过程 1、初始化顶标 为二分图中每个点赋值，称为这个点的顶标。顶标在求解过程中会变化。初始化顶标时，左侧的每个点的顶标都是和它相连的权重最大边的权重，像下面这个例子中，x1x_{1}x1​、x2x_{2}x2​、x3x_{3
二分图的最佳完美匹配——KM算法
热门推荐
六天
08-17 4万+
二分图的最佳完美匹配如果二分图的每条边都有一个权（可以是负数），要求一种完备匹配方案，使得所有匹配边的权和最大，记做最佳完美匹配。（特殊的，当所有边的权为1时，就是最大完备匹配问题） 我们使用KM算法解决该问题。KM（Kuhn and Munkres）算法，是对匈牙利算法的一种贪心扩展，如果对匈牙利算法还不够明白，建议先重新回顾一下匈牙利算法。KM是对匈牙利算法的一种贪心扩展，这种贪心不是对边的权
km算法详解
张小象
09-15 3414
先说KM算法求二分图的最佳匹配思想，再详讲KM的实现。 【KM算法求二分图的最佳匹配思想】 对于具有二部划分( V1, V2 )的加权完全二分图，其中 V1= { x1, x2, x3, ... , xn }， V2= { y1, y2, y3, ... , yn }，边 具有权值 Wi,j 。该带权二分图中一个总权值最大的完美匹配，称之为最佳匹配。   记 L(x) 表示
【总结】KM算法
cqbzlydd的博客
05-02 1186
upd on 2023/10/26 ：修改了代码和一些不知所云的内容。
匈牙利算法及KM算法详解
zack_liu的博客
03-10 3137
文章目录1 二分图相关概念2 匈牙利算法求解无权二分图最大匹配2.1 相关概念2.2 算法原理2.3 匈牙利算法代码3 KM算法求解加权二分图最优匹配3.1 相关概念3.3 KM代码示例 1 二分图相关概念 二分图定义： 二分图又称双分图、二部图、偶图，指顶点可以分成两个不相交的集U和V(U和V皆为独立集(Independent Sets))，使得在同一个集内的顶点不相邻(没有共同边)的图。 我们定义匹配点、匹配边、未匹配点、非匹配边。如图3中,1、4、5、7为匹配点，其他顶点为未匹配点；1-5、4-7为
KM算法详解
ylsoi的博客
05-31 5290
KM算法： KM是用来求带权二分图的最优匹配的一种算法。 原理： 我们要求一个二分图的最优匹配，直接求的话肯定是不太好求的，因为每一条边都带有自己的边权，而我们是要求得一个匹配，使得所有的边权加起来值最大。 然后智商超级高的KM算法发明者将这个问题转化为了求一个带权二分图的完备匹配的问题。 概念： 顶标：每一个点有一个顶标，左边的点的顶标为lx[i]lx[i]lx[i],右边的点的顶标...
KM算法
不可不戒
09-08 990
引用1： KM算法是通过给每个顶点一个标号（叫做顶标）来把求最大权匹配的问题转化为求完备匹配的问题的。设顶点Xi的顶标为A[i]，顶点Yi的顶标为B [i]，顶点Xi与Yj之间的边权为w[i,j]。在算法执行过程中的任一时刻，对于任一条边(i,j)，A[i]+B[j]>=w[i,j]始终 成立。KM算法的正确性基于以下定理：  　　若由二分图中所有满足A[i]+B[j]=w[i,j]的边(i,
KM算法总结
飞雪---晨
08-09 796
【KM算法及其具体过程】 （1）可行点标：每个点有一个标号，记lx[i]为X方点i的标号，ly[j]为Y方点j的标号。如果对于图中的任意边(i, j, W)都有lx[i]+ly[j]>=W，则这一组点标是可行的。特别地，对于lx[i]+ly[j]=W的边(i, j, W)，称为可行边；   （2）KM 算法的核心思想就是通过修改某些点的标号（但要满足点标始终是可行的），不断增加图中的可行边总
KM算法--学习笔记
yangss123的博客
03-21 1万+
博客推荐：KM算法详解 我对KM算法的理解 二分图的最佳完美匹配--KM算法 1、KM算法是用于寻找带权二分图最佳匹配的算法。对KM算法的描述，基本上可以概括成以下几个步骤： （1） 初始化可行标杆 （2） 用匈牙利算法寻找完备匹配 （3） 若未找到完备匹配则修改可行标杆 （4） 重复（2）（3）直到找到相等子图的完备匹配 2、二分图详解： （1）二...
HDU2222+WA
最新发布
03-08
HDU2222+WA 是指杭电OJ（杭州电子科技大学在线评测系统）上的一道题目，题目编号为2222，题目名称为"WA"。这道题目是一个字符串匹配的问题，要求判断一个字符串中是否包含另一个字符串中的所有字符（不考虑顺序）。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值