二分匹配之一

最新推荐文章于 2023-02-26 12:07:16 发布
最新推荐文章于 2023-02-26 12:07:16 发布
阅读量522 收藏
点赞数 1
分类专栏： 匹配 算法 文章标签： 算法 c++ 优化 2010 360
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinge008/article/details/8054258
版权

二分图的最大匹配：

匈牙利算法

DFS实现的匈牙利算法是每一次寻找一条增广路径

时间复杂度是O(n^3),复杂度偏高，通过改进优化在寻找增广路经的时候同时找多条不相交的增广路经

在寻找路径的每一个阶段，找到的增广路经都具有相同的长度，时间复杂度是O(n^0.5*m).

模板：DFS实现： 

//DFS实现增广，复杂度O(n^3);
const int maxn=550;
bool bmap[maxn][maxn];
bool bmask[maxn];
int cx[maxn],cy[maxn];
int nx,ny;

int findpath(int u)
{
	int i,j;
	for(int i=0;i<ny;i++)
	{
		if(bmap[u][i]&&!bmask[i])
		{
			bmask[i]=1;
			if(cy[i]==-1||findpath(cy[i]))
			{
				cy[i]=u;
				cx[u]=i;
				return 1;//每次增广只能找到一条增广路
			}
		}
	}

	return 0;
}

int maxMatch()
{
	int res(0);
	for(int i=0;i<maxn;i++)
	{
		cx[i]=-1;
		cy[i]=-1;
	}

	for(int i=0;i<nx;i++)
	{
		if(cx[i]==-1)
		{

			memset(bmask,0,sizeof(bmask));
			res+=findpath(i);

		}
	}
	return res;
}

模板2：

//时间复杂度是O(n^0.5*m).
const int maxn=510;//最大顶点数
const int inf=1<<28;
int bmap[maxn][maxn];
int cx[maxn];
int cy[maxn];
int nx,ny;
int dx[maxn];//dx[i]表示左集合i顶点的距离标号
int dy[maxn];//dy[i]表示左集合i顶点的距离标号
int dis;
bool bmask[maxn];
bool searchpath()
{
	queue<int> Q;
	dis=inf;
	for(int i=0;i<maxn;i++)//初始化为-1
	{
		dx[i]=-1;
		dy[i]=-1;
	}

	for(int i=0;i<nx;i++)
	{
		if(cx[i]==-1)
		{
			Q.push(i);dx[i]=0;
		}
	}
	while(!Q.empty())
	{
		int u=Q.front();Q.pop();
		if(dx[u]>dis)break;
		for(int v=0;v<ny;v++)
		{
			if(bmap[u][v]&&dy[v]==-1)
			{
				dy[v]=dx[u]+1;
				if(cy[v]==-1)dis=dy[v];
				else
				{
					dx[cy[v]]=dy[v]+1;
					Q.push(cy[v]);
				}
			}

		}
	}
	return dis!=inf;
}

int findpath(int u)
{

	for(int i=0;i<ny;i++)
	{
		if(bmap[u][i]&&!bmask[i]&&dy[i]==dx[u]+1)
		{
			bmask[i]=1;
			if(cy[i]!=-1&&dy[i]==dis)
			{
				continue;
			}
			if(cy[i]==-1||findpath(cy[i]))
			{
				cy[i]=u;
				cx[u]=i;
				return 1;
			}
		}
	}
	return 0;
}

int maxMatch()
{
	int res(0);
	for(int i=0;i<maxn;i++)
	{
		cx[i]=cy[i]=-1;
	}
	while(searchpath())
	{
		memset(bmask,0,sizeof(bmask));
		for(int i=0;i<nx;i++)
		{
			if(cx[i]==-1)
			{
				res+=findpath(i);
			}

		}

	}
	return res;
}


二分图的多重匹配：

即一对多的形式：

模板：

const int maxn=1001;
int bmap[maxn][maxn];
bool bmask[maxn];
int nx,ny;
int vcy[maxn];//vcy[i]表示右集合i顶点匹配到左集合的顶点数目。
int cy[maxn][maxn];//cy[i][j]表示与右边第i个匹配的第j个元素
int _left,_right,limit;//注意left，right是限制字，不能声明变量。

bool findpath(int u)
{
	for(int i=0;i<ny;i++)
	{
		if(bmap[u][i]&&!bmask[i])
		{
			bmask[i]=1;
			if(vcy[i]<limit)
			{
				cy[i][vcy[i]++]=u;
				return true;
			}
			for(int j=0;j<vcy[i];j++)
			{
				if(findpath(cy[i][j]))
				{
					cy[i][j]=u;
					return true;
				}
			}

		}

	}
return false;
}

bool MulMatch()
{
	memset(vcy,0,sizeof(vcy));
	for(int i=0;i<nx;i++)
	{
		memset(bmask,0,sizeof(bmask));
		if(!findpath(i))return false;
	}
	return true;
}


几个例题：

poj2289 典型的二分图多重匹配+二分求limit

//============================================================================
// Name        : 二分图的多重匹配.cpp
// Author      : xinge008
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
//此算法解决的是X边可以链接Y边的多个点，而Y边只能链接X边的一个点。即一对多
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include<stdlib.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <list>
using namespace std;
const int maxn=1001;

char ch[2010];
int bmap[maxn][maxn];
bool bmask[maxn];
int nx,ny;
int vcy[maxn];//vcy[i]表示右集合i顶点匹配到左集合的顶点数目。
int cy[maxn][maxn];//cy[i][j]表示与右边第i个匹配的第j个元素
int _left,_right,limit;//注意left，right是限制字，不能声明变量。

bool findpath(int u)
{
	for(int i=0;i<ny;i++)
	{
		if(bmap[u][i]&&!bmask[i])
		{
			bmask[i]=1;
			if(vcy[i]<limit)
			{
				cy[i][vcy[i]++]=u;
				return true;
			}
			for(int j=0;j<vcy[i];j++)
			{
				if(findpath(cy[i][j]))
				{
					cy[i][j]=u;
					return true;
				}
			}

		}

	}
return false;
}

bool MulMatch()
{
	memset(vcy,0,sizeof(vcy));
	for(int i=0;i<nx;i++)
	{
		memset(bmask,0,sizeof(bmask));
		if(!findpath(i))return false;
	}
	return true;
}
int main() {
	while(scanf("%d%d",&nx,&ny)!=EOF)
	{
		getchar();
		if(nx==0||ny==0)
			break;
		memset(bmap,0,sizeof(bmap));
		for(int i=0;i<nx;i++)
		{
			gets(ch);
			int len=strlen(ch);
//			printf("%d\n",len);
			for(int j=0;j<len;j++)
			{
				if(ch[j]>='0'&&ch[j]<='9')
				{
					int v=0;
					while(ch[j]>='0'&&ch[j]<='9')
					{
				       v=v*10+ch[j++]-'0';
					}
//					printf("%d\n",v);
					bmap[i][v]=1;
				}
			}
		}
		_left=0,_right=nx;
		while(_left<_right)
		{
			limit=(_left+_right)>>1;
			if(MulMatch())_right=limit;
			else
				_left=limit+1;
		}
		printf("%d\n",_left);
	}

	return 0;
}


hdu3605，典型多重匹配： 


//============================================================================
// Name        : hdu3065二分图的多重匹配.cpp
// Author      : xinge008
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include<stdlib.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <list>
using namespace std;
const int maxn=15;
int bmap[100010][maxn];
bool bmask[maxn];
int lit[maxn];
int nx,ny;
int vcy[maxn];//vcy[i]表示右集合i顶点匹配到左集合的顶点数目。
int cy[maxn][100010];//cy[i][j]表示与右边第i个匹配的第j个元素
int limit;//注意left，right是限制字，不能声明变量。

bool findpath(int u)
{
	for(int i=0;i<ny;i++)
	{
		if(bmap[u][i]&&!bmask[i])
		{
			bmask[i]=1;
//			printf("%d %d\n",vcy[i],lit[i]);
			if(vcy[i]>lit[i])
				return false;
			if(vcy[i]<lit[i])
			{
				cy[i][vcy[i]++]=u;
				return true;
			}
			for(int j=0;j<vcy[i];j++)
			{
				if(findpath(cy[i][j]))
				{
					cy[i][j]=u;
					return true;
				}
			}

		}

	}
return false;
}

bool MulMatch()
{
	memset(vcy,0,sizeof(vcy));
	for(int i=0;i<nx;i++)
	{
		memset(bmask,0,sizeof(bmask));
		if(!findpath(i))return false;
	}
	return true;
}

int main() {

	while(~scanf("%d%d",&nx,&ny))
	{
		memset(bmap,0,sizeof(bmap));
		for(int i=0;i<nx;i++)
		{
			for(int j=0;j<ny;j++)
			{
				int num;
				scanf("%d",&num);
				bmap[i][j]=num;
			}

		}
		for(int i=0;i<ny;i++)
			scanf("%d",&lit[i]);

		if(MulMatch())
			printf("YES\n");
		else
			printf("NO\n");

	}
	return 0;
}

hdu2063 裸的二分图的最大匹配： 

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
using namespace std;
//DFS实现增广，复杂度O(n^3);
const int maxn=550;
bool bmap[maxn][maxn];
bool bmask[maxn];
int cx[maxn],cy[maxn];
int nx,ny;

int findpath(int u)
{
    int i;
    for(i=0;i<ny;i++)
    {
        if(bmap[u][i]&&!bmask[i])
        {
            bmask[i]=1;
            if(cy[i]==-1||findpath(cy[i]))
            {
                cy[i]=u;
                cx[u]=i;
                return 1;//每次增广只能找到一条增广路
            }
        }
    }

    return 0;
}

int maxMatch()
{
    int res(0);
    for(int i=0;i<maxn;i++)
    {
        cx[i]=-1;
        cy[i]=-1;
    }

    for(int i=0;i<nx;i++)
    {
        if(cx[i]==-1)
        {

            memset(bmask,0,sizeof(bmask));
            res+=findpath(i);

        }
    }
    return res;
}
int main() {
    int T;
    while(~scanf("%d",&T))
    {
        if(T==0)
            break;
        scanf("%d%d",&nx,&ny);
        for(int i=0;i<maxn;i++)
            for(int j=0;j<maxn;j++)
                bmap[i][j]=false;
        int boy,girl;
        for(int i=1;i<=T;i++)
        {
            scanf("%d%d",&boy,&girl);
            boy--;girl--;
            bmap[boy][girl]=true;
        }
        printf("%d\n",maxMatch());
    }


    return 0;
}

二分图的重要性质：

二分图的最小顶点覆盖=二分图的最大匹配数

二分图的最大独立集=顶点数-二分图的最大匹配数 //当然了，有时候最大独立集=顶点数-二分图的最大匹配数/2.
//理解：最大独立集其实就是先求出二分图的最大匹配，然后用总的顶点数减去（最大匹配*2）+最大匹配，之所以加上最大匹配就是因为最大独立集要求是孤立点+各最大匹配中的一个点：即为最大匹配的个数。

二分图的最小路径覆盖=顶点数-二分图的最大匹配数

xinge008
关注
专栏目录
276.【华为OD机试】矩阵匹配（二分法—Java&Python&C++&JS实现）
一键难忘的博客
02-24 4866
【华为OD机试】矩阵匹配（二分法—Java&Python&C++&JS实现） 从一个N*M（N
opencv之SURF图像匹配
热门推荐
烟雨博客
04-19 2万+
1.概述前面介绍模板匹配的时候已经提到模板匹配时一种基于灰度的匹配方法，而基于特征的匹配方法有FAST、SIFT、SURF等，上面两篇文章已经介绍过使用Surf算法进行特征点检测以及使用暴力匹配(BruteForceMatcher)和最近邻匹配(FLANN)两种匹配方法。接下来将更深一步介绍利用Surf检测到的特征点以及匹配对进行图像匹配. 利用Surf算法进行图像匹配其一般流程为：检测物体特征点
【运筹优化】最大二分匹配问题及两种算法详解 + Python代码实现
知不足而奋进，望远山而前行
02-15 5048
在最大二分匹配（MBM）问题中，给定一个二分图 G，即分左右两部分，两个部分内部的点没有边连接，要求选出一些边，使得这些边没有公共顶点，且边的数量最大。上面的描述可能比较抽象，我们可以假想成男女配对。如下图所示，男女之间的连线代表他们互相之间有好感，假设你现在是一个媒婆，你的目标是在不违反男女双方自由意志的前提下，尽可能撮合出最多对的情侣。这就是最大二分匹配问题！匈牙利算法-看这篇绝对就够了！
【运筹优化】最大二分匹配问题及两种算法详解 + Java代码实现
最新发布
知不足而奋进，望远山而前行
02-26 4388
在最大二分匹配（MBM）问题中，给定一个二分图 G，即分左右两部分，两个部分内部的点没有边连接，要求选出一些边，使得这些边没有公共顶点，且边的数量最大。上面的描述可能比较抽象，我们可以假想成男女配对。如下图所示，男女之间的连线代表他们互相之间有好感，假设你现在是一个媒婆，你的目标是在不违反男女双方自由意志的前提下，尽可能撮合出最多对的情侣。这就是最大二分匹配问题！
二分之一波长传输线有啥用？
wusuowei1010的博客
04-12 6201
何平华老师分享《二分之一波长传输线有啥用？》，EDA365电子论坛，电子工程师硬件研发开发网站-电源电路原理图设计技术社区。
二分图匹配
Hanks软件库
09-02 1010
Bi-partite graph 二分图的定义：                  二分图是这样的一个图，它的顶点可以分为两个集合X和Y。所有的边关联的两个顶点中，恰好一个属于集合X，一个属于集合Y。 二分图的匹配：                 给定一个二分图G，M为G边集的一个子集，如果M满足当中的任意两条边都不依附于同一个顶点，则称M是一个匹配。 增广路：
二分匹配讲义
07-28
讲义中可能还会涵盖其他变种和优化技术，例如Kuhn-Munkres算法（KM算法），它解决了赋权二分匹配问题，即每条边都有一个非负权重，目标是找到使得所有匹配边权重之和最大的匹配。KM算法在解决赋权匹配问题时非常有效...
二分匹配+加权
dingdongsheng的专栏
08-27 2628
  前段时间为了省赛，我专门花了半个月来“专研”二部图，目前对二部图还是有一点点心得，所以就记录下来，希望对某些人有用。  开始我对二部图一窍不通，于是就在网上找资料，认真看完了各种资料，有一种感触：关于最大匹配问题，网上写的是挺好的，有深搜和广搜算法，很精辟；但是关于加权二部图，网上只有思想，没有具体实现代码，如果让一个一开始不知道二部图的算法的人去实现这个算法，还是有一定难度，所以决定写一
【小算法】二分图匹配之匈牙利算法详解(图例说明，代码亲测可用)
frank 的专栏
10-10 4396
在软件开发领域，任务指派和数据关联是一种常见业务需求，比如买卖订单的匹配，共享出行的人车匹配，及自动驾驶领域中目标追踪。 这都牵扯到一种技术，那就是数据关联，而匈牙利算法就是解决此类问题最典型的算法，也是今天本文的主题。 我们感性的认为目标之间的匹配好像一目了然的样子，但是计算机可不这样认为。计算机是理性的，如果要处理问题，一般我们会用数据结构来表示数据，栈、队列、树、图都很常用。 上面的形式，...
poj1751已知某些边建好的情况下求最小生成树中其他需要建的边
xinge008的专栏
08-10 2202
poj1751： 题意：已知某些边建好的情况下求最小生成树中其他需要建的边，输出其起点和终点 这道题目是spj，对输出的顺序没有要求 我用java写一直MLE，百思不得其解，然后又用C++写了一遍就AC了。 这次终于知道了在结构体内写比较函数要比在外面写cmp快的多 第二次在外面写的cmp直接卡时间超低空飘过，呵呵 不多说了，看代码吧 //==============
在一些边已建的情况下求最小生成树hdu1102
xinge008的专栏
08-08 1736
hdu1102 ：题意是在一个无向图中有一些边已经建好求最小生成树，思路很简单就是将已建的道路权值变为0即可。 我用的是kruskal求MST import java.util.Arrays; import java.util.Scanner; public class Main { static int max=10010; static int parent[]=new int[ma
poj3368--线段树统计区间的最大频率
xinge008的专栏
08-08 787
今天又做了点图论和线段树的题目，比较有感触的就是这道，一开始感觉有点像hotel那道题，感觉记录区间的左右值和左右的最大频率以及总的最大频率即可，最后比较取最大， 后来在初始化的时候RE了一次，然后就AC了，感觉线段树终于入门了 import java.io.*; public class Main { static StreamTokenizer in = new Strea
ural1521-线段树解约瑟夫问题
xinge008的专栏
08-07 754
使用sum[]数组来记录当前区段的个数 pushup来更新子节点与父节点的关系，实现很简单，但是要注意每次节点个数在减少，注意查询时要求的长度要模一下当前节点的个数 #include #include #include using namespace std; const int maxn=100010; int sum[maxn<<2]; void pushup(int idx
最短路模板BF和SPFA，poj3259测
xinge008的专栏
08-18 652
分别用BF和SPFA处理带负权图，自己写的模板，哎也WA 了N多次呀，测试题目是poj3259 Bellman-ford： #include #include #include #define MAX 1<<28 using namespace std; const int maxn=7010; int N,M,W; int dis[maxn]; int edgenum; struc
poj3026
xinge008的专栏
08-11 597
题意：就是S去感染A，然后A就变为了S在一起去感染其他的A，转变思路就是迷宫中全都是S，求把他们连起来的最小生成树 具体做法：先建图，然后BFS求出S之间的距离存入map[][]里在求解最小生成树就可以了。 2 6 5 ##### #A#A## # # A# #S ## ##### 7 7 ##### #AAA### # A# # S ### # # #AAA#
poj2481-树状数组的应用
xinge008的专栏
08-07 594
//***********************************************解决思想************************************ 对于这种有两个关键字并且具备单调性的问题，使用树状数组优化的一般方法是固定一个关键字（或者区间的端点），然后查询另一个关键字前n项和的性质确定当前对象的答案。 1.此题先按s由小到大排序，如果s相同根据t由大
hdu1394求最小逆序----树状数组解决
xinge008的专栏
08-07 548
首先用树状数组求出初始序列的逆序对数，再根据变化特征，因为所有的数都是在1 ~ n（由于用到树状数组每个输进来的数都加了1） 的，所以每次把末尾的数掉到序列前面时，减少的逆序对数为n-1-A[i] ，增加的逆序对数为A[i]-1 ，这样就可在所有的序列中找出含有逆序对最少的了！ import java.util.Arrays; import java.util.Scanner;
最小生成树专题
xinge008的专栏
08-09 540
今天系统的做了一下有关最小生成树的题目，都挺水的，水水更健康嘛 1.hdu1233，中文题目，不再赘述了，很裸的MST import java.util.Arrays; import java.util.Scanner; public class hdu1233 { static int roadnum; static int max=10010; static int parent[]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值