@atcoder - AGC034D@ Manhattan Max Matching

目录

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

---

@description@

考虑一个二维平面，执行共 2*N 次操作：

前 N 次，第 i 次在 (rx, ry) 处放置 rc 个红色球；

后 N 次，第 i 次在 (bx, by) 处放置 bc 个蓝色球。

保证放置的红色球总数 = 放置的蓝色球总数。

请将这些球两两配对，使得所有配对中 (bx, by) 与 (rx, ry) 的 |rx - bx| + |ry - by| 之和最大。

Constraints

1≤N≤1000, 0≤RXi,RYi,BXi,BYi≤10^9, 1≤RCi,BCi≤10

∑RCi=∑BCi

Input

输入形式如下：

N

RX1 RY1 RC1

RX2 RY2 RC2

⋮

RXN RYN RCN

BX1 BY1 BC1

BX2 BY2 BC2

⋮

BXN BYN BCN

Output

输出配对后曼哈顿距离之和的最大值。

Sample Input 1

2

0 0 1

3 2 1

2 2 1

5 0 1

Sample Output 1

8

Sample Input 2

Copy

3

0 0 1

2 2 1

0 0 2

1 1 1

1 1 1

3 3 2

Sample Output 2

16

@solution@

假如不考虑数据范围，我们可以将所有红球与所有蓝球连边，边权为匹配的曼哈顿距离。

然后跑一个二分图的最大权完美匹配。

这看起来非常好，但是 N <= 1000，边建出来一共有 N^2 条，会炸。

我们考虑怎么才能优化建图。

注意我们为什么要建 N^2 条边：哈密顿距离中带有绝对值，使得边权由两点共同决定。

在最大化问题中，有一个去掉绝对值的常用方法（当然不是零点分段）：|x| = max{x, -x}。

这道题同理，|rx - bx| + |ry - by| 可以表示成以下几种情况的最大值：

(rx - bx) + (ry - by) = (+ rx + ry) + (- bx - by)

(rx - bx) + (by - ry) = (+ rx - ry) + (- bx + by)

(bx - rx) + (ry - by) = (- rx + ry) + (+ bx - by)

(bx - rx) + (by - ry) = (- rx - ry) + (+ bx + by)

这样的转化使得边权可以由两点分别的权之和决定，就可以拆开，不用再建 O(n^2) 条边了。

具体来说，我们先 s 向 N 个红球连容量为 rc，费用为 0 的边；再 N 个蓝球向 t 连容量为 bc，费用为 0 的边。

中间另建 4 个点，表示以上 4 种情况。N 个红球连过去 4 个点，4 个点连向 N 个蓝球，费用如上面所谈论的。

注意 N 个红球与 N 个蓝球要交错着连（正正 对应 负负）。

@accepted code@

#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int MAXV = 4000;
const int MAXE = 20000;
const int INF = (1<<30);
const ll LINF = (1LL<<60);
struct FlowGraph{
	struct edge{
		int to, cap, flow; ll dis;
		edge *nxt, *rev;
	}edges[MAXE + 5], *adj[MAXV + 5], *cur[MAXV + 5], *ecnt;
	FlowGraph() {ecnt = &edges[0];}
	int s, t;
	void addedge(int u, int v, int c, ll w) {
		edge *p = (++ecnt), *q = (++ecnt);
		p->to = v, p->cap = c, p->flow = 0, p->dis = -w;
		p->nxt = adj[u], adj[u] = p;
		q->to = u, q->cap = 0, q->flow = 0, q->dis = w;
		q->nxt = adj[v], adj[v] = q;
		p->rev = q, q->rev = p;
//		printf("%d %d %d %lld\n", u, v, c, w);
	}
	ll h[MAXV + 5], d[MAXV + 5], f[MAXV + 5];
	int hp[MAXV + 5];
	void update(int x, ll k) {
		f[x] = k;
		while( x ) {
			hp[x] = x;
			if( (x<<1) <= t && f[hp[x]] > f[hp[x<<1]] )
				hp[x] = hp[x<<1];
			if( (x<<1|1) <= t && f[hp[x]] > f[hp[x<<1|1]] )
				hp[x] = hp[x<<1|1];
			x >>= 1;
		}
	}
	bool relabel() {
		for(int i=s;i<=t;i++)
			h[i] += d[i], d[i] = f[i] = LINF, hp[i] = i, cur[i] = adj[i];
		update(s, d[s] = 0);
		while( f[hp[1]] != LINF ) {
			int x = hp[1]; update(x, LINF);
			for(edge *p=adj[x];p;p=p->nxt) {
				if( p->cap > p->flow ) {
					ll w = p->dis + h[x] - h[p->to];
					if( d[x] + w < d[p->to] )
						update(p->to, d[p->to] = d[x] + w);
				}
			}
		}
		return !(d[t] == LINF);
	}
	bool vis[MAXV + 5];
	int aug(int x, int tot) {
		if( x == t ) return tot;
		int sum = 0; vis[x] = true;
		for(edge *&p=cur[x];p;p=p->nxt) {
			ll w = p->dis + h[x] - h[p->to];
			if( !vis[p->to] && p->cap > p->flow && d[x] + w == d[p->to] ) {
				int del = aug(p->to, min(tot - sum, p->cap - p->flow));
				p->flow += del, p->rev->flow -= del, sum += del;
				if( sum == tot ) break;
			}
		}
		vis[x] = false;
		return sum;
	}
	ll min_cost_max_flow(int _s, int _t) {
		s = _s, t = _t; ll cost = 0;
		while( relabel() ) {
			int del = aug(s, INF);
			cost += (d[t] + h[t]) * del;
		}
		return -cost;
	}
}G;
int N, s, t;
int main() {
	scanf("%d", &N), s = 1, t = 2*N+6;
	for(int i=1;i<=N;i++) {
		int x, y, c; scanf("%d%d%d", &x, &y, &c);
		G.addedge(s, i+1, c, 0);
		G.addedge(i+1, 2*N+2, INF, + x + y);
		G.addedge(i+1, 2*N+3, INF, + x - y);
		G.addedge(i+1, 2*N+4, INF, - x + y);
		G.addedge(i+1, 2*N+5, INF, - x - y);
	}
	for(int i=1;i<=N;i++) {
		int x, y, c; scanf("%d%d%d", &x, &y, &c);
		G.addedge(i+N+1, t, c, 0);
		G.addedge(2*N+5, i+N+1, INF, + x + y);
		G.addedge(2*N+4, i+N+1, INF, + x - y);
		G.addedge(2*N+3, i+N+1, INF, - x + y);
		G.addedge(2*N+2, i+N+1, INF, - x - y);
	}
	printf("%lld\n", G.min_cost_max_flow(s, t));
}
/*
(+ rx + ry) + (- bx - by)
(+ rx - ry) + (- bx + by)
(- rx + ry) + (+ bx - by)
(- rx - ry) + (+ bx + by)
*/

@details@

为什么我会傻到以为图匹配是 NP 问题。。。

特别是这个图还是个二分图。。。

想了半天的贪心，然后不停地叉掉，然后继续贪。。。