【ACWing】261. 旅馆

题目地址：

https://www.acwing.com/problem/content/description/263/

一家旅馆共有$N$个房间，这$N$个房间是连成一排的，标号为$1\sim N$。现在有很多旅客以组为单位前来入住，每组旅客的数量可以用$D_i$来表示。旅店的业务分为两种，入住和退房：旅客入住时，第$i$组旅客需要根据他们的人数$D_i$，给他们安排$D_i$个连续的房间，并且房间号要尽可能的小。如果房间不够，则无法安排。旅客退房时，第$i$组旅客的账单将包含两个参数$X_i$和$D_i$，你需要将房间号$X_i$到$X_i+D_i-1$之间的房间全部清空。现在你需要帮助该旅馆处理$M$单业务。旅馆最初是空的。

输入数据：
第一行输入两个用空格隔开的整数$N$和$M$。接下来$M$行将描述$M$单业务：
“1 Di”表示这单业务为入住业务。
“2 Xi Di”表示这单业务为退房业务。

输出数据：
每个入住业务输出一个整数，表示要安排的房间序列中的第一个房间的号码。如果没办法安排，则输出$0$。每个输出占一行。

数据范围：
$1\le D_i\le N\le 50000$
$1\le M<50000$

可以想象有个长$N$的$0$数组，那么上面的两个操作相当于是做：
1、找到尽可能左边的长度大于等于给定值$x$的$0$子数组，如果能找到，则将这些$0$全置为$1$；如果找不到则输出$0$；
2、将$[X_i,X_i+D_i-1]$清零。

这可以用线段树 + 懒标记来做。为了找到长度大于等于$x$的$0$子数组，每个树节点里可以存其维护区间的最长$0$子数组有多长，这样每次查询的时候，优先查左儿子，如果左儿子不够长，则查一下是否有横跨左右儿子的$0$子数组满足条件，横跨两边的最长长度由左儿子的最长后缀和右儿子的最长前缀决定，所以树节点里还需要存这个信息；如果横跨也找不到，则去查右儿子；如果还找不到，则说明不存在。

对于修改操作，如果当前区间被完全包含在内，则对其修改，修改完了打上懒标记；如果不是完全包含在内，则下传懒标记（这里懒标记有清零和变成$1$两种，可以用两个不同的数字来代表），下传完了之后递归修改左右孩子。

代码如下：

#include <iostream>
using namespace std;

const int N = 5e4 + 10;
struct Node{
    int l, r;
    // d为当前区间最长的0子数组的长度，ld是从l开始向右的
    // 最长0子数组长度，rd是r开始向左的最长0子数组长度
    int d, ld, rd;
    int lazy;
} tr[N << 2];
int n, m;

void pushup(Node &u, Node &l, Node &r) {
    u.ld = l.ld;
    if (l.d == l.r - l.l + 1) u.ld = l.d + r.ld;
    u.rd = r.rd;
    if (r.d == r.r - r.l + 1) u.rd = r.d + l.rd;
    u.d = max(max(l.d, r.d), l.rd + r.ld);
}

void pushup(int u) {
    pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}

void build(int u, int l, int r) {
    tr[u] = {l, r};
    if (l == r) {
        tr[u].d = tr[u].ld = tr[u].rd = 1;
        return;
    }

    int mid = l + r >> 1;
    build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
    pushup(u);
}

void pushdown(Node &u, Node &l, Node &r) {
    if (u.lazy == 1) {
        l.d = l.ld = l.rd = l.r - l.l + 1;
        r.d = r.ld = r.rd = r.r - r.l + 1;
    } else if(u.lazy == 2) {
        l.d = l.ld = l.rd = r.d = r.ld = r.rd = 0;
    }

    l.lazy = r.lazy = u.lazy;
    u.lazy = 0;
}

void pushdown(int u) {
    if (tr[u].lazy) pushdown(tr[u], tr[u << 1], tr[u << 1 | 1]);
}

int query(int u, int len) {
    if (tr[u].d < len) return 0;

    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    // 先查左儿子，再查横跨的，最后查右儿子
    if (tr[u << 1].d >= len) return query(u << 1, len);
    if (tr[u << 1].rd + tr[u << 1 | 1].ld >= len) return tr[u << 1].r - tr[u << 1].rd + 1;
    if (tr[u << 1 | 1].d >= len) return query(u << 1 | 1, len);
    
    return 0;
}

// c = 1代表变成1的操作，2代表清零操作
void modify(int u, int l, int r, int c) {
    if (tr[u].l >= l && tr[u].r <= r) {
        if (c == 1) tr[u].d = tr[u].ld = tr[u].rd = tr[u].r - tr[u].l + 1;
        else tr[u].d = tr[u].ld = tr[u].rd = 0;
        tr[u].lazy = c;
        return;
    }

    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid) modify(u << 1, l, r, c);
    if (r > mid) modify(u << 1 | 1, l, r, c);
    pushup(u);
}

int main() {
    scanf("%d%d", &n, &m);
    build(1, 1, n);

    while (m--) {
        int op;
        scanf("%d", &op);
        if (op == 1) {
            int len;
            scanf("%d", &len);
            int l = query(1, len);
            printf("%d\n", l);
            if (l) modify(1, l, l + len - 1, 2);
        } else {
            int l, len;
            scanf("%d%d", &l, &len);
            modify(1, l, l + len - 1, 1);
        }
    }

    return 0;
}

每次从操作时间复杂度$O(\log N)$，空间$O(N)$。