题目地址:
https://www.acwing.com/problem/content/863/
给定一个二分图,其中左半部包含 n 1 n_1 n1个点(编号 1 ∼ n 1 1\sim n_1 1∼n1),右半部包含 n 2 n_2 n2个点(编号 1 ∼ n 2 1\sim n_2 1∼n2),二分图共包含 m m m条边。数据保证任意一条边的两个端点都不可能在同一部分中。求该二分图的最大匹配,返回匹配数。
输入格式:
第一行包含三个整数
n
1
n_1
n1、
n
2
n_2
n2和
m
m
m。接下来
m
m
m行,每行包含两个整数
u
u
u和
v
v
v,表示左半部点集中的点
u
u
u和右半部点集中的点
v
v
v之间存在一条边。
输出格式:
输出一个整数,表示二分图的最大匹配数。
数据范围:
1
≤
n
1
,
n
2
≤
500
1\le n_1,n_2\le 500
1≤n1,n2≤500
1
≤
u
≤
n
1
1\le u\le n_1
1≤u≤n1
1
≤
v
≤
n
2
1\le v\le n_2
1≤v≤n2
1
≤
m
≤
1
0
5
1\le m\le 10^5
1≤m≤105
可以用匈牙利算法。我们先将这个二分图分为左右两部分,左半部分编号为 u 1 , . . . u n 1 u_1,...u_{n_1} u1,...un1,右半部分编号为 v 1 , . . . , v n 2 v_1,...,v_{n_2} v1,...,vn2。其思想是这样的,每次枚举左边的点,然后对这个点进行搜索,按照非匹配边、匹配边、非匹配边、匹配边等等这样的顺序走,匹配边指的是其两端点在之前已经形成匹配,非匹配边则是相反的意思。这个过程在第一次走到右边的非匹配点停止。非匹配点指的是在之前还未匹配的点。如果存在一条这样的路径的话,就找到了一个更优的匹配(具体来说匹配数会比旧匹配数加 1 1 1)。解释是这样的,不妨设这个路径是 u 1 → v 1 → u 2 → v 2 → . . . → u k → v k u_1\to v_1\to u_2\to v_2\to ...\to u_k\to v_k u1→v1→u2→v2→...→uk→vk,那么 u 1 → v 1 u_1\to v_1 u1→v1是个非匹配边, v 1 → u 2 v_1\to u_2 v1→u2是个匹配边, u 2 → v 2 u_2\to v_2 u2→v2是个非匹配边,以此类推。显然这条路径里一共有 k − 1 k-1 k−1个匹配边,但是我们可以重新排列,使得 u 1 , v 1 u_1,v_1 u1,v1匹配, u 2 , v 2 u_2,v_2 u2,v2匹配,等等,这样匹配数就是 k k k个,比原先多一个。显然这样做更优。算法的思想就是,遍历左边的点,每次都去找形如这样的路径(这样的路径被称作增广路,这个增广路和网络流里的增广路意思不一样,但非常相似),如果找到了就将匹配数加 1 1 1。实现的话可以用DFS,在寻找增广路的同时,如果找到了,就在回溯的时候把这个增广路的匹配边反一下,形成更长的路径以及更大的匹配。代码如下:
#include <iostream>
#include <cstring>
using namespace std;
const int N = 510, M = 100010;
int n1, n2, m;
int h[N], e[M], ne[M], idx;
// match[i]存的是右边的点i与左边哪个点匹配的。match[i] = 0说明还未匹配
int match[N];
bool st[N];
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
// 返回从v出发是否能找到一条增广路
bool dfs(int v) {
for (int i = h[v]; ~i; i = ne[i]) {
int j = e[i];
if (!st[j]) {
st[j] = true;
// 如果走到了非匹配点,那已经找到了一条增广路,将其与v匹配并返回true;
// 如果走到了匹配点j,那就看从j的匹配点出发能不能走出一条增广路,如果能,
// 也可以将v与j匹配并返回true;否则不做新匹配,匹配保持原样
if (!match[j] || dfs(match[j])) {
match[j] = v;
return true;
}
}
}
// 否则说明从v出发找不到增广路,返回false
return false;
}
int main() {
cin >> n1 >> n2 >> m;
memset(h, -1, sizeof h);
while (m--) {
int a, b;
cin >> a >> b;
add(a, b);
}
int res = 0;
for (int i = 1; i <= n1; i++) {
// st数组实际上就是DFS中的visited数组,每次都要清为false
memset(st, 0, sizeof st);
// 如果从i能找到增广路,就能增加匹配数,将匹配数加1
if (dfs(i)) res++;
}
cout << res << endl;
return 0;
}
时间复杂度 O ( n m ) O(nm) O(nm),空间 O ( n ) O(n) O(n)。