[CF1523G]Try Booking

题目

传送门 to CF

题目概要
有 $m$ 个订单 $[l_i,r_i]$，表示在第 $l_i$ 天到第 $r_i$ 天摸鱼。你准备采用这样的策略：只保留 $r_i-l_i+1\ge x_0$ 的订单，然后 依次 考虑它们：如果这个订单与之间已经确定的订单不冲突（即，第 $l_i$ 到第 $r_i$ 天你不准备摸鱼），那么你就接受这个订单，在第 $l_i$ 天到第 $r_i$ 天摸鱼。

对于每个 $x_0\in [1,n]$，请求出摸鱼的天数。

数据范围与提示
$m\le 10^5$ 且 $1\le l_i\le r_i\le n\le 5\times 10^4$ 。

思路

从来没有见到过三个$\sout{log}$的复杂度。

这个题，无论从什么角度考察，都很困难。$x$ 的变化可以引起很多订单的变化：$A$ 订单成功，于是 $B$ 订单失败，然后 $C$ 订单又成功……会引起很多订单的状态翻转。

而一个房间（或者一个区间）是否成功，关于 $x$ 也自然不连续。那么直接关于每个 $x$ 考察某个区间就很难进行。而直接考虑 $x$ 来研究方案可不可以呢？

想想，如果 $x$ 只是随便代表了某种 “后缀关系”，即 $x$ 的考虑区间是 $x-1$ 的子集，那么并不需要长度作为关键字，可以另设一个属性。不排除出题人别有用心。所以，这个长度应该是比较有用的。有什么用呢？

答案是长度至少为 $x$ 时，最多选 $\lfloor \frac{n}{x}\rfloor$ 个订单。所以对于所有 $x$ 只会有 $\mathcal{O}(n\ln n)$ 个订单。考虑怎么找到它们就行了。

考虑递归。先找到 $[L,R]$ 内的一个时间戳最小的订单，它会把区间割裂，然后递归寻找。所以我们只需要找一个 $L\le l\le r\le R$ 。

这就是二维偏序。不过需要动态做，所以树套树吧。时间复杂度 $\mathcal{O}(n{\log }^{3}n+m{\log }^{2}n)$ 。

代码

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <bitset>
using namespace std;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
typedef long long int_;
inline int readint(){
	int a = 0; char c = getchar(), f = 1;
	for(; c<'0'||c>'9'; c=getchar())
		if(c == '-') f = -f;
	for(; '0'<=c&&c<='9'; c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}

const int MaxN = 100005;

struct Range{
	int l, r, id;
	int len() const { return r-l+1; }
	bool operator < (const Range &t) const {
		return id < t.id;
	}
};
Range node[MaxN];

int n; // length of Segment Tree
namespace SgTree{
	const int MaxM = 40000000;
	int v[MaxM], ch[MaxM][2], cntNode;
	# define merge(l,r) (node[l]<node[r]?(l):(r))
	int query(int ql,int qr,int o,int l=1,int r=n){
		if(!o || qr < l || r < ql) return 0;
		if(ql <= l && r <= qr) return v[o];
		int lson = query(ql,qr,ch[o][0],l,(l+r)>>1);
		int rson = query(ql,qr,ch[o][1],(l+r)/2+1,r);
		return merge(lson,rson);
	}
	void modify(int qid,int qv,int &o,int l=1,int r=n){
		if(!o) o = ++ cntNode;
		v[o] = merge(v[o],qv);
		if(l == r) return ;
		if(qid <= (l+r)/2) // recurse to L
			modify(qid,qv,ch[o][0],l,(l+r)>>1);
		else modify(qid,qv,ch[o][1],(l+r)/2+1,r);
	}
};
namespace XJX{
	int rt[MaxN<<1|1];
	# define __id(l,r) (((l)+(r))|((l)!=(r)))
	void modify(int ql,int qr,int qv,int l=1,int r=n){
		SgTree::modify(qr,qv,rt[__id(l,r)]);
		if(l == r) return ;
		if(ql <= (l+r)>>1)
			modify(ql,qr,qv,l,(l+r)>>1);
		else modify(ql,qr,qv,(l+r)/2+1,r);
	}
	int query(int ql,int qr,int l=1,int r=n){
		if(ql <= l && r <= qr)
			return SgTree::query(ql,qr,rt[__id(l,r)]);
		if(qr < l || r < ql) return 0;
		int lson = query(ql,qr,l,(l+r)>>1);
		int rson = query(ql,qr,(l+r)/2+1,r);
		return merge(lson,rson);
	}
}

int solve(int l,int r){
	if(l > r) return 0;
	int id = XJX::query(l,r);
	if(!id) return 0;
	return node[id].len()
		+ solve(l,node[id].l-1)
		+ solve(node[id].r+1,r);
}

bool cmp(const Range &a,const Range &b){
	return a.len() > b.len();
}
int ans[MaxN];
int main(){
	n = readint(); int m = readint();
	for(int i=1; i<=m; ++i){
		node[i].l = readint();
		node[i].r = readint();
		node[i].id = i;
	}
	sort(node+1,node+m+1,cmp);
	node[0].id = m+1; // infty
	for(int i=n,p=1; i>=1; --i){
		for(; p<=m&&node[p].len()==i; ++p)
			XJX::modify(node[p].l,node[p].r,p);
		ans[i] = solve(1,n);
	}
	rep(i,1,n) printf("%d\n",ans[i]);
	return 0;
}

后记

由于 ${\log }^{3}n$ 实在气人，我准备写 ${\log }^{2}n$ 的。考虑把序列分块，块长度为 $i$，那么每个块内最多一个 “左端点”，最多一个 “右端点”，直接找时间戳最小的那一个。

然而这是不对的。因为 $A,B$ 即使相交，并且 $B$ 时间戳更大，但是 $A$ 可能因为前面某个区间的制约而无法选择，也就无法约束 $B$ 了。我不应该怀疑官方题解不优秀的。