Educational Codeforces Round 23 F. MEX Queries 线段树+离散化

原题链接：https://codeforces.ml/problemset/problem/817/F

题意

最开始有一个空集合和一个序列，有三种操作

1. l, r 将序列[l,r]之间的未出现数加入集合中，不重复
2. l, r 将序列[l,r]之间的出现数从集合中删除
3. l, r 将序列[l,r]之间未出现的数加入集合，并且将出现的数从集合中删除

分析

整个过程都可以用线段树来模拟：

1. 第一个操作实质就是将[l,r]区间覆盖成1，代表在集合中
2. 第二个操作实质就是将[l.r]区间覆盖成0，代表从集合中删除
3. 第三个操作实质就是翻转区间

接下来考虑这两个lazytag的顺序，如果当前是覆盖操作，那么就将翻转操作清空；如果当前是翻转操作，不需要对覆盖操作做任何变换即可。

最后考虑数据范围，l,r都很大，必然要离散化处理。同时还要处理1,l-1,r+1这些点，因为答案最终会落在·这些点上。

这题主要还是难在对题意的转化上。

Code

#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define re register
typedef long long ll;
typedef pair<ll, ll> PII;
const int N = 4e5 + 10, M = 1e6 + 5, INF = 0x3f3f3f3f;
const int MOD = 1e9+7;
struct node {
    int l, r;
    int rev, tag, sum;
}t[N<<2];
struct Query {
    ll opt, l, r;
}q[M];
void push_down(int u) {
    if (t[u].tag != -1) {
        t[u<<1].tag = t[u<<1|1].tag = t[u].tag;
        t[u<<1].rev = t[u<<1|1].rev = 0;
        t[u<<1].sum = (t[u<<1].r - t[u<<1].l + 1) * t[u].tag;
        t[u<<1|1].sum = (t[u<<1|1].r - t[u<<1|1].l + 1) * t[u].tag;
        t[u].tag = -1;
    }
    if (t[u].rev) {
        t[u<<1].rev ^= t[u].rev;
        t[u<<1|1].rev ^= t[u].rev;
        t[u<<1].sum = (t[u<<1].r - t[u<<1].l + 1 - t[u<<1].sum);
        t[u<<1|1].sum = (t[u<<1|1].r - t[u<<1|1].l + 1 - t[u<<1|1].sum);
        t[u].rev = 0;
    }
}
void push_up(int u) {
    t[u].sum = t[u<<1].sum + t[u<<1|1].sum;
}
void build(int u, int l, int r) {
    t[u].l = l, t[u].r = r, t[u].rev = 0, t[u].tag = -1;
    if (l == r) return;
    int mid = (l + r) >> 1;
    build(u<<1, l, mid);
    build(u<<1|1, mid+1, r);
    push_up(u);
}
void modify1(int u, int ql, int qr, int val) {
    if (ql <= t[u].l && qr >= t[u].r) {
        t[u].rev = 0;
        t[u].tag = val;
        t[u].sum = (t[u].r - t[u].l + 1) * val;
        return;
    }
    push_down(u);
    int mid = (t[u].l + t[u].r) >> 1;
    if (ql <= mid) modify1(u<<1, ql, qr, val);
    if (qr > mid) modify1(u<<1|1, ql, qr, val);
    push_up(u);
}
void modify2(int u, int ql, int qr, int val) {
    if (ql <= t[u].l && qr >= t[u].r) {
        t[u].rev ^= val;
        t[u].sum = (t[u].r - t[u].l + 1 - t[u].sum);
        return;
    }
    push_down(u);
    int mid = (t[u].l + t[u].r) >> 1;
    if (ql <= mid) modify2(u<<1, ql, qr, val);
    if (qr > mid) modify2(u<<1|1, ql, qr, val);
    push_up(u);
}
int query(int u) {
    if (t[u].l == t[u].r) return t[u].l;
    push_down(u);
    if (t[u<<1].sum != t[u<<1].r - t[u<<1].l + 1) return query(u<<1);
    else return query(u<<1|1);
}
int find(int u, int pos) {
    if (t[u].l == t[u].r) return t[u].sum;
    push_down(u);
    int mid = (t[u].l + t[u].r) >> 1;
    if (pos <= mid) return find(u<<1, pos);
    else return find(u<<1|1, pos);
}
vector<ll> ve;
void solve() {
    int n; cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> q[i].opt >> q[i].l >> q[i].r;
        ve.push_back(q[i].l);
        ve.push_back(q[i].r);
        ve.push_back(max(1ll, q[i].l-1));
        ve.push_back(q[i].r+1);
    }
    ve.push_back(1);
    sort(ve.begin(), ve.end());
    ve.erase(unique(ve.begin(), ve.end()), ve.end());
    for (int i = 1; i <= n; i++) {
        q[i].l = lower_bound(ve.begin(), ve.end(), q[i].l) - ve.begin() + 1;
        q[i].r = lower_bound(ve.begin(), ve.end(), q[i].r) - ve.begin() + 1;
    }
    build(1, 1, ve.size());
    for (int i = 1; i <= n; i++) {
        if (q[i].opt == 1) {
            modify1(1, q[i].l, q[i].r, 1);
        } else if (q[i].opt == 2) {
            modify1(1, q[i].l, q[i].r, 0);
        } else {
            modify2(1, q[i].l, q[i].r, 1);
        }
        //for (int j = 1; j <= 10; j++) cout << find(1, j) << " ";
        //cout << endl;
        cout << ve[query(1)-1] << endl;
    }
}
signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
    return 0;
}