74分RE求调

#include <bits/stdc++.h>
using namespace std;
const int N = 5e4 + 44;
int n, m;

struct SegmentTree {
    int val, lazy_tag;
    int l, r;
    int l_max_len, r_max_len;
} tree[N * 4];

void build(int u, int l, int r) {
    tree[u].l = l;
    tree[u].r = r;
    tree[u].lazy_tag = 0;
    tree[u].val = tree[u].l_max_len = tree[u].r_max_len = r - l + 1;
    if (l == r)
        return;
    int mid = (l + r) / 2;
    build(u * 2, l, mid);
    build(u * 2 + 1, mid + 1, r);
}

void spread(int u) {
    if (tree[u].lazy_tag == 1) {
        tree[u * 2].lazy_tag = tree[u * 2 + 1].lazy_tag = 1;
        tree[u * 2].val = tree[u * 2].l_max_len = tree[u * 2].r_max_len = 0;
        tree[u * 2 + 1].val = tree[u * 2 + 1].l_max_len = tree[u * 2 + 1].r_max_len = 0;
    }
    if (tree[u].lazy_tag == 2) {
        tree[u * 2].lazy_tag = tree[u * 2 + 1].lazy_tag = 2;
        tree[u * 2].val = tree[u * 2].l_max_len = tree[u * 2].r_max_len = tree[u * 2].r - tree[u * 2].l + 1;
        tree[u * 2 + 1].val = tree[u * 2 + 1].l_max_len = tree[u * 2 + 1].r_max_len = tree[u * 2 + 1].r - tree[u * 2 + 1].l + 1;
    }
    tree[u].lazy_tag = 0;
}

void check_in(int u, int l, int r) {
    spread(u);
    if (l <= tree[u].l && tree[u].r <= r) {
        tree[u].val = tree[u].l_max_len = tree[u].r_max_len = 0;
        tree[u].lazy_tag = 1;
        return;
    }
    // int mid = (l + r) / 2;
    int mid = (tree[u].l + tree[u].r) / 2;
    if (l <= mid)
        check_in(u * 2, l, min(r, mid));
    if (r > mid)
        check_in(u * 2 + 1, max(l, mid + 1), r);
    if (tree[u * 2].r - tree[u * 2].l + 1 == tree[u * 2].val)
        tree[u].l_max_len = tree[u * 2].r - tree[u * 2].l + 1 + tree[u * 2 + 1].l_max_len;
    else
        tree[u].l_max_len = tree[u * 2].l_max_len;
    if (tree[u * 2 + 1].r - tree[u * 2 + 1].l + 1 == tree[u * 2 + 1].val)
        tree[u].r_max_len = tree[u * 2].r_max_len + tree[u * 2 + 1].r - tree[u * 2 + 1].l + 1;
    else
        tree[u].r_max_len = tree[u * 2 + 1].r_max_len;
    tree[u].val = max(max(tree[u * 2].val, tree[u * 2 + 1].val), tree[u * 2].r_max_len + tree[u * 2 + 1].l_max_len);
}

void check_out(int u, int l, int r) {
    spread(u);
    if (l <= tree[u].l && tree[u].r <= r) {
        tree[u].val = tree[u].l_max_len = tree[u].r_max_len = tree[u].r - tree[u].l + 1;
        tree[u].lazy_tag = 2;
        return;
    }
    int mid = (tree[u].l + tree[u].r) / 2;
    if (l <= mid)
        check_out(u * 2, l, min(r, mid));
    if (r > mid)
        check_out(u * 2 + 1, max(l, mid + 1), r);
    if (tree[u * 2].r - tree[u * 2].l + 1 == tree[u * 2].val)
        tree[u].l_max_len = tree[u * 2].r - tree[u * 2].l + 1 + tree[u * 2 + 1].l_max_len;
    else
        tree[u].l_max_len = tree[u * 2].l_max_len;
    if (tree[u * 2 + 1].r - tree[u * 2 + 1].l + 1 == tree[u * 2 + 1].val)
        tree[u].r_max_len = tree[u * 2].r_max_len + tree[u * 2 + 1].r - tree[u * 2 + 1].l + 1;
    else
        tree[u].r_max_len = tree[u * 2 + 1].r_max_len;
    tree[u].val = max(max(tree[u * 2].val, tree[u * 2 + 1].val), tree[u * 2].r_max_len + tree[u * 2 + 1].l_max_len);
}

int query(int u, int x) {
    spread(u);
    if (tree[u].l == tree[u].r)
        return tree[u].l;
    int mid = (tree[u].l + tree[u].r) / 2;
    if (tree[u * 2].val >= x)
        return query(u * 2, x);
    if (tree[u * 2].r_max_len + tree[u * 2 + 1].l_max_len >= x)
        return mid - tree[u * 2].r_max_len + 1;
    if (tree[u * 2 + 1].val >= x)
        return query(u * 2 + 1, x);
    return 0;
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);//咒语

    cin >> n >> m;
    build(1, 1, n);
    int opt, x, y;
    for (int i = 1; i <= m; i++) {
        cin >> opt;
        if (opt == 1) {
            cin >> x;
            if (tree[1].val >= x) {
                int l = query(1, x);
                cout << l << endl;
                check_in(1, l, l + x - 1);
            } else {
                cout << 0 << endl;
            }
        } else {
            cin >> x >> y;
            check_out(1, x, x + y - 1);
        }
    }
    return 0;
}