【集训笔记】二分图及其应用【HDOJ1068【HDOJ1150【HDOJ1151

匈牙利算法样例程序

格式说明

输入格式：

第1行3个整数，V1,V2的节点数目n1,n2,G的边数m

第2-m+1行，每行两个整数t1,t2，代表V1中编号为t1的点和V2中编号为t2的点之间有边相连

输出格式：

1个整数ans，代表最大匹配数

//邻接矩阵-C
#include <stdio.h>
#include <string.h>

int n1,n2,m,ans;                                //n1 表示左边有n1 个元素, n2 表示右边有n2个元素
int result[101];                                //记录V2中的点匹配的点的编号
bool state[101];                                //记录V2中的每个点是否被搜索过
bool data[101][101];                            //邻接矩阵 true代表有边相连

void init () {
int t1, t2;
memset (data,0,sizeof(data));
memset (result,0,sizeof(result));
ans = 0;
scanf ("%d%d%d",&n1,&n2,&m);
for (int i = 1; i <= m; ++i) {
scanf ("%d%d",&t1,&t2);
data[t1][t2] = true;
}
}

bool find (int a) {
for (int i = 1; i <= n2; ++i) {
if (data[a][i] == 1 && !state[i]) {     //如果节点i与a相邻并且未被查找过
state[i] = true;                    //标记i为已查找过
if (result[i] == 0                  //如果i未在前一个匹配M中
|| find(result[i]) ) {              //i在匹配M中，但是从与i相邻的节点出发可以有增广路
result[i] = a;                  //记录查找成功记录
return true;                    //返回查找成功
}
}
}
return false;
}

int main() {

init();
for (int i = 1; i <= n1; ++i) {
memset (state, 0, sizeof(state));       //清空上次搜索时的标记
if (find(i)) ++ans;                     //从节点i尝试扩展
}

printf("%d\n",ans);
return 0;
}

#include <iostream>
#include <cstring>
using namespace std;
//定义链表
struct link {
int data; //存放数据
link* next; //指向下一个节点
link(int=0);
};
link::link(int n) {
data=n;
next=NULL;
}
int n1,n2,m,ans=0;
int result[101]; //记录n1中的点匹配的点的编号
bool state [101]; //记录n1中的每个点是否被搜索过
link *head [101]; //记录n2中的点的邻接节点
link *last [101]; //邻接表的终止位置记录
//判断能否找到从节点n开始的增广路
bool find(const int n) {
link* t=head
;
while (t!=NULL) { //n仍有未查找的邻接节点时
if (!(state[t->data])) { //如果邻接点t->data未被查找过
state[t->data]=true; //标记t->data为已经被找过
if ((result[t->data]==0) || //如果t->data不属于前一个匹配M
(find(result[t->data]))) { //如果t->data匹配到的节点可以寻找到增广路
result[t->data]=n; //那么可以更新匹配M'，其中n1中的点t->data匹配n
return true; //返回匹配成功的标志
}
}
t=t->next; //继续查找下一个n的邻接节点
}
return false;
}
int main() {
int t1=0,t2=0;
cin>>n1>>n2>>m;
for (int i=0; i<m; i++) {
cin>>t1>>t2;
if (last[t1]==NULL)
last[t1]=head[t1]=new link(t2);
else
last[t1]=last[t1]->next=new link(t2）；
}
for (int i=1; i<=n1; i++) {
memset(state,0,sizeof(state));
if (find(i)) ans++;
}
cout<<ans<<endl;
return 0;
}

临接链表

下面一段资料fromhttp://blog.csdn.net/xuguangsoft/article/details/7861988

二分图又称作二部图，是图论中的一种特殊模型。 设G=(V,E)是一个无向图，如果顶点V可分割为两个互不相交的子集(A,B)，并且图中的每条边（i，j）所关联的两个顶点i和j分别属于这两个不同的顶点集(i in A,j in B)，则称图G为一个二分图。



二分图的最大匹配：

匈牙利算法

完美匹配： 如果所有点都在匹配边上，称这个最大匹配是完美匹配。

最小覆盖： 最小覆盖要求用最少的点（Ｘ集合或Ｙ集合的都行）让每条边都至少和其中一个点关联。可以证明：最少的点（即覆盖数）＝最大匹配数

最小路径覆盖：
用尽量少的不相交简单路径覆盖有向无环图Ｇ的所有结点。解决此类问题可以建立一个二分图模型。把所有顶点i拆成两个：Ｘ结点集中的i和Y结点集中的i',如果有边i->j，则在二分图中引入边i->j'，设二分图最大匹配为m,则结果就是n-m。

最大独立集问题：
在Ｎ个点的图G中选出m个点，使这m个点两两之间没有边．求m最大值．
如果图Ｇ满足二分图条件，则可以用二分图匹配来做．最大独立集点数 = N - 最大匹配数

二分图最大匹配问题的匈牙利算法：

分图的最大匹配有两种求法，第一种是最大流（我在此假设读者已有网络流的知识）；第二种就是我现在要讲的匈牙利算法。这个算法说白了就是最大流的算法，但是它跟据二分图匹配这个问题的特点，把最大流算法做了简化，提高了效率。
最大流算法的核心问题就是找增广路径（augment path）。匈牙利算法也不例外，它的基本模式就是：

初始时最大匹配为空 while 找得到增广路径 do 把增广路径加入到最大匹配中去

可见和最大流算法是一样的。但是这里的增广路径就有它一定的特殊性，下面我来分析一下。
（注：匈牙利算法虽然根本上是最大流算法，但是它不需要建网络模型，所以图中不再需要源点和汇点，仅仅是一个二分图。每条边也不需要有方向。）



图1是我给出的二分图中的一个匹配：［1，5］和［2，6］。图2就是在这个匹配的基础上找到的一条增广路径：3->6->2->5->1->4。我们借由它来描述一下二分图中的增广路径的性质：

(1)有奇数条边。
(2)起点在二分图的左半边，终点在右半边。
(3)路径上的点一定是一个在左半边，一个在右半边，交替出现。（其实二分图的性质就决定了这一点，因为二分图同一边的点之间没有边相连，不要忘记哦。）
(4)整条路径上没有重复的点。
(5)起点和终点都是目前还没有配对的点，而其它所有点都是已经配好对的。（如图1、图2所示，［1，5］和［2，6］在图1中是两对已经配好对的点；而起点3和终点4目前还没有与其它点配对。）
(6)路径上的所有第奇数条边都不在原匹配中，所有第偶数条边都出现在原匹配中。（如图1、图2所示，原有的匹配是［1，5］和［2，6］，这两条配匹的边在图2给出的增广路径中分边是第2和第4条边。而增广路径的第1、3、5条边都没有出现在图1给出的匹配中。）
(7)最后，也是最重要的一条，把增广路径上的所有第奇数条边加入到原匹配中去，并把增广路径中的所有第偶数条边从原匹配中删除（这个操作称为增广路径的取反），则新的匹配数就比原匹配数增加了1个。（如图2所示，新的匹配就是所有蓝色的边，而所有红色的边则从原匹配中删除。则新的匹配数为3。）

不难想通，在最初始时，还没有任何匹配时，图1中的两条灰色的边本身也是增广路径。因此在这张二分图中寻找最大配匹的过程可能如下：

(1)找到增广路径1->5，把它取反，则匹配数增加到1。
(2)找到增广路径2->6，把它取反，则匹配数增加到2。
(3)找到增广路径3->6->2->5->1->4，把它取反，则匹配数增加到3。
(4)再也找不到增广路径，结束。

当然，这只是一种可能的流程。也可能有别的找增广路径的顺序，或者找到不同的增广路径，最终的匹配方案也可能不一样。但是最大匹配数一定都是相同的。

对于增广路径还可以用一个递归的方法来描述。这个描述不一定最准确，但是它揭示了寻找增广路径的一般方法：
“从点A出发的增广路径”一定首先连向一个在原匹配中没有与点A配对的点B。如果点B在原匹配中没有与任何点配对，则它就是这条增广路径的终点；反之，如果点B已与点C配对，那么这条增广路径就是从A到B，再从B到C，再加上“从点C出发的增广路径”。并且，这条从C出发的增广路径中不能与前半部分的增广路径有重复的点。
比如图2中，我们要寻找一条从3出发的增广路径，要做以下3步：
(1)首先从3出发，它能连到的点只有6，而6在图1中已经与2配对，所以目前的增广路径就是3->6->2再加上从2出发的增广路径。
(2)从2出发，它能连到的不与前半部分路径重复的点只有5，而且5确实在原匹配中没有与2配对。所以从2连到5。但5在图1中已经与1配对，所以目前的增广路径为3->6->2->5->1再加上从1出发的增广路径。
(3)从1出发，能连到的不与自已配对并且不与前半部分路径重复的点只有4。因为4在图1中没有与任何点配对，所以它就是终点。所以最终的增广路径是3->6->2->5->1->4。

但是严格地说，以上过程中从2出发的增广路径（2->5->1->4）和从1出发的增广路径（1->4）并不是真正的增广路径。因为它们不符合前面讲过的增广路径的第5条性质，它们的起点都是已经配过对的点。我们在这里称它们为“增广路径”只是为了方便说明整个搜寻的过程。而这两条路径本身只能算是两个不为外界所知的子过程的返回结果。
显然，从上面的例子可以看出，搜寻增广路径的方法就是DFS，可以写成一个递归函数。当然，用BFS也完全可以实现。

至此，理论基础部份讲完了。但是要完成匈牙利算法，还需要一个重要的定理：

如果从一个点A出发，没有找到增广路径，那么无论再从别的点出发找到多少增广路径来改变现在的匹配，从A出发都永远找不到增广路径。

要用文字来证明这个定理很繁，话很难说，要么我还得多画一张图，我在此就省了。其实你自己画几个图，试图举两个反例，这个定理不难想通的。（给个提示。如果你试图举个反例来说明在找到了别的增广路径并改变了现有的匹配后，从A出发就能找到增广路径。那么，在这种情况下，肯定在找到别的增广路径之前，就能从A出发找到增广路径。这就与假设矛盾了。）
有了这个定理，匈牙利算法就成形了。如下：

初始时最大匹配为空 for 二分图左半边的每个点i do 从点i出发寻找增广路径。如果找到，则把它取反（即增加了总了匹配数）。

如果二分图的左半边一共有n个点，那么最多找n条增广路径。如果图中共有m条边，那么每找一条增广路径（DFS或BFS）时最多把所有边遍历一遍，所花时间也就是m。所以总的时间大概就是O（n * m）。

真正求二分图的最大匹配的题目很少，往往做一些简单的变化
变种1：二分图的最小顶点覆盖
在二分图中求最少的点，让每条边都至少和其中的一个点关联，这就是“二分图的最小顶点覆盖”。
hdoj1150
二分图的最小顶点覆盖数 = 二分图的最大匹配数

变种2：DAG图（无回路有向图）的最小路径覆盖
用尽量少的不相交简单路径覆盖有向无环图(DAG)的所有顶点，这就是DAG图的最小路径覆盖问题。
hdoj1151
DAG图的最小路径覆盖数 = 节点数（n）- 最大匹配数（m）
关键：求二分图的最大匹配数

变种3: 二分图的最大独立集
hdoj1068
二分图的最大独立集数 = 节点数（n）- 最大匹配数（m）
关键：求二分图的最大匹配数