【二分图】匈牙利 & KM

二分图

概念：

一个图 \(G=(V,E)\) 是无向图，如果顶点 \(V\) 可以分成两个互不相交地子集 \(X,Y\)

且任意一条边的两个顶点一个在 \(X\) 中，一个在 \(Y\) 中，则称 \(G\) 是二分图

性质：

当且仅当无向图 \(G\) 的所有环都是偶环时， \(G\) 才是个二分图

判定：

可从任意一点开始 \(\text{dfs}\)，按距离编号

如果要编号的点已经被编号，可根据奇偶判断是否是二分图

bool dfs(int u) {

    for (int i = lst[u], v; i; i = nxt[i]) {

        v = to[i];

        if (cl[u] == cl[v])

            return 0;

        if (!cl[v]) {

            cl[v] = 3 - cl[u];

            if (!dfs(v))

                return 0;

        }

    }

    return 1;

}

int main() {

    cl[1] = 1;

    dfs(1);

}

二分图的匹配

概念：

一个二分图 \(G\) 的一个子图 \(M\)，若在 \(M\) 中的任意两条边都不依附同一个顶点

则称 \(M\) 是一个匹配

最大匹配：

即选择边数最大的匹配

完备匹配：

某一部的顶点全部与匹配中的某条边关联

完美匹配：

所有顶点都和匹配中的某条边关联

增广路

定义：

\(M\) 是二分图 \(G\) 的已匹配边的集合，若 \(P\) 是一条联通两个在不同部的未匹配点的路径，

且路径上匹配边与未匹配边交替出现，则 \(P\) 是相对于 \(M\) 的增广路。

性质：

第一条和最后一条都是未匹配边，边数为奇数

因为要联通两个在不同部的未匹配点
一个增广路径 \(P\) 经过取反可以得到一个更大的匹配 \(M'\)
\(M\) 是 \(G\) 的最大匹配当且仅当不存在相对于 \(M\) 的增广路

最大匹配

匈牙利算法

根据增广路的性质，我们也可以想到一种算法

清空 \(M\)
寻找 \(M\) 的增广路 \(P\)，通过取反得到更大的 \(M'\) 代替 \(M\)
重复 (2) 直到找不到增广路为止

这就是匈牙利算法

实现

用 \(\text{dfs}\) ，从 \(X\) 部的一个未匹配点开始，访问邻接点 \(v\) （一定是 \(Y\) 部的）

如果 \(v\) 未匹配，则已找到一条增广路
否则，找出 \(v\) 的匹配顶点 \(w\) （一定是 \(X\) 部的），则 \((w,v)\) 是匹配边

因为要"取反"，所以要使 \((w,v)\) 未匹配， \((u,v)\) 匹配。

能实现这一点就需要从 \(w\) 出发找一条新增广路，如果行，则可以找到增广路

实现：

// cx[i] 是 X 部的点 i 匹配的 Y 部点

// cy[i] 是 Y 部的点 i 匹配的 X 部点

bool dfs(int u) {

	for (int i = 1; i <= m; i++)

		if (mp[u][i] && !vis[i]) {

			vis[i] = 1;

			if (!cy[i] || dfs(cy[i])) {

				cx[u] = i, cy[i] = u;

				return 1;

			}

		}

	return 0;

}

inline void match() {

	memset(cx, 0, sizeof(cx));

	memset(cy, 0, sizeof(cy));

	for (int i = 1; i <= n; i++) {

		memset(vis, 0, sizeof(vis));

		ans += dfs(i);

	}

}

时间复杂度：

邻接矩阵：\(O(n^3)\)
前向星：\(O(nm)\)

最大匹配的性质

最小点覆盖 = 最大匹配

最小点覆盖：选择最少的点使得每条边都至少和其中一个点关联
- 证明：最大匹配能保证剩下的边都与至少一个点关联
最小边覆盖 = 总点数 - 最大匹配

最小边覆盖：选择最少的边去覆盖所有点
- 证明：设总点数是 \(n\)，最大匹配是 \(m\)
  
  则最大匹配能覆盖 \(2m\) 个点，设剩下 \(a\) 个点
  
  则这 \(a\) 个点需要单独用 \(a\) 条边覆盖，最小边覆盖 = \(m+a\)
  
  因为 \(2m+a=n\)
  
  所以最小边覆盖 = \((2m+a)-m=n-m\)
最大点独立集 = 总点数 - 最小点覆盖

最大点独立集：在二分图中选出最多的顶点，使得任两点之间没有边相连
- 证明：删去最小点覆盖的点集，对应的边也没有了，剩下的点就是独立集
  
  因为是最小点覆盖，减去后就是最大点独立集

最佳匹配

如果边有权，则权和最大的匹配叫最佳匹配

有连接 \(X,Y\) 部的顶点 \(X_iY_j\) 的一条边 \(w_{i,j}\) ，要求一种使 \(\sum w_{i,j}\) 最大的匹配

顶标：给顶点的一个标号

设 \(X_i\) 的顶标 \(A_i\) ， \(Y_j\) 的顶标 \(B_j\) ，则在任意时刻需要满足 \(A_i+B_j\ge w_{i,j}\) 成立

相等子图：由 \(A_i+B_j=w_{i,j}\) 的边构成的字图

性质：如果相等字图有完备匹配，那么这个完备匹配是最佳匹配

KM

核心：通过修改顶标使得能找到完备匹配

初始化： \(A_i\) 为所有与 \(X_i\) 相连边的最大权， \(B_i=0\)
寻找完备匹配失败，得到一条路径，叫做交错树

将交错树中 \(X\) 部的顶标全部减去 \(d\) ， \(Y\) 部的顶标全部加上 \(d\) ，会发现
- 两端都在交错树中的边， \(A_i+B_j\) 不变，仍在相等字图中
  
  都不在，仍然不在相等字图
- \(X\) 不在 \(Y\) 在，\(A_i+B_j\) 增大，仍然不在相等字图
- \(X\) 在 \(Y\) 不在，\(A_i+B_j\) 减小，现在可能在相等字图中，使得相等字图扩大
为了使至少有一条边进入相等字图，且 \(A_i+B_j\ge w_{i,j}\) 恒成立

\(d\) 应该等于 \(\min A_i+B_j-w_{i,j}\)
重复 (2) 直到找到完备匹配

复杂度：朴素实现是 \(O(n^4)\) 的

在相等字图上找增广路 \(O(n^2)\) ，每次改顶标最多 \(n\) 次增广路，要改 \(n\) 次顶标

// lx, ly ：顶标

// cy[i] 是 y 部点 i 匹配的 X 部点

bool dfs(int x) {

   vx[x] = 1;

   for (int i = 1, cz; i <= n; i++) {

       if (vy[i]) continue;

       cz = lx[x] + ly[i] - mp[x][i];

       if (cz == 0) {

           vy[i] = 1;

           if (!cy[i] || dfs(cy[i])) {

               cy[i] = x;

               return 1;

           }

       } else lack = min(lack, cz);

   }

   return 0;

}

inline void KM() {

   memset(cy, 0, sizeof(cy));

   for (int i = 1; i <= n; i++)

       for (;;) {

           memset(vx, 0, sizeof(vx));

           memset(vy, 0, sizeof(vy));

           lack = 2e9;

           if (dfs(i)) break;

           for (int j = 1; j <= n; j++) {

               if (vx[j]) lx[j] -= lack;

               if (vy[j]) ly[j] += lack;

           }

       }

}

\(O(n^3)\) 的做法

其实是可以实现 \(O(n^3)\) 的，

我们给每个 \(Y\) 顶点一个松弛量 \(\text{slack}\) ，初始为正无穷
对于每条边 \((i, j)\)，若不在相等字图中，\(\text{slack}_j=\min(A_i+B_j-w_{i,j})\)
修改顶标时 \(d\) 取所有不在交错树中的 \(Y\) 部点的 \(\text{slack}\) 的最小值
修改完后，所有不在交错树中的 \(Y\) 部点的 \(\text{slack}\) 都减去 \(d\)

int slk[N], pre[N], mat[N];

// mat 等同于 cy

inline void bfs(int st) {

    memset(pre, 0, sizeof(pre));

    for (int i = 1; i <= n; i++) slk[i] = 1e9;

    int x, y = 0, del, pos;

    mat[y] = st;

    do {

        x = mat[y], vy[y] = 1, del = 1e9;

        for (int i = 1; i <= n; i++) {

            if (vy[i]) continue;

            if (slk[i] > lx[x] + ly[i] - mp[x][i])

                slk[i] = lx[x] + ly[i] - mp[x][i], pre[i] = y;

            if (slk[i] < del) del = slk[i], pos = i;

        }

        for (int i = 0 ; i <= n; i++) {

            if (vy[i]) lx[mat[i]] -= del, ly[i] += del;

            else slk[i] -= del;

        }

        y = pos;

    } while (mat[y]);

    while (y) mat[y] = mat[pre[y]], y = pre[y];

}

inline void KM() {

    memset(mat, 0, sizeof(mat));

    memset(lx, 0, sizeof(lx));

    memset(ly, 0, sizeof(ly));

    for (int i = 1; i <= n; i++) {

        memset(vy, 0, sizeof(vy));

        bfs(i);

    }

}

答案

for (int i = 1; i <= n; i++) {

    if (mp[mat[i]][i]==-1e9 || !mat[i]) {

        puts("-1");

        break;

    }

    ans += mp[mat[i]][i];

}

End