求二部图的最小覆盖顶点

最新推荐文章于 2022-07-21 19:42:41 发布
最新推荐文章于 2022-07-21 19:42:41 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： C++算法系列 文章标签： iterator graph exchange 算法 delete c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangzhicheng1983/article/details/8103650
版权

1. 最小覆盖顶点

http://www.matrix67.com/blog/archives/116

2. 代码

/*
This is a free Program, You can modify or redistribute it under the terms of GNU
*Description:输入一个图,能够识别该图是不是二部图,如果是,自动将此二部图的顶点划分为
红点集合蓝点集,并确保红点集中元素个数小于等于蓝点集中元素的个数,
此系统核心功能还包括找出二部图最大匹配,完备匹配,最优匹配,最小覆盖顶点集(Konig)
*Language: C++
*Development Environment: VC6.0
*Author: Wangzhicheng
*E-mail: 2363702560@qq.com
*Date: 2012/10/23
*/

#include "graph.h"
#include "graph.cpp"
#include <string>
#include <vector>
#include <map>
#include <stack>
#include <set>
using namespace std;

enum Color{red,blue,black};  //定义颜色

/*
二部图类,是图的公有派生类
*/
template<class ElemType>
class Bipartite_Graph:public Graph<ElemType> {
	private:
		bool flag;				//表示此图是不是二分图
		bool isolateflag;       //表示此图是否有孤立点
		bool perfectMatch;      //表示此图有没有完备匹配
		vector<int>Red;			//红点集向量
		vector<int>Blue;		//蓝点集向量
		vector<int>unMatchBlue; //蓝点集中未匹配的点  
		vector<int>isolate;     //孤立点集合 
		Color *vertexcolor;		//颜色向量,向量中每个元素为相应顶点的颜色
		map<int,int>match;		//<蓝点,与蓝点匹配的红点>
		set<int>MarkedRed;   //打上标记的红点集
		set<int>MarkedBlue;  //打上标记的蓝点集
		set<int>minCoveredPoints; //最小覆盖顶点集
		int count;				//此二部图的匹配数
        /*********************************************************/
		stack<pair<int,int> >Stack;  //保存着匹配
		stack<pair<int,int> >tempStack;  //临时保存Stack内容
		vector<pair<stack<pair<int,int> >,int> >MatchArray;  //存放所有匹配和其对应的权值和的向量

	public:
		/*
		二部图的构造方法,在构造方法中,完成识别二部图的功能,划分出红点集合蓝点集的功能
		*/
		Bipartite_Graph(bool IsDirect,bool IsWeight):Graph<ElemType>(IsDirect,IsWeight) {
			vertexcolor=new Color[graph.vertexnum];
			isolateflag=false;
			flag=true;
			perfectMatch=true;
			count=0;
			int i,j;
			for(i=0;i<graph.vertexnum;i++) vertexcolor[i]=black; //将所有顶点都打上黑色
			for(i=0;i<graph.vertexnum;i++) visited[i]=false;  //将所有顶点都设置为未访问
			for(i=0;i<graph.vertexnum;i++) {
				if(visited[i]==false) {
					IsBipartite_Graph_DFS(i,red);  //判断输入的图是不是二部图,如果是,则将图的顶点划分为红点集和蓝点集
					if(flag==false) return;  //IsBipartite_Graph_DFS执行后,如果输入的图不是二部图,则flag==false
				}
			}
			Exchange();  //如果需要,交换红点集合蓝点集
			count=0;
			vector<int>::iterator it;
			/*
			初始化时,将每个匹配设置为<蓝点,-1>,即蓝点对应的红点为-1
			*/
			for(it=Blue.begin();it!=Blue.end();it++) {
				pair<int,int>p(*it,-1); // <蓝点,-1>
				match.insert(p);
			}
			
		}
		/*
		最大匹配算法
		*/
		void MaxMatch() {
			vector<int>::iterator it;
			if(flag==false) {
				cerr<<"不是二部图!"<<endl;
				return;
			}
			for(it=Red.begin();it!=Red.end();it++) {
				/*
				每次到蓝点集中找增广路径之前,都将所有蓝点设为为未访问
				这样才能找到最大匹配
				*/
				for(int i=0;i<graph.vertexnum;i++) visited[i]=false;
					if(DFS(*it)) count++;
			}
			ElemType red,blue;
			cout<<"最大匹配是:"<<endl;
			map<int,int>::iterator pos;
			for(pos=match.begin();pos!=match.end();pos++) {
				if(pos->first==-1 || pos->second==-1) {
					unMatchBlue.push_back(pos->first);
					continue;  //此时match中有顶点没有匹配
				}
				Get(pos->first,blue);  
				Get(pos->second,red);  
				cout<<"红点:"<<red<<"到"<<"蓝点"<<blue<<endl;
			}
			cout<<"共有"<<count<<"个匹配"<<endl;
			cout<<"未匹配的蓝点是:";
			for(it=unMatchBlue.begin();it!=unMatchBlue.end();it++) {
				cout<<*it<<" ";
			}
			cout<<endl;
		}

		/*
		匈牙利算法,其核心思想是对于红点集中每一个红点,到蓝点集中找出所有的增广路径,找到就增广
		从而不断扩充原有的匹配,如果红点集中每个红点都找到匹配,即其所对应的蓝点,则程序找到
		完备匹配
		*/
		void Hungary() {  
			vector<int>::iterator it;
			if(isolateflag==true || flag==false)  {
				if(flag==false) {
					cerr<<"不是二部图!"<<endl;
					return;
				}
				else {
					cerr<<"此二部图存在孤立点,找不到最优匹配!"<<endl;
					return;
				}
			}

			for(it=Red.begin();it!=Red.end();it++) {
				/*
				每次到蓝点集中找增广路径之前,都将所有蓝点设为为未访问
				这样才能找到完备匹配
				*/
				for(int i=0;i<graph.vertexnum;i++) visited[i]=false;
					if(DFS(*it)) count++;
			}
			if(count<Red.size()) {  //此时至少有一个红点没有与其匹配的蓝点
				cerr<<"此二部图不存在完备匹配!"<<endl;
				perfectMatch=false;
				return;
			}
			ElemType red,blue;
			cout<<"完备匹配是:"<<endl;
			map<int,int>::iterator pos;
			for(pos=match.begin();pos!=match.end();pos++) {
				if(pos->first==-1 || pos->second==-1) continue;  //此时match中有顶点没有匹配
				Get(pos->first,blue);  
				Get(pos->second,red);  
				cout<<"红点:"<<red<<"到"<<"蓝点"<<blue<<endl;
			}
			cout<<"共有"<<count<<"个匹配"<<endl;
		}
		/*
		显示二部图的红点集合蓝点集
		*/
		void show() {
			Graph<ElemType>::show();
			vector<int>::iterator it;
			cout<<endl<<"红点集是:"<<endl;
			for(it=Red.begin();it!=Red.end();it++) {
				cout<<*it<<" ";
			}
			cout<<endl;
			cout<<endl<<"蓝点集是:"<<endl;
			for(it=Blue.begin();it!=Blue.end();it++) {
				cout<<*it<<" ";
			}
			cout<<endl;
			if(isolateflag) {
				cout<<endl<<"孤立点是:"<<endl;
				for(it=isolate.begin();it!=isolate.end();it++) {
					cout<<*it<<" ";
				}
			}
			cout<<endl;
		}
		~Bipartite_Graph() {
			delete []vertexcolor;
		}
	/**********************************************************************/
		/*
		此方法找出最优匹配,核心思想是利用枚举法,当某个红点i在蓝点集中找到匹配时,
		下一个红点i+1从未访问过的蓝点中找匹配
		*/
		void OptimalMatch() {
			int i,k;
			if(isolateflag==true || flag==false)  {
				if(flag==false) {
					cerr<<"不是二部图!"<<endl;
					return;
				}
				else {
					cerr<<"此二部图存在孤立点,找不到最优匹配!"<<endl;
					return;
				}
			}
			for(i=0;i<graph.vertexnum;i++) visited[i]=false;
			k=0;  //k表示匹配数
			perfectMatch=false;
			vector<int>::iterator it=Red.begin();
			DFS(it,k);
			if(perfectMatch==false) {
				cerr<<"该二部图不存在完备匹配!"<<endl;
				return;
			}
			int maxpos;
			int maxweight=0;
			for(i=0;i<MatchArray.size();i++) {
				if(MatchArray[i].second>maxweight) {
					maxweight=MatchArray[i].second;
					maxpos=i;
				}
			}
			cout<<"最优匹配是:"<<endl;
			stack<pair<int,int> > s=MatchArray[maxpos].first;
			while(s.empty()==false) {
				int red=s.top().first;
				int blue=s.top().second;
				cout<<"红点:"<<red<<"--"<<"蓝点:"<<blue<<endl;
				s.pop();
			}
			cout<<"权值和为:"<<maxweight<<endl;
		}
		/*
		*最小覆盖点集
		*/
		void MinCoveredPoints() {
			vector<int>::iterator it;
			int i; //指向蓝点
			int j; //指向红点
			for(it=unMatchBlue.begin();it!=unMatchBlue.end();it++) {
				setVisitedFalse();
				i=*it;
				while(true) {
					MarkedBlue.insert(i);  //将蓝点加入标记集合
					visited[i]=true;
					j=BlueToRed(i);          //找到与蓝点i相邻接且未匹配的红点
					if(j==-1) break;
					MarkedRed.insert(j);  //将红点加入标记集合
					visited[j]=true;
					i=MatchedRed(j);		 //找到与红点j匹配的蓝点i
				}
			}
			set<int>::iterator pos;
			for(pos=MarkedRed.begin();pos!=MarkedRed.end();pos++) {
				minCoveredPoints.insert(*pos);
			}
			for(it=Blue.begin();it!=Blue.end();it++) {
				if(MarkedBlue.find(*it)==MarkedBlue.end()) minCoveredPoints.insert(*it);
			}
			cout<<"最小覆盖顶点是"<<endl;
			ElemType e;
			for(pos=minCoveredPoints.begin();pos!=minCoveredPoints.end();pos++) {
				Get(*pos,e);  
				cout<<e<<" ";
			}
			cout<<endl;
		}
	private:
		void Exchange() {
			if(Red.size()<=Blue.size()) return;
			//swap(Red,Blue); //交换两个向量的内容,这样在使用匈牙利算法时可节省查找增广路径的时间
			Red.swap(Blue);
		}
		/*
		此方法识别输入图是不是二部图,核心思想是通过图的深度优先遍历,对每个顶点进行着色,
		如果相邻接的两个顶点颜色一致,则该图不是二部图
		@start: 选择一个开始的顶点进行深度优先遍历
		@Color: 当前被访问顶点的颜色
		*/
		void IsBipartite_Graph_DFS(int start,Color color) {  //pre是顶点start在DFS序列中的直接前驱顶点
			int j;
			visited[start]=true;    
			lnode *p=graph.array[start].link;
			/*
			 找到孤立点 
			*/
			if(!p) {
				isolateflag=true;         
     			isolate.push_back(start);  //加入孤立点集合
				return;
			}
			if(vertexcolor[start]==black) {  //此顶点没有打上颜色
				vertexcolor[start]=color;
				if(color==red) {
					Red.push_back(start);  //将此顶点加入红点集
					color=blue;  //将颜色转化
				}
				else {
					Blue.push_back(start);
					color=red;
				}
			}
			while(p) {
				j=p->sequence;
				if(!visited[j]) {
					if(flag==true) IsBipartite_Graph_DFS(j,color); //去检查此顶点的相邻顶点
				}
				else {
					if(vertexcolor[j]==vertexcolor[start]) {  //相关联的两个顶点颜色一样,则此图不是二分图
						cerr<<"不是二分图!"<<endl;
						Red.clear();
						Blue.clear();
						flag=false;
						return;
					}
				}
				p=p->next;
			}
		}
		/*
		此方法根据红点k,在蓝点集中找到增广路径,找到就增广
		@k: 红点
		*/
		bool DFS(int k) {
			vector<int>::iterator it;
			for(it=Blue.begin();it!=Blue.end();it++)  //试探每一个蓝点集的顶点
			{
				
				if(graph.connect[k][*it] && !visited[*it])  //如果此蓝点与红点相连,且该蓝点没有被访问过
				{
					visited[*it]=true;
					if(match[*it]==-1 || DFS(match[*it]))  //如果该蓝点没有与其匹配的红点,或者蓝点
													//有匹配的红点,那么从该红点查找匹配
					{
						match[*it]=k;    //找到增广路径,将其取反
						return true;
					}
				}
			}
			return false;
		}
		/*********************************************************************************/
		void DFS(vector<int>::iterator i,int k) {  //i指向当前的红点,k表示匹配数
			vector<int>::iterator it;
			int weight;
			if(i!=Red.end() && k<Red.size()) {
				for(it=Blue.begin();it!=Blue.end();it++) {
					if(graph.connect[*i][*it] && !visited[*it]) {  //匹配成功
						pair<int,int>p(*i,*it);  //构造一个匹配
						Stack.push(p);  //将此匹配入栈
						visited[*it]=true;
						DFS(i+1,k+1);  //递归从第i+1个红点去找匹配
						visited[*it]=false;  //将递归前的访问到蓝点变成未访问
						Stack.pop();
					}
				}
			}
			if(k==Red.size()) {  //所有红点都已经找到匹配
				perfectMatch=true;
				int j;
				for(j=0;j<k;j++) {
					tempStack.push(Stack.top());
					Stack.pop();
				}
				weight=0;
				for(j=0;j<k;j++) {
					pair<int,int>p=tempStack.top();
					weight+=graph.connect[p.first][p.second];
					tempStack.pop();
					Stack.push(p);
				}	
				pair<stack<pair<int,int> >,int>p(Stack,weight);
				MatchArray.push_back(p);
			}
		}
		/*
		*给定红点查找与其匹配的蓝点
		*/
		int MatchedRed(int red) {
			map<int,int>::iterator pos;
			for(pos=match.begin();pos!=match.end();pos++) {
				if(pos->second==red) return pos->first;			
			}
		}
		/*
		*给定蓝点找与其邻接的没有被访问过且不匹配的红点
		*/
		int BlueToRed(int Blue) {
			vector<int>::iterator it;
			for(it=Red.begin();it!=Red.end();it++) {
				if(graph.connect[Blue][*it] && visited[*it]==false) {
					return *it;
				}
			}
			return -1;  //找不到满足条件的红点
		}
		void setVisitedFalse() {
			int i;
			for(i=0;i<graph.vertexnum;i++) visited[i]=false;  //将所有顶点都设置为未访问
		}
		public:
			void test() {
				int blue;
				do{
					setVisitedFalse();
					cin>>blue;
					cout<<BlueToRed(blue);
				}while(blue!=-1);
			}
};

void main() {
	Bipartite_Graph<string>bg(0,0);  //不带权值的无向图
	bg.show();
	bg.MaxMatch();
	bg.MinCoveredPoints();
//	bg.Hungary();
//bg.OptimalMatch();	
}


3. 测试

原图如下：

 

在程序中输入该图

输入顶点

输入边

程序输出结果：

顶点输出

边输出

红点集，蓝点集，最大匹配，最小覆盖顶点集输出

 

I am 006!
关注
专栏目录
二分图中对最小顶点覆盖、最小边覆盖、最大独立集的理解
Iguodala的博客
10-29 1万+
仅仅用于自己理解，若有共鸣，别太吐槽就行哈~ 首先是匈牙利算法的本质：(图参考了zxy的) 这个图要详细看完，那么刚开始我想的“找小三”实际上就是递归找增广路的过程，如果找到增广路，匹配数就一定可以加一。(代码就不上了，都是一个模板) 理解到这里其实才只是个开始，我想解决的是最大匹配与最小顶点覆盖数、最小边覆盖数、最大点独立集之间的关系是怎么得来的。首先是结论
最大匹配、最小顶点覆盖、最大独立集、最小路径覆盖（转）
c3po
10-28 3549
在讲述这两个算法之前，首先有几个概念需要明白： 二分图:  二分图又称二部图，是图论中的一种特殊模型。设G=(V,E)是一个无向图，如果顶点V可以分割为两个互不相交的子集(A,B),并且图中的每条边(i,j)所关联的两个顶点i和j分别属于这两个不同的顶点集(i in A, j in B), 则称图G是二分图。  匹配：  给定一个二分图，在G的一个子图G’中，如果G’的边集中的任意两条边都不...
二分图（最小顶点覆盖、最大匹配、最大独立集）
桃夭丶的博客
11-12 984
本文参考于：https://www.cnblogs.com/czsharecode/p/9777533.html 一、二分图的基本概念   二分图又称为二部图，是图论的一种特殊模型。   设 G=(V,E)是一个无向图，如果顶点 V 可以分割为两个互不相交的子集 (A,B)，并且图中的每条边 (i,j) 所关联的顶点 i 和 j 分别属于这两个不同的顶点集 （i in A,j in B) ，则称图...
poj2226 二分图经典建图求最小点覆盖
喵 喵 喵~
08-31 462
题意：：给出一个N行M列的图，’*’代表稀泥，’.’代表草地，现在要用一些木板把所有的稀泥盖住，但是不能盖住草地。一张木板只能盖住一行或者一列中的一部分，求至少要用多少木板把所有的稀泥盖住。 把横向连续的点压在一起作为L，把列向连续的点压在一起作为R，如果两者有交集，就从L到R连一条边。求最小点覆盖(==最大匹配数) #include &lt;cstdio&gt; #include &lt;c...
poj3041-Asteroids , 二分图的最小顶点覆盖数 = 最大匹配数
天亮说晚安
07-12 2774
点击打开链接 二分图的最小顶点覆盖数 = 二分图的最大匹配数 题意： 在N*N的网络中有K颗小行星。小行星i的位置是(Ri, Ci)。现在有一个强力的武器能够用一发光束将一整行或一整列的小行星消灭。想要利用这个武器消灭所有的小行星最少需要几发光束？ 分析： 以小行星的左右坐标建立二分图，就可以看出是求二分图的最小顶点覆盖数。 #include #include #inc
二分图--最小点覆盖及证明
qq_52280112的博客
07-21 3967
假如选了一个点就相当于覆盖了以它为端点的所有边。最小顶点覆盖就是选择最少的点来覆盖所有的边。
【二分图】HDU1150 最小顶点覆盖
qq_40999273的博客
07-01 627
二分图小总结： 1、最小顶点覆盖 = 最大匹配数 最小顶点覆盖：实质是个点集，点集里面的点能覆盖所有的边，最小点覆盖就是满足这个要求的点集中点数最小的那个 2、最大独立集 = 顶点个数V - 最大匹配数 最大独立集：实质是个点集，点集里面的点互相之间不连着，最大独立集就是满足这个要求的点集中点数最多的那个 3、最小边覆盖 =顶点个数V - 最大匹配数 最小边覆盖：实质是个边集，这个集合里的边能覆盖所有的点，最小边覆盖是满足这个要求的所有边集中边数最少的一个 这里顶点数等于总的顶点数 ...
König定理：二部图中的最大匹配与最小覆盖
它阐述了在一个二部图（一种特殊的图，其中顶点分为两组，每条边连接不同组的顶点）中，最大匹配数（最大匹配是指图中没有两个匹配边共享顶点的边集合，其数量最大）r(G)与最小覆盖数（最小覆盖是指图中恰好覆盖所有...
二分图的最小覆盖和最大匹配
sunpengshanda的博客
03-23 1298
二分图：对于图G=(V,E)，存在一种方式，将V划分为两个点集，每个点集内任意两个点间没有边。 覆盖：V的子集，E中每条边至少有一个顶点在该集合中。 最小覆盖：能够覆盖G的最少顶点集合。 匹配：E的子集，该集合中任意两条边不相交。 最大匹配：能够匹配G的最大边集合。 定理：二分图中的最小覆盖数等于最大匹配数。 先证充分性。记二分图的最小覆盖数为m，最大匹配数为n，显然有： m⩾\geqslant⩾...
二部图算法：POJ题目详解与代码实践
1. Mayor's posters.cpp: 这个文件可能涉及到了在二部图中某种特定的优化问题，比如某些类型的覆盖问题或者是二部图的最优匹配问题。 2. Tree.cpp: 这个文件可能包含了基于二部图构建树结构的算法实现，如构建最小...
二分图匹配&&最小顶点覆盖
simao
08-19 746
上大佬博客 https://blog.csdn.net/acdreamers/article/details/8621130 https://blog.csdn.net/qq_41730082/article/details/81456611 https://blog.csdn.net/qq_34921856/article/details/79535004 https://blog.c...
二分图的最大匹配问题和基数顶点覆盖问题（2）
Drogoyyy的博客
07-17 909
这篇文章为上篇文章的下叙，主要介绍基数顶点覆盖问题。这个问题也是出自文章《Approximation Algorithms》。 现在我们就来解决上一篇文章中我们提到的''Is the size of the minimum vertex cover inGat mostk? ''这个问题 首先我们介绍一下什么是基数顶点覆盖问题，也就是基数顶点覆盖的定义： 定义：假如选定了一个点就相当于覆盖了以它为端点的所有边。最小顶点覆盖就是用最少的点来覆盖所有的边。 ...
图的匹配--二分图，一般图以及二分图的边覆盖、独立集和顶点覆盖
csyifanZhang的博客
03-02 1842
最经典的二分图匹配问题： 这个问题可以像下面这样转化为图论模型来分析。我们可以像下面这样来定义无向二分图，G=(U∪V,E)G=(U\cup V, E)G=(U∪V,E)。 UUU是代表计算机的顶点集合，VVV代表任务的顶点集合，对于任意的u∈Uu\in Uu∈U,v∈Vv\in Vv∈V，计算机uuu能处理任务vvv，那我们就在u,vu,vu,v之间连一条边，(u,v)∈E(u,v)\in E...
二分图匹配 --- 最小点覆盖
Anxdada -- 我等风来也等你
08-15 606
//二分图有一个重要模型 – 最小点覆盖. 结论 ： 最小点覆盖 = 二分图最大匹配数.解释: 最小点覆盖指的是选择尽量少的点, 使得每条边至少有一个端点被选中. 那么在二分图匹配中很容易可以被证明就是该个二分图的最匹配数. (把图画出来写一写就知道了.)举几个例子 :经典例题UVa – 11419 //题意: 在一个矩阵上某些位置上有一些目标, 每一次可以发射一颗子弹, 这颗子弹可以把任意一
二分图最大匹配，最小点覆盖，最小路径覆盖，二分图最大独立集
Winjourn的专栏
11-10 1440
1） ）数 一个二分图中的最大匹配数等于这个图中的最小点覆盖数 König 定理是一个二分图中很重要的定理，它的意思是，一个二分图中的最大匹配数等于这个图中的最小 点覆盖数。如果你还不知道什么是最小点覆盖，我也在这里说一下：假如选了一个点就相当于覆盖了以它 为端点的所有边，你需要选择最少的点来覆盖所有的边 UVA11419最小点覆盖，打印匹配位置。 #include #include
二分图大合集——二分图最大匹配（最小覆盖数），完美匹配以及最优匹配（带权最大匹配）
热门推荐
ling_wang的博客
04-06 4万+
二分图： 定义：二分图又称作二部图，是图论的一种特殊模型。设G=(V, E)是一个无向图，如果顶点V可分割为两个互不相交的子集（A , B），且图中的每条边（i, j）所关联的两个定点分别属于这两个不同的顶点集（i in A, j in B），则称图G为一个二分图。 简单的说，一个图被分成了两部分，相同的部分没有边，那这个图就是二分图，二分图是特殊的图。（不含奇环） 由定义可知，二分图没有自...
分图的最大匹配与最小路径覆盖
态度决定高度
07-15 1235
转自： http://stqdd.com/blog/?p=124 二分图的最大匹配与最小路径覆盖 在讲述这两个算法之前，首先有几个概念需要明白： 二分图: 二分图又称二部图，是图论中的一种特殊模型。设G=(V,E)是一个无向图，如果顶点V可以分割为两个互不相交的子集(A,B),并且图中的每条边(i,j)所关联的两个顶点i和j分别属于这两个不同的顶点集(i in A, j in B),
图论——二分图——最小点覆盖
T.J的博客
06-20 1万+
最小点集覆盖 == 最大匹配 ①最小点集覆盖<=最大匹配， 假设最小点集覆盖为n, 那么一定能构造出一个为n的匹配， 显然这个匹配<= 最大匹配 ②最小点集覆盖 >= 最大匹配。 假设最大匹配为n，所以肯定有n条边，他们的端点互不相同。 因此我们要覆盖这n条边至少要n个定点。 所以 最小点集覆盖>= 最大匹配。 综上： 最小点集覆盖 == 最大匹配 所以可以通过二分图匹...
二分图最大匹配的König定理及其证明
matrix67的专栏
12-02 1115
    如果你看不清楚第二个字母，下面有一个大号字体版本： 二分图最大匹配的König定理及其证明     本文将是这一系列里最短的一篇，因为我只打算把König定理证了，其它的废话一概没有。    以下五个问题我可能会在以后的文章里说，如果你现在很想知道的话，网上去找找答案：    1. 什么是二分图；    2. 什么是二分图的匹配；    3. 什么是匈牙利算法；(http:/
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值