题目地址:
https://www.acwing.com/problem/content/description/263/
一家旅馆共有 N N N个房间,这 N N N个房间是连成一排的,标号为 1 ∼ N 1∼N 1∼N。现在有很多旅客以组为单位前来入住,每组旅客的数量可以用 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+Di−1之间的房间全部清空。现在你需要帮助该旅馆处理 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
1≤Di≤N≤50000
1
≤
M
<
50000
1≤M<50000
1≤M<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+Di−1]清零。
这可以用线段树 + 懒标记来做。为了找到长度大于等于 x x x的 0 0 0子数组,每个树节点里可以存其维护区间的最长 0 0 0子数组有多长,这样每次查询的时候,优先查左儿子,如果左儿子不够长,则查一下是否有横跨左右儿子的 0 0 0子数组满足条件,横跨两边的最长长度由左儿子的最长后缀和右儿子的最长前缀决定,所以树节点里还需要存这个信息;如果横跨也找不到,则去查右儿子;如果还找不到,则说明不存在。
对于修改操作,如果当前区间被完全包含在内,则对其修改,修改完了打上懒标记;如果不是完全包含在内,则下传懒标记(这里懒标记有清零和变成 1 1 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(\log N) O(logN),空间 O ( N ) O(N) O(N)。