@bzoj - 4951@ [Wf2017]Money for Nothing

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

@description@

在这道题种你需要解决一个全世界人类从存在起就在面临的最深刻的问题--如何发大财。

你是一名零件交易市场的中介。你的工作是从零件生产公司那里买到零件,然后把它们卖给零件消费公司。

每个零件消费公司在截止日期前每天都会对一个零件有一个开放式的需求,以及它愿意买下零件的价格。另一方面,每个零件生产公司在开始日期及以后都可以销售零件,以及它销售零件的价格。基于公平竞争法,你只能与一家生产公司、一家消费公司签订合同。

你可以在生产公司开始销售后每天从生产公司买一个零件,当然这也要在消费公司结束需求之前。

在这些天里,每天你可以从买卖差价中获取利润。你的任务是选择能使你利益最大化的生产公司与消费公司。

1≤m,n≤500 000

原题戳这里0.0。

@solution@

实际上就是求 max{(qj - pi)*(ej - di) | ej > di}。

将 (qj, ej) 与 (pi, di) 都看成二维平面中的点，则相当于求以 (qj, ej) 为右上角，(pi, di) 为左下角的最大矩形面积。

注意到当 qk <= qj 且 ek <= ej 时，(qj, ej) 比 (qk, ek) 更容易合法且在更优，此时 k 就没有用了。

同理，当 pi <= pk 且 di <= dk 时，(pi, di) 比 (pk, dk) 一定更好。

所以最终两个序列的有用点一定是横坐标单增的同时纵坐标单减。

不会做了。于是考虑决策单调性。手推了一下式子发现的确有决策单调性（这里就不推了，挺好推的）。

然而。。。如果仅仅这样就结束了我才不会写这篇博客作为教训。。。

注意到每个点 (qj, ej) 的决策是有范围：对应的 i 要满足 pi < qj, di < ej。否则决策单调性的式子就推不出来了（？应该是吧，因为有点久了所以不是很确定）。

而这些 i 构成了一个区间 [le(j), ri(j)]，其中 le(j) 的纵坐标 < ej 且最小，ri(j) 的横坐标 < pi 且最大。

而假如你像我一样采用分治法，那么就会遇到一个问题：有可能当前分治的决策点区间 [opl, opr] 与我们 mid 的决策范围没有交集。。。

而这又有几种情况：一种是 le(mid) > ri(mid)，即 mid 本身没有决策的点。此时分治 [opl, ri(mid)] 与 [le(mid), opr]，可以保证时间复杂度与正确性。

另外两种其实是类似的，一种是 le(mid) > opr，此时把 [opl, opr] 传给 [l, mid-1] 即可；还有一种是 ri(mid) < opl，反过来传给右边的 [mid, r] 即可。

@accepted code@

#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 500000;
typedef long long ll;
struct node{
	int x, y;
	node(int _x=0, int _y=0) : x(_x), y(_y) {}
	friend bool operator < (node a, node b) {
		return (a.x == b.x) ? a.y < b.y : a.x < b.x;
	}
}t[MAXN + 5], a[MAXN + 5], b[MAXN + 5];
ll ans;
int le[MAXN + 5], ri[MAXN + 5];
void solve(int opl, int opr, int l, int r) {
	if( l > r ) return ;
	int m = (l + r) >> 1, opm = opl;
	if( ri[m] < opl ) solve(opl, opr, m + 1, r);
	else if( le[m] > opr ) solve(opl, opr, l, m - 1);
	else if( le[m] > ri[m] ) {
		solve(opl, ri[m], l, m - 1);
		solve(le[m], opr, m + 1, r);
	}
	else {
		ll res = -1;
		for(int i=opl;i<=opr;i++) {
			ll t = 1LL*(b[m].x - a[i].x)*(b[m].y - a[i].y);
			if( b[m].x >= a[i].x && b[m].y >= a[i].y && t >= res )
				opm = i, res = t;
		}
		ans = max(ans, res);
		solve(opl, opm, l, m - 1);
		solve(opm, opr, m + 1, r);
	}
}
int m, n, ca, cb;
int main() {
	scanf("%d%d", &m, &n);
	for(int i=1;i<=m;i++) {
		int p, d; scanf("%d%d", &p, &d);
		t[i] = node(p, d);
	}
	sort(t + 1, t + m + 1);
	for(int i=1;i<=m;i++) {
		if( !ca || !(t[i].x >= a[ca].x && t[i].y >= a[ca].y) )
			a[++ca] = t[i];
	}
	for(int i=1;i<=n;i++) {
		int q, e; scanf("%d%d", &q, &e);
		t[i] = node(q, e);
	}
	sort(t + 1, t + n + 1);
	for(int i=1;i<=n;i++) {
		while( cb && t[i].x >= b[cb].x && t[i].y >= b[cb].y )
			cb--;
		b[++cb] = t[i];
	}
	le[0] = 1, ri[0] = 0;
	for(int i=1;i<=n;i++) {
		le[i] = le[i-1], ri[i] = ri[i-1];
		while( le[i] <= m && a[le[i]].y > b[i].y ) le[i]++;
		while( ri[i] < m && a[ri[i]+1].x <= b[i].x )
			ri[i]++;
	}
	solve(1, ca, 1, cb);
	printf("%lld\n", ans);
}

@details@

比较详细的细节都在 solution 里面说啦。