带权二分图匹配-KM算法

1.KM算法基础

每个员工做不同的工作效率不同，如何分配使总效率最大？
暴力：用匈牙利算法求出所有最大匹配，再从中找出效率和最高的
KM算法：解决带权二分图最优匹配

2.KM算法流程

1.为各顶点赋值值，将左顶点赋值为最大权值，右顶点赋值为0
2.用匈牙利算法寻找完备匹配
3.若未找到完备匹配则修改顶点权值
4.重复(2)(3)直到找到完备匹配为止

时间复杂度O(n^3)

3.KM算法演示

(1)
初始化各顶点值
将左顶点赋值为最大权
将右顶点赋值为0

——————————————————————————————————————————————
(2)
从A出发
尝试与a匹配，4+0!=3 失配
尝试与c匹配，4+0=4 匹配成功

——————————————————————————————————————————————
(3)
从B出发
尝试与a匹配，3+0!=2 失配
尝试与b匹配，3+0!=1 失配
尝试与c匹配，3+0=3 成功

但c已经与A匹配过
尝试修改A的匹配边，发现无法修改
此时B无法匹配
涉及的顶点为A，B，c
令所有左边点-1，所有右边点+1

——————————————————————————————————————————————
(4)
继续从B开始匹配
尝试与a匹配 2+0=2 成功

——————————————————————————————————————————————
(5)
从C开始匹配
5+1!=5 匹配失败
此时C无边可以匹配

涉及到的点为C
令所有左顶点-1，右顶点+1
修改完成后，继续从C开始匹配
尝试与c匹配 4+1=5 成功

但c已经与A匹配
尝试修改A的匹配，发现A-a可以匹配
但a已经和B匹配
尝试修改B的匹配，发现无法修改
此时C无法匹配
涉及的顶点为A，B，C，c，a
所有左边顶点值-1，右边顶点值+1

——————————————————————————————————————————————
(6)
继续从C开始匹配
尝试与c匹配 3+2=5 成功
但c已经与A匹配
尝试修改A的匹配，发现A-a可以匹配
但a已经与B匹配
尝试修改B的匹配，发现B-b可以匹配
将B的匹配修改为B-b
将A的匹配修改为A-a
此时，C与c成功匹配

——————————————————————————————————————————————
(7)
所有顶点都已被匹配
算法结束
此时最优匹配权值为
3+1+5=9

——————————————————————————————————————————————

4.KM算法实现

#include 
#include 
#include 

using namespace std;
const int MAXN = 305;
const int INF = 0x3f3f3f3f;

int E_val[MAXN][MAXN];   // 记录每条边的权值
int L_val[MAXN];      // 每个左顶点的值
int R_val[MAXN];       // 每个右顶点的值
bool L_vis[MAXN];    // 记录每一轮匹配匹配过的左顶点
bool R_vis[MAXN];     // 记录每一轮匹配匹配过的右顶点
int match[MAXN];        // 记录每个右顶点匹配到的左顶点 如果没有则为-1
int slack[MAXN];        // 记录每个右顶点如果能被左顶点匹配最少还需要多少值
int N;                 //顶点数

bool dfs(int now)
{
    L_vis[now] = true;
    for (int i = 0; i < N; i++)
    {
        if (R_vis[i]) continue; // 每一轮匹配 每个右顶点只尝试一次
        int tmp = L_val[now] + R_val[i] - E_val[now][i];

        if (tmp == 0) {  // 如果符合要求
            R_vis[i] = true;
            if (match[i] == -1 || dfs( match[i] )) {    // 找到一个没有匹配的右顶点 或者该右顶点当前匹配的左顶点可以找到其它匹配
                match[i] = now;
                return true;
            }
        } else {
            slack[i] = min(slack[i], tmp);  // slack 可以理解为该右顶点能被一个左顶点匹配 还需多少值 取最小值
        }
    }
    return false;
}

int KM()
{
    memset(match, -1, sizeof(match));    // 初始每个右顶点都没有匹配的左顶点
    memset(R_val, 0, sizeof(R_val));   // 初始每个右顶点的值为0
    for (int i = 0; i < N; ++i) {             //初始每个左顶点为与其相连边的最大权值
        L_val[i] = E_val[i][0];
        for (int j = 1; j < N; ++j) {
            L_val[i] = max(L_val[i], E_val[i][j]);
        }
    }
    // 尝试为每一个左顶点匹配
    for (int i = 0; i < N; ++i) {
        fill(slack, slack + N, INF);    // 因为要取最小值 初始化为无穷大
        while (1) {
            // 为每个左顶点匹配的方法是 ：如果找不到就降低期望值，直到找到为止
            // 记录每轮匹配中左右顶点是否被尝试匹配过
            memset(L_vis, false, sizeof(L_vis));
            memset(R_vis, false, sizeof(R_vis));
            if (dfs(i)) break;  // 找到匹配 退出
            // 如果不能找到 就降低期望值
            // 最小可降低的期望值
            int d = INF;
            for (int j = 0; j < N; ++j)
                if (!R_vis[j]) d = min(d, slack[j]);
            for (int j = 0; j < N; ++j) {
                // 所有访问过的(被涉及的)左顶点降低值
                if (L_vis[j]) L_val[j] -= d;
                // 所有访问过(被涉及的)的右顶点增加值
                if (R_vis[j]) R_val[j] += d;
                // 没有访问过的右顶点 因为左顶点的期望值降低，距离被左顶点匹配又进了一步
                else slack[j] -= d;
            }
        }
    }
    // 匹配完成 求出所有匹配的权值和
    int res = 0;
    for (int i = 0; i < N; ++i)
        res += E_val[ match[i] ][i];
    return res;
}
int main()
{
    while (~scanf("%d", &N)) {

        for (int i = 0; i < N; ++i)
            for (int j = 0; j < N; ++j)
                scanf("%d", &E_val[i][j]);

        printf("%d\n", KM());
    }
    return 0;
}