「学习笔记」匈牙利算法
二分图匹配
定义：给定一个二分图 \(G\)，在 \(G\) 的一个子图 \(M\) 中，\(M\) 的边集 \(E\) 中的任意两条边都不依附于同一个顶点，则称 \(M\) 是一个匹配。
匹配点：匹配边上的两点。
通俗一点就是一个二分图，每一个点最多只能选择连着一条边。
极大匹配
是指在当前已完成的匹配下，无法再增加未完成的匹配的边的方式来增加匹配的边数。
如图：
\(1 \rightarrow 4, 5 \rightarrow 8, 7 \rightarrow 6\) 是我们选择的边，这是一个极大匹配，
最大匹配
是指所有的极大匹配当中边数最大的一个匹配，设为 \(M\)。选择这样的边数最大的子集成为图的最大匹配问题。
最大匹配一定是极大匹配，极大匹配不一定是最大匹配。
如图：
\(1 \rightarrow 4\) 是我们选择的边，这是一个极大匹配，但是，它不是一个最大匹配。
完美匹配（完备匹配）
一个图中所有的顶点都是匹配点的匹配，即 \(M=2 \times V\)。完美匹配一定是最大匹配。
其实就是两部分的点一一对应。
如图：
这就是一个完美匹配。
最大匹配
最优匹配又称为带权最大匹配，是指在带有权值边的二分图中，求一个匹配使得匹配边上的权值和最大。一般 \(X\) 和 \(Y\) 集合顶点个数相同，最优匹配也是一个完美匹配，即每一个顶点都被匹配。如果个数不相等，可以通过补点加 \(0\) 边实现转化。一般会使用 KM 算法来解决此问题，这个我们后面再说。
二分图最大匹配
先来看几个定义：
交替路：从一个未匹配点出发，依次经过非匹配边、匹配边，非匹配边......形成的路径叫做交替路。
增广路：从一个未匹配点出发，走交替路，如果途径另一个未匹配点（出发点不算），则这条交替路称之为增广路。
增广路有一个重要特点：非匹配边比匹配边多一条。因此研究增广路的意义是改进匹配。只要把增广路中的匹配边和非匹配边的身份互换即可。由于中间的匹配节点不存在其他相连的匹配边，所以这样做不会破坏匹配的性质。交换后，图中的匹配数目比原来多了一条。
我们可以通过不停的找增广路来增加匹配中的匹配边和匹配点。找不到增广路时就是最大匹配了（增广路定理）。
匈牙利算法
其实匈牙利算法就是类似于生活中你和一些人选东西，以座位为例，你想选这个座位，如果别人没选，那你就直接坐下，如果已经有别人了，你要先和这个人协商，看看人家愿不愿意让给你，让，你就坐；否则，你就要找其他的位置 要不你站着。
dfs 版本
数组、存图等的准备
#include <iostream>
#include <cstdio>
#include <cstring>
typedef long long ll;
using namespace std;
const int N = 510;
const int M = 5e4 + 5;
int n, m, ed, cnt, tim, ans;
int h[N], vis[N], ask[N];// vis 本次匹配是否访问过 ask 该节点的匹配,为0,则还没有匹配
struct edge {// 链式前向星
int v, nxt;
} e[M << 1];
inline ll read() {// 快读
ll x = 0;
int fg = 0;
char ch = getchar();
while(ch < '0' || ch > '9') {
fg |= (ch == '-');
ch = getchar();
}
while(ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return fg ? ~x + 1 : x;
}
void add(int u, int v) {// 加边,建图
e[++cnt].v = v;
e[cnt].nxt = h[u];
h[u] = cnt;
}
核心代码——dfs：
inline int dfs(int u) {
int v;
for(int i = h[u]; i; i = e[i].nxt) {
v = e[i].v;
if(vis[v]) continue;//这个点能不能选或者能不能“抢”
vis[v] = 1;//能选 或 能“抢”但要协商
if(!ask[v] || dfs(ask[v])) {
//ask[v] == 0不用协商就能选
//否则就dfs(ask[v]),看看原主人能不能换别人(协商)
ask[v] = u;//直接选上 或 协商成功
return 1;//匹配成功
}
}
return 0;//没有连边或协商失败——匹配失败
}
ll match() {
for(int i = 1; i <= n; ++i) {
memset(vis, 0, sizeof vis);//为了满足i的要求,将数组清0，让他可以任意选
ans += dfs(i);//匹配成功+1,否则+0
}
return ans;
}
注释我觉得挺详细的了，dfs 版本比较好理解，也比较好些写，但是许多博主和 dalao 都说 bfs 版本要比 dfs 快一点，所以，我又去学习并理解的 bfs 匈牙利算法，
bfs 版本
bfs 相对于 dfs 的过程差不多，只是 dfs 是通过递归来到这个点来让它找新点，而 bfs 是放进队列中了而已
必要的准备
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
typedef long long ll;
using namespace std;
const int N = 510;
const int M = 5e4 + 5;
int n, m, edge_num, cnt, ans;
int h[N], px[N], py[N];// px 左边的点的匹配点 py 右边的点的匹配点
int vis[N], pre[N];// vis 本轮是否访问过 pre 右边点的前驱
struct edge {// 链式前向星
int v, nxt;
} e[M << 1];
inline ll read() {// 快读
ll x = 0;
int fg = 0;
char ch = getchar();
while(ch < '0' || ch > '9') {
fg |= (ch == '-');
ch = getchar();
}
while(ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return fg ? ~x + 1 : x;
}
void add(int u, int v) {// 加边
e[++cnt].v = v;
e[cnt].nxt = h[u];
h[u] = cnt;
}
老实说，bfs 版本是真的难理解，代码也不好写，在数据比较小的情况下还是用 dfs 更好一些，一定要先理解 dfs 版本再来看 bfs 版本！！！
首先，还是匈牙利的前置函数，没什么可说的
ll match() {
for(int i = 1; i <= n; ++i) {
ans += bfs(i);
}
return ans;
}
然后就是 bfs 的过程
ll bfs(int x) {
memset(vis, 0, sizeof vis);//其实这里也可以记录时间戳来判断是否在本轮被标记
memset(pre, 0, sizeof pre);//前驱一定要清0
queue<int> q;//队列定义在函数内相较于定义在函数外可以免去清空的过程
q.push(x);// 先将本轮要匹配的点入队
while(!q.empty()) {
int u = q.front();// 取队首
q.pop();// 弹出
for(int i = h[u]; i; i = e[i].nxt) {
int v = e[i].v;
if(vis[v]) continue;// 如果本轮他已经被选过了,跳过
vis[v] = 1;// 标记
pre[v] = u;// 记录v点是被谁搜到的,即记录前驱
if(!py[v]) {// 如果v点还没有匹配
aug(v);// 进行匹配
return 1;
}
else {
q.push(py[v]);// 否则就默认点v与当前点u匹配了,原主人入队去找新点
}
}
}
return 0;
}
其实队列的作用与原 bfs 的队列一样，谁要找点谁就入队，找到一个点，没被匹配就直接匹配，匹配了就与原主人协商
接下来是 aug 匹配函数
void aug(int x) {
while(x) {
int temp = px[pre[x]];//记录搜到当前点的点原来的匹配temp
px[pre[x]] = x;
py[x] = pre[x];//将两点进行匹配
x = temp;//将temp带入循环,让他去匹配
}
}
来解释一下，首先，能进入这个函数，一定是右边的点没有被匹配，但是，我们不能确定左边的点是否已经被匹配。
当这个点 \(a\) 是被迫换新点时，它与它原来的配对点 \(b\) 配对关系依旧存在，直到 \(a\) 与其他点配对成功了，原关系才破裂（这里的情况是被迫换新点，所以该点 \(a\) 的原匹配点 \(b\) 就与强迫 \(a\) 换的点的点 \(c\) 进行匹配 点c 是与点 a 抢人的）
更新
dfs 时间戳优化匈牙利算法
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 510;
int n, m, e, tim;
vector<int> son[N];
int ask[N], vis[N];
int dfs(int u) {
for (int v : son[u]) {
if (vis[v] == tim) continue;
vis[v] = tim;
if (!ask[v] || dfs(ask[v])) {
ask[v] = u;
return 1;
}
}
return 0;
}
int main() {
scanf("%d%d%d", &n, &m, &e);
for (int i = 1, u, v; i <= e; ++ i) {
scanf("%d%d", &u, &v);
son[u].push_back(v);
}
int ans = 0;
for (int i = 1; i <= n; ++ i) {
++ tim;
ans += dfs(i);
}
printf("%d\n", ans);
return 0;
}
