@noi.ac - 507@ 二分图最大权匹配
@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(玄学)，不过完全图应该跑不快。。。
