图论专题-学习笔记：匈牙利算法

目录

• 1. 前言
• 2. 例题
• 3. 总结

1. 前言

本篇博文将会专门讲述匈牙利算法的具体思路，实现过程以及正确性证明。

匈牙利算法是在 \(O(n \times e+m)\) 内的时间内寻找二分图的最大匹配的一种算法，其中 \(n\) 为左部点个数，\(m\) 为右部点个数。

在学习匈牙利算法之前，请先确保掌握以下名词：

1. 二分图
2. 匹配与最大匹配
3. 增广路

如果对上述部分名词没有掌握，请先掌握后再来学习。

懒得百度？传送门：图论专题-学习笔记：二分图基础

2. 例题

模板题：P3386 【模板】二分图最大匹配

由于自然语言描述匈牙利算法难懂且难表述，直接采用图示方法讲解。

（绘图工具：Windows 画图软件）

为了理解方便，我们假设左边的 \(A_1-A_4\) 表示 4 个人，这 4 个人去吃饭，\(B_1-B_4\) 表示 4 道菜，每个人都有自己喜欢的菜，而连线就表示喜欢的菜。

没错 B2 因为太难吃了以至于没人喜欢

每个人至多只能选择一道菜。

先给 \(A_1\) 分菜。\(A_1\) 喜欢吃 \(B_1\)，那么就将 \(B_1\) 分配给 \(A_1\)。

那么分配如下所示（红色边就是匹配）：

再给 \(A_2\) 分菜。\(A_2\) 也喜欢吃 \(B_1\)，于是就有了这样一段对话：

\(A_2\)：“我说 \(A_1\) 呀，我也想吃 \(B_1\)，您就不能换一道菜吗？”

\(A_1\)：“啊这？好吧，\(B_1\) 给你，我吃 \(B_3\)。”

于是当前分配如下：

现在考虑 \(A_3\)。糟糕，\(A_3\) 也想吃 \(B_1\)。

\(A_3\) ：“\(A_2\) 在吗？您可不可以换一道菜啊，我也想吃 \(B_1\)。”

\(A_2\) ：“啊这？但是我只喜欢这一道菜，根据先到先得原则，我不能让给您。”

于是 \(A_3\) 没有吃到 \(B_1\)，但是 \(A_3\) 还喜欢 \(B_4\) 啊！于是 \(A_3\) 选择了 \(B_4\) 这道菜。

那么当前分配如下：

最后是 \(A_4\)。\(A_4\) 也想吃 \(B_1\)，而且也只喜欢 \(B_1\)。很遗憾的是，\(B_1\) 已经被 \(A_2\) 选走了，且 \(A_2\) 不愿意换。

最后，\(A_4\) 谁都没选到。

因此结果为 3。

你会发现，实际上上面的所有过程就是寻找最大匹配的过程。

简单总结一下：

1. 如果新来的人想选择一道菜且这道菜没有被选，那么就选上。
2. 如果想选的菜冲突了，以前的换一道菜。
3. 但是如果以前的菜不能换，那么新来的人只能换一道菜。
4. 如果新来的人想选的菜都选不了，那么就别吃了。

有关该算法的系统语言描述以及正确性证明见代码后面。

代码（推荐先将后面理论看完再看代码）：

/*
========= Plozia =========
	Author:Plozia
	Problem:P3386 【模板】二分图最大匹配
	Date:2021/3/14
========= Plozia =========
*/

#include <bits/stdc++.h>
using std::vector;

typedef long long LL;
const int MAXN = 500 + 10;
int n, m, e, Match[MAXN], ans;
vector <int> Next[MAXN];
bool book[MAXN];

int read()
{
	int sum = 0, fh = 1; char ch = getchar();
	for (; ch < '0' || ch > '9'; ch = getchar()) fh -= (ch == '-') << 1;
	for (; ch >= '0' && ch <= '9'; ch = getchar()) sum = (sum << 3) + (sum << 1) + (ch ^ 48);
	return (fh == 1) ? sum : -sum;
}

bool dfs(int k)
{
	for (int i = 0; i < Next[k].size(); ++i)
	{
		int u = Next[k][i];
		if (book[u]) continue;
		book[u] = 1;
		if (!Match[u] || dfs(Match[u])) {Match[u] = k; return 1;}//寻找增广路
	}
	return 0;
}

void Hungary()
{
	memset(Match, 0, sizeof(Match));
	for (int i = 1; i <= n; ++i)
	{
		memset(book, 0, sizeof(book));//注意重置
		if (dfs(i)) ++ans;
	}
}

int main()
{
	n = read(), m = read(), e = read();
	for (int i = 1; i <= e; ++i)
	{
		int u = read(), v = read();
		Next[u].push_back(v);
	}
	Hungary();
	printf("%d\n", ans);
	return 0;
}

那么上面算法的本质是什么呢？

考虑一下 \(A_1\) 和 \(A_2\) 的对话。

我们发现，在 \(A_2\) 还没有匹配之前，\(A_2\) 为 非匹配点。

\((A_2,B_1)\) 为一条 非匹配边。

而 \((A_1,B_1)\) 为一条 匹配边。

\((A_1,B_3)\) 为一条 非匹配边，\(B_3\) 为 非匹配点。

于是：

路径 \(A_2->B_1->A_1->B_3\) 为一条 增广路！

增广路！

在二分图#1（link）中作者提到过增广路有一条重要性质：

• 当增广路上非匹配边比匹配边数量大一，那么将非匹配边改为匹配边，匹配边改为非匹配边，那么该路径依然是增广路而且匹配数加一。

于是我们再结合上面的图示来理解，正确性就显然了。

根据这个性质，在保证路径不变的情况下我们能够尽可能的增加匹配数，而最大匹配一定在若干条增广路上，且增广路上匹配数达到最大。

于是正确性证完了。

因此，匈牙利算法的本质就是不断寻找增广路来扩大匹配。

而代码中的 \(Match\) 数组就是表示匹配，\(Match_i\) 表示 \((i,Match_i)\) 是一条匹配边。

3. 总结

匈牙利算法的本质就是不断寻找增广路来扩大匹配。