匈牙利算法-CFANZ编程社区

匈牙利算法用于二分图的最大匹配，核心问题就是找增广路径。匈牙利算法的时间复杂度为O(VE)，其中V为二分图左边的顶点数，E为二分图中边的数目。

增广路性质：

(1)有奇数条边。
(2)起点在二分图的左半边，终点在右半边。
(3)路径上的点一定是一个在左半边，一个在右半边，交替出现。
(4)整条路径上没有重复的点。
(5)起点和终点都是目前还没有配对的点，而其它所有点都是已经配好对的。
(6)路径上的所有第奇数条边都不在原匹配中，所有第偶数条边都出现在原匹配中。
(7)最后，也是最重要的一条，把增广路径上的所有第奇数条边加入到原匹配中去，并把增广路径中的所有第偶数条边从原
匹配中删除（这个操作称为增广路径的取反），则新的匹配数就比原匹配数增加了1个。

匹配开始时我们任意选择一边的所有未匹配的点为起始点找增广路径，由增广路的性质可以看出，每找到一条增广路径，匹配数增加1。

二分图匹配模型,几种常见变形：

(1)二分图的最小顶点覆盖
最小顶点覆盖要求用最少的点（X或Y中都行），让每条边都至少和其中一个点关联。
Knoig定理：二分图的最小顶点覆盖数等于二分图的最大匹配数。

(2)DAG图的最小路径覆盖
用尽量少的不相交简单路径覆盖有向无环图(DAG)G的所有顶点，这就是DAG图的最小路径覆盖问题。
结论：DAG图的最小路径覆盖数 = 节点数（n）- 最大匹配数（m）

(3)二分图的最大独立集
最大独立集问题：在Ｎ个点的图G中选出m个点，使这m个点两两之间没有边．求m最大值
结论：二分图的最大独立集数 = 节点数（n）— 最大匹配数（m）

总结：

简单点说，就是你从二分图中找出一条路径来，让路径的起点和终点都是还没有匹配过的点，并且路径经过的连线是一条没被匹配、一条已经匹配过，再下一条又没匹配这样交替地出现。找到这样的路径后，显然路径里没被匹配的连线比已经匹配了的连线多一条，于是修改匹配图，把路径里所有匹配过的连线去掉匹配关系，把没有匹配的连线变成匹配的，这样匹配数就比原来多1个。不断执行上述操作，直到找不到这样的路径为止。

伪代码：

bool 寻找从k出发的对应项出的可增广路
{
    while (从邻接表中列举k能关联到顶点j)
    {
        if (j不在增广路上)
        {
            把j加入增广路;
            if (j是未盖点 或者 从j的对应项出发有可增广路)
            {
                修改j的对应项为k;
                则从k的对应项出有可增广路,返回true;
            }
        }
    }
    则从k的对应项出没有可增广路,返回false;
}

void 匈牙利hungary()
{
    for i->1 to n
    {
        if (则从i的对应项出有可增广路)
            匹配数++;
    }
    输出 匹配数;
}

邻接矩阵模板：

int n, m;
int p[1510][1510];//图
int book[1510];
int match[1510];//保存匹配边

bool dfs(int u)
{
    int i;
    for (i = 0; i < n; i++)
    {
        if (book[i] == 0 && p[u][i] == 1)
        {
            book[i] = 1;
            if (match[i] == 0 || dfs(match[i]))
            {
                match[i] = u;
                return true;
            }
        }
    }
    return false;
}
int gungary()
{
    int ans = 0;
    memset(match, 0, sizeof(match));
    for (int i = 0; i < n; i++)
    {
        memset(book, 0, sizeof(book));
        if (dfs(i))
            ans++;
    }
    return ans;
}

邻接表模板：

const int MAXN = 5010;//点
const int MAXM = 50010;//边

struct  Edge
{
    int to;
    int next;
}edge[MAXM];

int head[MAXN], tot;

void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}

void addedge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}

int linker[MAXN];
bool used[MAXN];
int uN;

bool dfs(int u)
{
    for (int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if (!used[v])
        {
            used[v] = true;
            if (linker[v] == -1 || dfs(linker[v]))
            {
                linker[v] = u;
                return true;
            }
        }
    }
    return false;
}

int hungary()
{
    int ans = 0;
    memset(linker,-1,sizeof(linker));
    for (int u = 0; u < uN; u++)
    {
        memset(used,false,sizeof(used));
        if (dfs(u)) ans++;
    }
    return ans;
}