匈牙利算法：二分图最大匹配原理与实现

爱过河的小马锅

1. 二分图最大匹配算法概述

二分图最大匹配是图论中的一个经典问题，在实际应用中有着广泛的用途。简单来说，二分图是指顶点可以划分为两个不相交的集合，使得每条边的两个端点分别属于这两个集合。而匹配则是指一组没有公共顶点的边集合。

匈牙利算法是解决二分图最大匹配问题最常用的方法之一，其时间复杂度为O(VE)，其中V是顶点数，E是边数。这个算法由匈牙利数学家Dénes Kőnig在1931年提出，因此得名匈牙利算法。

在实际应用中，二分图匹配可以解决许多实际问题，比如：

任务分配问题
婚姻匹配问题
课程安排问题
网络流量优化等

2. 匈牙利算法原理详解

2.1 算法核心思想

匈牙利算法的核心思想是通过不断寻找增广路径来扩大当前的匹配。增广路径是指从一个未匹配点出发，依次经过非匹配边、匹配边、非匹配边...最后到达另一个未匹配点的路径。

算法的基本步骤如下：

初始化所有顶点为未匹配状态
对于左边的每一个未匹配顶点，尝试找到一条增广路径
如果找到增广路径，则反转路径上的边的匹配状态（匹配变非匹配，非匹配变匹配）
重复上述过程直到找不到更多的增广路径

2.2 算法实现细节

在代码实现中，我们通常使用深度优先搜索(DFS)来寻找增广路径。以下是关键变量的作用：

adj[maxn]：邻接表，存储二分图的边
pre[maxm]：记录右边顶点匹配的左边顶点
visit[maxm]：标记右边顶点是否在当前DFS中被访问过

算法的核心函数是Hungarian_findMatch，它尝试为左边的顶点u找到一个匹配。如果成功则返回true，否则返回false。

3. 代码实现与解析

3.1 基础框架实现

cpp复制#include <iostream>
#include <vector>
#include <cstring>
using namespace std;

#define maxn 510
#define maxm 510

vector<int> adj[maxn]; // 邻接表存储
int pre[maxm];         // 匹配记录
bool visit[maxm];      // 访问标记
int n, m;              // 左右顶点数

// 初始化函数
void Hungarian_Init(int n_, int m_) {
    n = n_, m = m_;
    memset(pre, -1, sizeof(pre));
    for (int i = 1; i <= n; ++i) {
        adj[i].clear();
    }
}

// 添加边
void Hungarian_AddEdge(int u, int v) {
    adj[u].push_back(v);
}

// 核心匹配函数
bool Hungarian_findMatch(int u) {
    for (int i = 0; i < adj[u].size(); ++i) {
        int v = adj[u][i];
        if (!visit[v]) {
            visit[v] = true;
            int vpre = pre[v];
            pre[v] = u;
            if (vpre == -1 || Hungarian_findMatch(vpre)) {
                return true;
            }
            pre[v] = vpre;
        }
    }
    return false;
}

// 获取最大匹配数
int Hungarian_GetMaxMatch() {
    int cnt = 0;
    for (int i = 1; i <= n; ++i) {
        memset(visit, false, sizeof(visit));
        if (Hungarian_findMatch(i)) {
            cnt++;
        }
    }
    return cnt;
}

3.2 代码解析

初始化部分：
- Hungarian_Init函数负责初始化所有数据结构
- 需要传入左右两边的顶点数量n和m
- 将pre数组初始化为-1，表示初始时没有匹配
添加边：
- Hungarian_AddEdge函数用于构建二分图
- 参数u表示左边顶点，v表示右边顶点
核心匹配函数：
- Hungarian_findMatch是算法的核心
- 使用DFS尝试为左边顶点u找到匹配
- 如果找到匹配则返回true，否则返回false
获取最大匹配数：
- Hungarian_GetMaxMatch遍历所有左边顶点
- 对每个顶点调用Hungarian_findMatch
- 统计成功匹配的数量

4. 实际应用案例

4.1 职位匹配问题

这是一个典型的二分图匹配应用场景：左边是求职者，右边是职位，边表示求职者可以胜任某个职位。

cpp复制int main() {
    int n, m;
    // n: 职位数量
    // m: 求职者数量
    cin >> n >> m;
    Hungarian_Init(m, n);
    for(int i=1; i <= m; ++i){
        int k;
        cin >> k;
        while(k--){
            int x;
            cin >> x;
            Hungarian_AddEdge(i, x);
        }
    }  
    cout << Hungarian_GetMaxMatch() << endl;
    return 0;
}

在这个例子中：

输入首先给出职位数量n和求职者数量m
然后对于每个求职者，输入其可以胜任的职位列表
最后输出最大匹配数，即最多可以安排多少人到合适的职位

4.2 长方形的覆盖问题

这是一个更有趣的应用，将棋盘覆盖问题转化为二分图匹配问题。

cpp复制char c[25][25];
int dir[4][2] = {
    {0, 1}, {1, 0}, {0, -1}, {-1, 0}
};

int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> c[i];
    }
    Hungarian_Init(n * n, n * n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if ((i + j) & 1) {
                for (int k = 0; k < 4; ++k) {
                    int di = i + dir[k][0];
                    int dj = j + dir[k][1];
                    if (dj < 0 || di == n || dj < 0 || dj == n) {
                        continue;
                    }
                    if (c[i][j] == '1' || c[di][dj] == '1') {
                        continue;
                    }
                    Hungarian_AddEdge(i * n + j + 1, di * n + dj + 1);
                }
            }
        }
    }
    cout << Hungarian_GetMaxMatch() << endl;
    return 0;
}