题目链接: Physical Education Lessons
大致题意
给定一个长度为 n n n的 01 01 01序列, 有两种操作: 把区间 [ l , r ] [l, r] [l,r]全部变为 1 1 1, 或把区间 [ l , r ] [l, r] [l,r]全部变为 0 0 0.
每次操作结束后, 输出序列中 1 1 1的个数.
解题思路
➡️题目弱化版推荐⬅️
➡️珂朵莉树做法题解⬅️
线段树
我们考虑到如果 n n n比较小(在 1 0 6 10^6 106以内), 我们可以直接用线段树暴力维护区间信息.
但是本题的 n n n很大(有 1 0 9 10^9 109), 我们没法通过堆存储的方式用静态开点线段树来维护. 但是考虑到操作 m m m比较小, 只有 3 ⋅ 1 0 5 3·10^5 3⋅105, 因此涉及到的点个数至多为 2 m 2m 2m. 我们可以采用动态开点的线段树来维护.
但是我们还有一种更节省空间的方式 — 把用到的所有点进行离散化. 但是这样离散化后, 会使得原本不连续的点变得连续, 我们需要再额外插入一些有权值的点, 使得这些点仍然保持不连续.
例如: 如果现在用到的端点有3和7, 离散化后就变成了1和2, 但本身3和7是不挨着的(中间还有4, 5, 6). 但是离散化后, 1和2是挨着的(4, 5, 6这三个点被错误的丢弃了).
因此我们正确的做法是, 在3和7两个点之间再插入一个带有权值的点4, 权值为3(表示4, 5, 6这三个点).
为了便于叙述, 我们不妨把所有的点都看作一个点对 ( x , y ) (x, y) (x,y), 其中 x x x为点所处的位置, y y y为这个点的点权, 即表示这个点一共代表了多少个点.
如上述的3和7离散化后, 应该为 ( 1 , 1 ) , ( 2 , 3 ) , ( 3 , 1 ) (1, 1), \ (2, 3), \ (3, 1) (1,1), (2,3), (3,1).
我们发现, 通过这种离散化方式, 至多会额外产生一倍的点数.
因此线段树内维护的点个数至多为 4 m 4m 4m. 又因线段树需要开 4 4 4倍空间, 因此我们需要的空间为 16 m 16m 16m.
考虑如何用线段树维护序列:
由于每次是把一个区间全部变为 0 0 0或 1 1 1, 这相当于是一次区间修改. 我们可以通过在树外处理出前缀和数组的方式, 来节约空间.
对于查询整个 01 01 01序列的 1 1 1的个数, 就是线段树的根节点查询.
AC代码
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 3E5 + 10;
vector<int> v(1, -0x3f3f3f3f);
int find(int x) {
return lower_bound(v.begin(), v.end(), x) - v.begin(); }
int s[N * 4];
struct query {
int tp, l, r; }; vector<query> area;
struct node {
int l, r;
int val;
int lazy;
}t[N << 4];
void pushdown(node& op, int lazy) {
op.val = lazy * (s[op.r] - s[op.l - 1]);
op.lazy = lazy;
}
void pushdown(int x) {
if (t[x].lazy == -1) return;
pushdown(t[x << 1], t[x].lazy), pushdown(t[x << 1 | 1], t[x].lazy);
t[x].lazy = -1;
}
void pushup(int x) {
t[x].val = t[x << 1].val + t[x << 1 | 1].val; }
void build(int l, int r, int x = 1) {
t[x] = {
l, r, s[r] - s[l - 1], -1 };
if (l == r) return;
int mid = l + r >> 1;
build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
}
void modify(int l, int r, int c, int x = 1) {
if (l <= t[x].l and r >= t[x].r) {
pushdown(t[x], c);
return;
}
pushdown(x);
int mid = t[x].l + t[x].r >> 1;
if (l <= mid) modify(l, r, c, x << 1);
if (r > mid) modify(l, r, c, x << 1 | 1);
pushup(x);
}
int main()
{
int n, m; cin >> n >> m;
rep(i, m) {
int l, r, tp; scanf("%d %d %d", &l, &r, &tp);
area.push_back({
tp, l, r });
v.push_back(l), v.push_back(r);
}
v.push_back(1), v.push_back(n); // 本题需要离散化整个[1, n]区间
sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end());
int last = 0;
int len = v.size();
rep(i, len - 1) {
int l = last + 1, r = v[i] - 1;
if (l <= r) v.push_back(l);
last = v[i];
}
sort(v.begin(), v.end());
len = v.size(); // [1, len - 1]
for (int i = 1; i < len - 1; ++i) s[i] = v[i + 1] - v[i];
s[len - 1] = 1; // 右端点n
rep(i, len - 1) s[i] += s[i - 1];
assert(s[len - 1] == n);
build(1, len - 1);
for (auto& [tp, l, r] : area) {
l = find(l), r = find(r);
modify(l, r, tp - 1);
printf("%d\n", t[1].val);
}
return 0;
}