POJ 3667 Hotel 线段树（带延迟标记）

题目：http://poj.org/problem?id=3667

还有一个：https://www.acwing.com/problem/content/description/263/

一家旅馆共有N个房间，这N个房间是连成一排的，标号为1-N。

现在有很多旅客以组为单位前来入住，每组旅客的数量可以用Di来表示。

旅店的业务分为两种，入住和退房：

1、旅客入住时，第i组旅客需要根据他们的人数Di，给他们安排Di个连续的房间，并且房间号要尽可能的小。如果房间不够，则无法安排。

2、旅客退房时，第i组旅客的账单将包含两个参数Xi和Di,你需要将房间号Xi到Xi+Di−1之间的房间全部清空。

现在你需要帮助该旅馆处理M单业务。

旅馆最初是空的。

输入数据

第一行输入两个用空格隔开的整数N和M。

接下来M行将描述M单业务：

“1 Di”表示这单业务为入住业务。

“2 Xi Di”表示这单业务为退房业务。

输出数据

每个入住业务输出一个整数，表示要安排的房间序列中的第一个房间的号码。

如果没办法安排，则输出0。

每个输出占一行。

 

首先数据规模是5e4,问题的规模也是5e4 , 说明每一个问题最多需要logN 的时间来回答。

然后题目要求我们在logN的时间内

1.将一个区域的房间标记为未入住  

2.找到长度为di的空房,并且编号需要最小

大概就可以判断是线段树了,并且也可以判断问题的难点就是上面的第2点.

 

首先需要解决的第一个问题是如何找到长度大于等于di的连续房间,我们可以使用线段树来维护从房间编号为 l到r 的空房间数,并且是连续最大的空房间数,这里我用len[i]表示

对于 [l,r] 区间内的连续最大的空房间数 , 它可以有3个来源

1.[l,mid]区间内的最大空房间数

2.[mid+1,r]区间内的最大空房间数

3.最大空房间的编号经过mid

对于前2点都很好实现,关键是第3点.

因此再引入两个变量,llen(left_lenth) 和 rlen(right_lenth) , 分别表示[l,r]区间内从左边开始的连续空房间数,和从右边开始的连续空房间数

例如: 

在  00101 中(0表示空房间) , 其llen = 2 , rlen = 0(从最右边开始没有连续的空房)

那么第3点就可以表示为:

假设当前节点的编号为 index , 那么其左子节点编号为 index*2 , 右子节点编号为 index*2+1

编号经过mid的连续空房间数= llen[index*2+1] + rlen[index*2]

如此一来就解决了用线段树维护连续最大空房间数的问题

 

然后接下来要解决的是找到最小的编号

这个只需要调整搜索顺序即可.

对于某一段区间,先检查其左子节点的连续空房间数是否符合要求,若符合要求则递归进入左子节点

否则检查这段区间中 房间编号经过mid的连续空房间数 是否符合要求,若符合直接返回结果

否则检查右子节点的连续空间数是否符合要求,若符合则递归进入右子节点

否则返回 0 

 

代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#define ll long long 
#define ull unsigned long long 
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 5e4 + 7;
int lazy[maxn << 3], llen[maxn << 3], rlen[maxn << 3];
int len[maxn << 3];
int n, m;
void build_tree(int l, int r, int ind) {
	if (l == r) {
		len[ind] = llen[ind] = rlen[ind] = 1;
		return;
	}
	int mid = (l + r) >> 1;
	build_tree(l, mid, ind << 1);
	build_tree(mid + 1, r, ind << 1 | 1);
	//初始化
	len[ind] = rlen[ind] = llen[ind] = len[ind << 1] + len[ind << 1 | 1];
}
void push(int l,int r,int ind) {
	int mid = (l + r) >> 1;
	if (lazy[ind]) {
		if (lazy[ind] == 1) {
			llen[ind << 1] = rlen[ind << 1] = len[ind << 1] = mid - l + 1;
			llen[ind << 1 | 1] = rlen[ind << 1 | 1] = len[ind << 1 | 1] = r - mid;
		}
		else {
			llen[ind << 1] = rlen[ind << 1] = len[ind << 1] = 0;
			llen[ind << 1 | 1] = rlen[ind << 1 | 1] = len[ind << 1 | 1] = 0;
		}
		//这里不能用+=。。。
		//lazy[ind << 1] += lazy[ind];
		//lazy[ind << 1 | 1] += lazy[ind];
		lazy[ind << 1] = lazy[ind << 1 | 1] = lazy[ind];
		lazy[ind] = 0;
	}
}
//opt : 1 退房，  -1： 入住
void update(int l, int r, int q_l, int q_r, int opt, int ind) {
	if (q_l <= l && q_r >= r) {
		//lazy[ind] += opt;
		lazy[ind] = opt;
		if (opt == 1) {
			llen[ind] = rlen[ind] = len[ind] = r - l + 1;
		}
		else
			llen[ind] = rlen[ind] = len[ind] = 0;
		return;
	}
	push(l, r, ind);
	int mid = (l + r) >> 1;
	if (q_l <= mid) update(l, mid, q_l, q_r, opt, ind << 1);
	if (q_r > mid) update(mid + 1, r, q_l, q_r, opt, ind << 1 | 1);
	//假如左子树全部都是空房的话
	if (len[ind << 1] == mid - l + 1)
		llen[ind] = len[ind << 1] + llen[ind << 1 | 1];
	else
		llen[ind] = llen[ind << 1];
	//假如右子树全部都是空房的话
	if (len[ind << 1 | 1] == r - mid)
		rlen[ind] = len[ind << 1 | 1] + rlen[ind << 1];
	else
		rlen[ind] = rlen[ind << 1 | 1];
	//更新长度 
	len[ind] = max(max(len[ind << 1], len[ind << 1 | 1]), rlen[ind << 1] + llen[ind << 1 | 1]);
}
int query(int l, int r, int need,int ind) {
	int mid = (l + r) >> 1;
	push(l, r, ind);
	if (len[ind << 1] >= need) { // 左儿子满足条件
		return query(l, mid, need, ind << 1);
	}
	else if (rlen[ind<<1]+llen[ind<<1|1] >= need) { //中间满足条件
		int ret = mid - rlen[ind << 1] + 1;
		update(1, n, ret, ret + need - 1, -1, 1);
		return ret;
	}
	else if (len[ind << 1 | 1] >= need) { //右儿子满足条件
		return query(mid + 1, r, need, ind << 1 | 1);
	}
	else return 0;
}

int main() {
	cin >> n >> m;
	build_tree(1, n, 1);
	int opt, in1, in2;
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &opt, &in1);
		if (opt == 1) { // 安排入住
			if (len[1] < in1) {
				printf("0\n");
				continue;
			}
			printf("%d\n", query(1, n, in1, 1));
		}
		else {
			scanf("%d", &in2);
			update(1, n, in1, in1 + in2 - 1, 1, 1);
		}
	}
	return 0;
}