@noi.ac - 507@ 二分图最大权匹配

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

有一天你学了一个能解决二分图最大权匹配的算法，你决定将这个算法应用到NOI比赛中。

给定一张完全二分图。在这张图里，两个部分的的大小均为 n。对于第一部分的点 u 和第二部分的点 v ，连接它们的边的权值为 \(c_{uv}+k_{uv}x\)，其中 x 为一个值不确定的变量。

你将被多次给定 x 的值，对于每一个 x 的值，你需要回答对应的二分完全图的最大权匹配的总权值。

input

第一行一个数n，含义如题所述。

接下来 n 行，每行 n 个整数，其中第 i 行的第 j 个数为 cij 的值。

接下来nn行，每行nn个整数，其中第 i 行的第 j 个数为 kij 的值。

接下来一个数 q，表示给定的 x 的值的数量。

接下来 q 行，每行一个整数表示给定的 x 的值。

output

输出 q 行，每行一个数，其中第 i 行表示对应于第 i 个 x 的值的答案。

sample input

3

0 0 2

0 2 0

2 0 0

0 1 0

1 1 0

0 0 1

3

0

1

3

sample output

6

7

9

explanation

对于 x=0，最大匹配为 0→2,1→1,2→0，答案为 2+2+2=6。

对于 x=1，最大匹配仍然为 0→2,1→1,2→0，由于只有 \(k_{11}=1\)而另外两条边的 k 为零，只有第二条边的边权有变化，为 3。答案为2+3+2=7。

对于 x=3，最大匹配变为 0→1,1→0,2→2，因为这三条边的 k 值均为1，边权均变成了3。答案为 3+3+3=9。

对于100%的数据，1≤n≤50,1≤q≤100000,0≤cij≤10^7,0≤kij≤1，给定的 x 的值为在 0 到 10^7 之间的整数。

@solution@

不难发现答案一定形如 K*x + C 的形式。因为匹配最多 n 条边，所以 1<=K<=n。

进一步发现，每一个 K 唯一对应一个 C。这意味着答案的变化只会存在 n 种可能性。

我们只需要找出这 n 种可能性，再对于每一个询问找该询问对应哪一种可能性即可。

直观上可以发现（同时也不难使用反证法证明），当 x 越大时，最优解对应的 K 一定随之增大。

这意味着每一种 K 对应的 x 总是一段连续的区间，于是我们可以通过二分 x 的值找到每一种 K 对应的区间。

考虑求解最大权匹配时使用 KM 算法 O(n^3) 求解，我们的预处理时间复杂度 O(n^4*log(A))，其中 A = 10^7 是一个常数。

而询问只需要遍历 n 种可能性，故询问总时间复杂度为 O(nq)。

只要你的 KM 算法写的真的是 O(n^3)（可以去 uoj#80 测一测）而不是 O(n^4) 就可以过。

其实真正用得到的 x 只有 q 次询问中的 x。我们可以将询问排序后在询问上二分，就可以将时间复杂度将至 O(n^4*log(q))

但我懒得写这个优化。

@accepted code@

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int INF = 1<<30;
int c[50 + 5][50 + 5], k[50 + 5][50 + 5], K, X, C;
int f(int x, int y) {return k[x][y]*X + c[x][y];}
int lx[50 + 5], ly[50 + 5], lk[50 + 5], slk[50 + 5];
bool vx[50 + 5], vy[50 + 5];
int n, q;
bool dfs(int x) {
	vx[x] = true;
	for(int y=1;y<=n;y++) {
		if( vy[y] ) continue;
		int t = lx[x] + ly[y] - f(x, y);
		if( t == 0 ) {
			vy[y] = true;
			if( (!lk[y]) || dfs(lk[y]) ) {
				lk[y] = x;
				return true;
			}
		}
		else slk[y] = min(slk[y], t);
	}
	return false;
}
void KM(int p) {
	X = p;
	for(int i=1;i<=n;i++) {
		lx[i] = ly[i] = lk[i] = 0;
		for(int j=1;j<=n;j++)
			lx[i] = max(lx[i], f(i, j));
	}
	for(int x=1;x<=n;x++) {
		for(int i=1;i<=n;i++)
			vx[i] = vy[i] = false, slk[i] = INF;
		if( !dfs(x) ) {
			while( true ) {
				int del = INF, y = 0;
				for(int i=1;i<=n;i++)
					if( !vy[i] ) del = min(del, slk[i]);
				for(int i=1;i<=n;i++) {
					if( vx[i] ) lx[i] -= del;
					if( vy[i] ) ly[i] += del;
				}
				for(int i=1;i<=n;i++)
					if( !vy[i] ) {
						slk[i] -= del;
						if( slk[i] == 0 )
							y = i;
					}
				if( !lk[y] ) break;
				vx[lk[y]] = vy[y] = true;
				for(int i=1;i<=n;i++)
					slk[i] = min(slk[i], lx[lk[y]] + ly[i] - f(lk[y], i));
			}
			for(int i=1;i<=n;i++)
				vx[i] = vy[i] = false;
			dfs(x);
		}
	}
	K = C = 0;
	for(int i=1;i<=n;i++)
		K += k[lk[i]][i], C += c[lk[i]][i];
}
struct node{
	int k, c, l, r;
	node(int _k=0, int _c=0, int _l=0, int _r=0):k(_k), c(_c), l(_l), r(_r){}
};
vector<node>vec;
int pk, pc;
int solve(int l, int r) {
	while( l < r ) {
		int mid = (l + r + 1) >> 1; KM(mid);
		if( pk == K ) l = mid;
		else r = mid - 1;
	}
	return l;
}
int main() {
	scanf("%d", &n);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			scanf("%d", &c[i][j]);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			scanf("%d", &k[i][j]);
	int le = 0, ri = int(1E7);
	while( le <= ri ) {
		KM(le); pk = K, pc = C;
		int res = solve(le, ri);
		vec.push_back(node(pk, pc, le, res));
		le = res + 1;
	}
	scanf("%d", &q);
	for(int i=1;i<=q;i++) {
		int x; scanf("%d", &x);
		for(int j=0;j<vec.size();j++)
			if( vec[j].l <= x && x <= vec[j].r )
				printf("%d\n", vec[j].k*x + vec[j].c);
	}
}

@details@

本身来说这道题难度不大，只是需要想到一开始 K*x + C 中 K 的取值只有 n 种。

另外网上百度出来的 KM 算法大多都是假的 O(n^3)（包括百度百科），如果真的想找 O(n^3) 的代码可以去搜 uoj#80 的题解。

其实我也不知道把 KM 算法换成费用流能不能过。虽然费用流的复杂度是 O(玄学)，不过完全图应该跑不快。。。