POJ 1823 Hotel【线段树】

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 12 10 3 1 2 3 1 9 4 3 2 2 1 3 2 9 2 3 2 3 2 3 Sample Output 12 4 4 6 10 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;
}