您的位置：首页 > 其它

POJ 1823 Hotel【线段树】

2014-08-18 15:22 513 查看

POJ 1823 Hotel【线段树】http://poj.org/problem?id=1823

Hotel

Time Limit: 5000MS		Memory Limit: 30000K
Total Submissions: 2031		Accepted: 869

Description

The "Informatics" hotel is one of the most luxurious hotels from Galaciuc. A lot of tourists arrive or leave this hotel in one year. So it is pretty difficult to keep the evidence of the occupied rooms. But this year the owner of the hotel decided to do some
changes. That's why he engaged you to write an efficient program that should respond to all his needs.

Write a program that should efficiently respond to these 3 types of instructions:

type 1: the arrival of a new group of tourists

A group of M tourists wants to occupy M free consecutive rooms. The program will receive the number i which represents the start room of the sequence of the rooms that the group wants to occupy and the number M representing the number of members of the group.
It is guaranteed that all the rooms i,i+1,..,i+M-1 are free at that moment.

type 2: the departure of a group of tourists

The tourists leave in groups (not necessarilly those groups in which they came). A group with M members leaves M occupied and consecutive rooms. The program will receive the number i representing the start room of the sequence of the released rooms and the
number M representing the number of members of the group. It is guaranteed that all the rooms i,i+1,..,i+M-1 are occupied.

type 3: the owner's question

The owner of the hotel may ask from time to time which is the maximal length of a sequence of free consecutive rooms. He needs this number to know which is the maximal number of tourists that could arrive to the hotel. You can assume that each room may be occupied
by no more than one tourist.

Input

On the first line of input, there will be the numbers N (3 <= N <= 16 000) representing the number of the rooms and P (3 <= P <= 200 000) representing the number of the instructions.

The next P lines will contain the number c representing the type of the instruction:

if c is 1 then it will be followed (on the same line) by 2 other numbers, i and M, representing the number of the first room distributed to the group and the number of the members

if c is 2 then it will be followed (on the same line) by 2 other numbers, i and M, representing the number of the first room that will be released and the number of the members of the group that is leaving

if c is 3 then it will not be followed by any number on that line, but the program should output in the output file the maximal length of a sequence of free and consecutive rooms

Output

In the output you will print for each instruction of type 3, on separated lines, the maximal length of a sequence of free and consecutive rooms. Before the first instruction all the rooms are free.
Sample Input

Sample Output

Source

Romania OI 2002

[Submit] [Go Back] [Status]
[Discuss]
【题意】有n个房间标号1~n，起初全是空的，每个房间只能住一人；有三种不同的操作：1 a b表示从a房间开始住进去b个人；2 a b表示从a房间开始离开b个人；3 表示查询当前状态最长的连续空房间个数。
【分析】线段树

【代码如下】

//1823	Accepted	924K    3500MS	C++	3480B
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>

using namespace std;
const int maxn = 16000 + 10;

struct hotel
{
int l, r;
int in;
//记录该区间是否被覆盖，0代表未覆盖，1代表部分覆盖，2代表完全覆盖
int maxl, mmax, maxr;
//记录节点，左边的最大长度maxl，右边的最大长度maxr，和该节点区间的最大长度mmax
}tree[maxn*4];

void build_tree(int l, int r, int u)//建树
{
tree[u].l = l; tree[u].r = r; tree[u].in = 0;
if(l == r){
tree[u].mmax = tree[u].maxr = tree[u].maxl = 1;
return ;
}
int mid = (l+r)/2;
build_tree(l, mid, u*2);
build_tree(mid+1, r, u*2+1);
tree[u].mmax = tree[u].maxr = tree[u].maxl = tree[u*2].mmax + tree[u*2+1].mmax;
}

void update(int u)//更新节点的最大值
{
if(!tree[u*2].in)//如果该节点的左子树未被覆盖,则该节点左边maxl的最大值为：左子树的最大值加上右子树的左边值
tree[u].maxl = tree[u*2].mmax + tree[u*2+1].maxl;
else
tree[u].maxl = tree[u*2].maxl;//否则该节点的左边值就等于左子树的左边值
if(!tree[u*2+1].in)//同理更新节点的右值
tree[u].maxr = tree[u*2+1].mmax + tree[u*2].maxr;
else
tree[u].maxr = tree[u*2+1].maxr;
//下面一步是更新节点的mmax
int maxl = max(tree[u].maxl, tree[u].maxr);//找出节点左右值的最大值。
int maxm = tree[u*2].maxr + tree[u*2+1].maxl;//该节点左子树的右值加右子树的左值（即该父节点区间的中间值）
int maxr = max(tree[u*2].mmax, tree[u*2+1].mmax);//左右子树的最大值
int maxmax = max(max(maxl, maxm), maxr);
tree[u].mmax = maxmax;//更新最大值
if(tree[u*2].in == tree[u*2+1].in)
tree[u].in = tree[u*2].in;
}

void insert(int l, int r, int u)//插入
{
if(l==tree[u].l && tree[u].r==r)//如果区间相等
{
tree[u].in=2;//则完全覆盖
tree[u].maxl=tree[u].maxr=tree[u].mmax=0;//长度为0
return ;
}
if(!tree[u].in)//如果没被覆盖
{
tree[u].in=1;
tree[u*2].in=0;
tree[u*2+1].in=0;
//更新左右子树的最大值为区间长度
tree[u*2].maxl=tree[u*2].maxr=tree[u*2].mmax=tree[u*2].r-tree[u*2].l+1;
tree[u*2+1].maxl=tree[u*2+1].mmax=tree[u*2+1].maxr=tree[u*2+1].r-tree[u*2+1].l+1;
}
//向下递归
int mid=(tree[u].l+tree[u].r)/2;
if(r <= mid)
insert(l, r, u*2);
else if(l > mid)
insert(l, r, u*2+1);
else
{
insert(l, mid, u*2);
insert(mid+1, r, u*2+1);
}
update(u);//更新节点的最大值
}

void remove(int l,int r,int u)//撤离同插入
{
if(l==tree[u].l&&tree[u].r==r)//如果相等
{
tree[u].in=0;//则全部移除，为0。
tree[u].maxl=tree[u].maxr=tree[u].mmax=tree[u].r-tree[u].l+1;//更新最大值为区间长度
return ;
}
if(tree[u].in==2)//如果该节点被完全覆盖
{
tree[u].in=1;
tree[u*2].in=2;
tree[u*2+1].in=2;
//更新左右子树的最大值为0.（完全覆盖）
tree[u*2].maxl=tree[u*2].mmax=tree[u*2].maxr=0;
tree[u*2+1].maxl=tree[u*2+1].mmax=tree[u*2+1].maxr=0;
}
//向下递归
int mid=(tree[u].l+tree[u].r)/2;
if(r<=mid)
remove(l, r, u*2);
else if(l>mid)
remove(l, r, u*2+1);
else
{
remove(l, mid, u*2);
remove(mid+1, r, u*2+1);
}
update(u);//更新节点的最大值
}

int main()
{
int n, m, k, a, b;
scanf("%d %d", &n, &m);
build_tree(1, n, 1);
while(m--)
{
scanf("%d", &k);
if(k==1){
scanf("%d %d", &a, &b);
insert(a, a+b-1, 1);
}
else if(k==2){
scanf("%d %d", &a, &b);
remove(a, a+b-1, 1);
}
else
printf("%d\n", tree[1].mmax);
}
return 0;
}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航