【ACWing】261. 旅馆

题目地址:

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

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

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

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

数据范围:
1 ≤ D i ≤ N ≤ 50000 1≤D_i≤N≤50000 1DiN50000
1 ≤ M < 50000 1≤M<50000 1M<50000

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

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

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

代码如下:

#include 
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(\log N) O(logN),空间 O ( N ) O(N) O(N)

你可能感兴趣的:(AC,数据结构,c++,数据结构,算法)