2021CCPC浙江省赛 B - Restore Atlantis

是一道比较神仙的数据结构（我自己肯定想不出来）

这个查询其实是比较难处理的，对于一段询问区间[l, r]，每一个矩形和其他的都是可能相互联系的

但是可以注意到区间的范围非常小，是[0, 2000]之间，所以可以考虑对每一个1×1大小的方格进行处理，可以发现方格的数量是2000*2000个，是一个可以接受的范围，那么我们现在来考虑对于每次询问的[l, r]，每个小方格是否存在一个不在[l, r]的区间的矩形能包含它。

由于每次询问的区间都是连续的，所以只有当前这个询问区间完全包含所有出现了这个小方格的矩形的时候，这个小方格不被任何一个矩形包含，所以我们只需要知道每个小方格出现在的矩形中编号最小的和编号最大的就可以了。

求解这个的部分可以用扫描线+线段树维护优先队列解决，对于所有矩形，扫描线按照x从小到大扫，对每一个矩形的左边，区间修改（就是往优先队列里丢这个编号），如果扫到了矩形的右边，就打上标记。

然后查询所有的点，得到答案，其实在这里，这个优先队列相当于lazy标记，所以在查询的时候需要下传，而我们之所以要用一个优先队列就是为了把打上标记的点去掉，所以取出数的时候要找到第一个没有标记的点。

现在我们得到了每个点的最小出现编号和最大出现编号，问题就又转换成了给定\(C^2\)条线段，每次询问\([l, r]\)，求多少个线段不被\([l, r]\)完全包含。

这个方法就比较多了，在线的话可以用什么分块，线段树，主席树来维护，当然这道题是离线，所以可以用扫描线+树状数组简单维护，大概就是先按照y的坐标排序，然后按照从小到大把x加进树状数组里，加的过程中顺便算出来每个区间的答案

代码参考了一下claris，写的太优雅了%%%

#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
bool vis[N];
struct node {
	int x, y1, y2, id, flag;
	inline bool operator < (const node & o) const {
		return x < o.x;
	}
}v[N << 1];
priority_queue < int > maxn[N], minn[N];
void update(int o, int l, int r, int L, int R, int x) {
	if (r < L || l > R)	return;
	if (L <= l && r <= R) {
		maxn[o].push(x);
		minn[o].push(-x);
		return ;
	}
	int mid = (l + r) >> 1;
	update(o << 1, l, mid, L, R, x);
	update(o << 1 | 1, mid + 1, r, L, R, x);
}
vector < pair<int, int> > seg;
int tot;
void query(int o, int l, int r, int x, int y) {
	while (!maxn[o].empty() && vis[maxn[o].top()])	maxn[o].pop();
	while (!minn[o].empty() && vis[-minn[o].top()])	minn[o].pop();
	if (!maxn[o].empty())	x = max(x, maxn[o].top()), y = max(y, minn[o].top());
	if (l == r) {
		if (x) seg.emplace_back(x, -y), tot++;
		return ;
	}
	int mid = (l + r) >> 1;
	query(o << 1, l, mid, x, y);
	query(o << 1 | 1, mid + 1, r, x, y);
}
int n, q, c[N];
inline int lowbit(int x) { return x & (-x); }
inline void add(int x) { while (x <= n) {c[x]++; x += lowbit(x);} }
inline int get(int x) { int ans = 0; while (x) { ans += c[x]; x -= lowbit(x);} return ans; }
vector < tuple<int, int, int> > qs;
int ans[N];
int main() {
	scanf("%d%d", &n, &q);
	for (int i = 1; i <= n; i++) {
		int xa, ya, xb, yb;
		scanf("%d%d%d%d", &xa, &ya, &xb, &yb);
		xa++; ya++; xb++; yb++;
		v[i] = node{xa, ya, yb, i, 1};
		v[i + n] = node{xb, ya, yb, i, -1};
	}
	sort(v + 1, v + 2 * n + 1);
	int p = 1;
	for (int i = 1; i <= 2000; i++) {
		while (v[p].x == i) {
			if (v[p].flag == 1) 
				update(1, 1, 2000, v[p].y1, v[p].y2 - 1, v[p].id);
			else	vis[v[p].id] = true;
			p++;
		}
		query(1, 1, 2000, 0, -n);
	}
	sort(seg.begin(), seg.end());
	for (int i = 1; i <= q; i++) {
		int x, y;
		scanf("%d%d", &x, &y);
		qs.emplace_back(y, x, i);
	}
	sort(qs.begin(), qs.end());
	int cnt = 0; p = 0;
	for (auto [y, x, id]:qs) {
		while (seg[p].first <= y && p < tot)	add(seg[p++].second), cnt++;
		ans[id] = tot - cnt + get(x - 1);
	}
	for (int i = 1; i <= q; i++)	printf("%d\n", ans[i]);
	return 0;
}