[ABC342G] Retroactive Range Chmax

题目传送门

题面翻译

维护一个数列，有以下三个操作：

1. 区间最值操作，即将 $[l,r]$ 区间内的 $A_i$ 变成 $\max (A_i,v)$。

2. 删除操作操作，即将第 $i$ 次操作删除，保证第 $i$ 次操作是操作 $1$，且未被删除。注：仅删除第 $i$ 次操作，后续操作仍然在。

3. 查询，询问当前的 $A_i$。

样例 #1

样例输入 #1

6
2 7 1 8 2 8
15
3 1
3 3
3 4
1 1 5 4
3 1
3 3
3 4
1 3 6 9
3 1
3 3
3 4
2 4
3 1
3 3
3 4

样例输出 #1

2
1
8
4
4
8
4
9
9
2
9
9

样例 #2

样例输入 #2

24
721 78 541 256 970 478 370 467 344 542 43 166 619 17 592 222 983 729 338 747 62 452 815 838
35
3 10
3 8
3 8
3 13
3 9
1 1 17 251
3 3
3 19
3 13
3 22
3 1
3 15
3 18
3 10
3 15
1 16 19 883
1 8 23 212
3 5
3 13
2 6
3 15
1 5 18 914
2 17
3 20
1 23 23 56
3 13
2 25
3 13
3 13
3 10
2 16
1 17 22 308
3 19
3 17
3 7

样例输出 #2

542
467
467
619
344
541
338
619
452
721
592
729
542
592
970
619
592
747
914
914
914
914
338
983
914

思路

首先我们可以发现对于每个节点的值只会变大或者保持，即具有单调性，那么我们可以在线段树的每个节点维护一个multiset不论是否替换我们都将值插入，每次查询只要输出set的末值即可，由此思路我们可以写出一发

暴力版本：

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const ll N = 2e5 + 10;
ll n, m, k, T;
ll num, idx;
ll a[N];
struct node {
    multiset<ll> se, add;
} tr[N << 2];
struct nodex {
    ll l, r, val;
} b[N];

void updown(ll root) {
    if (tr[root].add.size()) {
        tr[root << 1].add.insert(tr[root].add.begin(), tr[root].add.end());
        tr[root << 1 | 1].add.insert(tr[root].add.begin(), tr[root].add.end());
        tr[root << 1].se.insert(tr[root].add.begin(), tr[root].add.end());
        tr[root << 1 | 1].se.insert(tr[root].add.begin(), tr[root].add.end());
        tr[root].add.clear();
    }
}

void update(ll root) {
    tr[root].se = tr[root << 1].se;
    tr[root].se.insert(tr[root << 1 | 1].se.begin(), tr[root << 1 | 1].se.end());
}

void build(ll root, ll l, ll r) {
    if (l == r) {
        tr[root].se.insert(a[l]);
        return;
    }
    ll mid = (l + r) >> 1;
    build(root << 1, l, mid);
    build(root << 1 | 1, mid + 1, r);
    update(root);
}

ll query(ll root, ll l, ll r, ll L, ll R) {
    if (L <= l && r <= R) {
        return *tr[root].se.rbegin();
    }
    ll mid = (l + r) >> 1;
    updown(root);
    ll res = 0;
    if (L <= mid)res = query(root << 1, l, mid, L, R);
    if (mid < R)res += query(root << 1 | 1, mid + 1, r, L, R);
    return res;
}

void modify(ll root, ll l, ll r, ll L, ll R, ll val) {
    if (L <= l && r <= R) {
        tr[root].se.insert(val);
        tr[root].add.insert(val);
        return;
    }
    ll mid = (l + r) >> 1;
    updown(root);
    if (L <= mid)modify(root << 1, l, mid, L, R, val);
    if (mid < R)modify(root << 1 | 1, mid + 1, r, L, R, val);
    update(root);
}

void cut_off(ll root, ll l, ll r, ll L, ll R, ll val) {
    if (l == r) {
        tr[root].se.erase(*tr[root].se.find(val));
        return;
    }
    ll mid = (l + r) >> 1;
    updown(root);
    if (L <= mid)modify(root << 1, l, mid, L, R, val);
    if (mid < R)modify(root << 1 | 1, mid + 1, r, L, R, val);
    update(root);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cin >> n;
    for (ll i = 1; i <= n; i++)cin >> a[i];
    build(1, 1, n);
    cin >> m;
    for (ll i = 1; i <= m; i++) {
        ll op, x;
        cin >> op;
        if (op == 1) {
            ll l, r;
            cin >> l >> r >> x;
            b[i] = {l, r, x};
            modify(1, 1, n, l, r, x);
        } else if (op == 2) {
            cin >> x;
            cut_off(1, 1, n, b[x].l, b[x].r, b[x].val);
        } else {
            cin >> x;
            cout << query(1, 1, n, x, x) << '\n';
        }
    }
}

优化

但是对于1e5的数据范围我们为每个节点维护一个multiset复杂度爆炸，后来观摩了一位大佬的写法，发现我们没必要将每个区间所拥有的值跑存满，我们只需要当前区间的最大值即可，于是就有了优化版本

#include<bits/stdc++.h>

#define IOS ios::sync_with_stdio(false);cin.tie(0), cout.tie(0);
using namespace std;
typedef long long ll;
const ll N = 2e5 + 10;
ll n, m;
ll a[N];
multiset<ll> tr[N << 2];
struct node {
    ll l, r, val;
} b[N];


void build(ll root, ll l, ll r) {
    if (l == r) {
        tr[root].insert(a[l]);
        return;
    }
    ll mid = (l + r) >> 1;
    build(root << 1, l, mid);
    build(root << 1 | 1, mid + 1, r);
}

ll query(ll root, ll l, ll r, ll pos) {
    if (l == r) {
        return *tr[root].rbegin();
    }
    ll mid = (l + r) >> 1;
    ll res = tr[root].empty() ? 0 : *tr[root].rbegin(); // 我们记录每个我们跑的区间的最大值，不断比较，最终值就是答案
    if (pos <= mid)res = max(res, query(root << 1, l, mid, pos));
    else res = max(res, query(root << 1 | 1, mid + 1, r, pos));
    return res;
}

void modify(ll root, ll l, ll r, ll L, ll R, ll val, ll op) {
    if (L <= l && r <= R) {
        if (op)tr[root].insert(val);
        else tr[root].extract(val);//由于我们优化掉了pushup的操作，所以我们当前节点可能并没有val的值，用erase会出错
        //因为删除和插入的操作的区间都是同一个区间，所以我们完全可以优化掉pushup
        return;
    }
    ll mid = (l + r) >> 1;
    if (L <= mid)modify(root << 1, l, mid, L, R, val, op);
    if (mid < R)modify(root << 1 | 1, mid + 1, r, L, R, val, op);
}

int main() {
    IOS
    cin >> n;
    for (ll i = 1; i <= n; i++)cin >> a[i];
    build(1, 1, n);
    cin >> m;
    for (ll i = 1; i <= m; i++) {
        ll op, x;
        cin >> op;
        if (op == 1) {
            ll l, r;
            cin >> l >> r >> x;
            b[i] = {l, r, x};
            modify(1, 1, n, l, r, x, 1);
        } else if (op == 2) {
            cin >> x;
            modify(1, 1, n, b[x].l, b[x].r, b[x].val, 0);
        } else {
            cin >> x;
            cout << query(1, 1, n, x) << '\n';
        }
    }
}