AcWing 861. 二分图的最大匹配(匈牙利算法)

题目链接 ：点击查看

题目描述 ：

给定一个二分图，其中左半部包含 n1 个点（编号 1∼n1），右半部包含 n2 个点（编号 1∼n2），二分图共包含 m 条边。

数据保证任意一条边的两个端点都不可能在同一部分中。

请你求出二分图的最大匹配数。

二分图的匹配：给定一个二分图 G，在 G 的一个子图 M 中，M 的边集 {E} 中的任意两条边都不依附于同一个顶点，则称 M 是一个匹配。

二分图的最大匹配：所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配，其边数即为最大匹配数。

输入输出格式 ：

输入

第一行包含三个整数 n1、 n2 和 m。
接下来 m 行，每行包含两个整数 u 和 v，表示左半部点集中的点 u 和右半部点集中的点 v 之间存在一条边。

输出

输出一个整数，表示二分图的最大匹配数。

输入输出样例 ：

输入

2 2 4
1 1
1 2
2 1
2 2

输出

2

题目描述 ：

匈牙利算法的思路为，从二分图的某一侧点集开始遍历，每一个点与其相互连通的第一个点进行匹配，如果相匹配的那个点之前没有点与之匹配，则匹配成功。如若有点与之匹配，则找与其匹配的那个点是否与其他点相连，如若有其他点相连，则改到其他点。反之，则放弃本次匹配。总之，匈牙利算法是通过不断寻找增广路径来实现的，当无法再寻找增广路径，即得到最大匹配数。

具体实现为 ： 首先我们要定义 1 . int match[N]数组，match[i] = j表示i与j节点相匹配。 2. bool st[N] , st[i] = true表示当前次查找匹配点，i点已经有点与之匹配 3. 本题我们用邻接表来存储图结构。 为了找出最大匹配数，在主函数中我们对所有节点进行遍历，查找与之匹配的节点，查找过程是用find函数实现的。在每次调用find函数时，要先将st数组进行状态恢复，即memset(st, false, sizeof(st))，使得st数组仅在当前这一轮有效。在bool find (int x)函数中，我们遍历所有与传入的x节点相连的节点(即遍历以h[x]为头结点的邻接表)。从第一个节点开始，如果当前这一轮此节点没有匹配，我们将此节点进行"预订"即st[j] = true。至于为什么是"预订"，我们接着往下看，因为st数组只在当前轮有效，所以尽管st[j] = false,但j节点之前几轮遍历过程中就已经与其他点相匹配，只有当match[j] == 0，才表示之前没有与其他点相匹配。如果match[j] != 0(假设match[j] = a)，我们再从a这个点再查找是否有另外的点与a连通，如有，我们让a与另外的那个点相匹配，让当前节点x与j点相匹配，既然找到与x相匹配的点，就直接return true 不用再进行后续遍历。
即

for (int i = h[x] ; i != -1; i = ne[i]) {
    int j = e[i];
    if (!st[j] {
       st[j] = true;
       if (match[j] ==0 || find(match[j]) {
           match[j] = x;
           return true;
       }  
    }
}

详见如下代码

代码 ：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N = 510, M = 1e5 + 7;
int n1, n2, m;//n1, n2分别表示二分图左右两边点的标号 
int h[N], e[M], ne[M], cur;//用邻接表的方式来存储图 
int match[N];//match[i] = x 表示节点i与节点x相匹配 
bool st[N];//st[i] = true表示节点i已有匹配 

void add(int v1, int v2) {//建图 
	e[cur] = v2;
	ne[cur] = h[v1];
	h[v1] = cur ++ ;
}
bool find(int x) {//是否能找到匹配 
	for (int i = h[x]; i != -1; i = ne[i]) {//遍历与节点x相连的节点 
		int j = e[i]; 
		if (!st[j]) {//如果当前这一轮遍历下j没有被配对 
			st[j] = true;//预定 
			if (match[j] == 0 || find(match[j])) {//如果j之前没有已经相匹配的点， 或j的与其相匹配的点还能找到其他点 
				match[j] = x;//匹配成功 
				return true;
			}
		}
	}
	return false;
} 
int main() {
	cin >> n1 >> n2 >> m;
	memset(h, -1, sizeof(h));
	for (int i = 0; i < m; i ++ ) {
	    int v1, v2;
		cin >> v1 >> v2;
		add(v1, v2); 
	} 
	int res = 0;//res记录最大匹配数 
	for (int i = 1; i <= n1; i ++ ) {
		memset(st, false, sizeof(st));//每一轮找点都要将状态清空 
		if (find(i)) res ++ ;
	}
	cout << res << endl;
	return 0; 
}
 

---

下面我们给出匈牙利算法的相关模板

时间复杂度是 O(n*m), n 表示点数，m 表示边数
int n1, n2;     // n1表示第一个集合中的点数，n2表示第二个集合中的点数
int h[N], e[M], ne[M], idx;     // 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边
int match[N];       // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个
bool st[N];     // 表示第二个集合中的每个点是否已经被遍历过

bool find(int x)
{
    for (int i = h[x]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j])
        {
            st[j] = true;
            if (match[j] == 0 || find(match[j]))
            {
                match[j] = x;
                return true;
            }
        }
    }

    return false;
}

// 求最大匹配数，依次枚举第一个集合中的每个点能否匹配第二个集合中的点
int res = 0;
for (int i = 1; i <= n1; i ++ )
{
    memset(st, false, sizeof st);
    if (find(i)) res ++ ;
}