poj 3667 Hotel

http://poj.org/problem?id=3667

Hotel

Time Limit: 3000MS		Memory Limit: 65536K
Total Submissions: 8874		Accepted: 3769

Description

The cows are journeying north to Thunder Bay in Canada to gain cultural enrichment and enjoy a vacation on the sunny shores of Lake Superior. Bessie, ever the competent travel agent, has named the Bullmoose Hotel on famed Cumberland Street as their vacation residence. This immense hotel has N (1 ≤ N ≤ 50,000) rooms all located on the same side of an extremely long hallway (all the better to see the lake, of course).

The cows and other visitors arrive in groups of size D_i (1 ≤ D_i ≤ N) and approach the front desk to check in. Each group i requests a set of D_i contiguous rooms from Canmuu, the moose staffing the counter. He assigns them some set of consecutive room numbers r..r+D_i-1 if they are available or, if no contiguous set of rooms is available, politely suggests alternate lodging. Canmuu always chooses the value of r to be the smallest possible.

Visitors also depart the hotel from groups of contiguous rooms. Checkout i has the parameters X_i and D_i which specify the vacating of rooms X_i ..X_i +D_i-1 (1 ≤ X_i ≤ N-D_i+1). Some (or all) of those rooms might be empty before the checkout.

Your job is to assist Canmuu by processing M (1 ≤ M < 50,000) checkin/checkout requests. The hotel is initially unoccupied.

Input

* Line 1: Two space-separated integers: N and M
* Lines 2..M+1: Line i+1 contains request expressed as one of two possible formats: (a) Two space separated integers representing a check-in request: 1 and D_i (b) Three space-separated integers representing a check-out: 2, X_i, andD_i

Output

* Lines 1.....: For each check-in request, output a single line with a single integer r, the first room in the contiguous sequence of rooms to be occupied. If the request cannot be satisfied, output 0.

Sample Input

10 6
1 3
1 3
1 3
1 3
2 5 5
1 6

Sample Output

1
4
7
0
5

Source

/**
题意：两个操作
1  len  找是否存在连续的len长的空房子。
           如果有多个存在，选择最左边的。并输出最左边的位置的值
           
2 L num 从L开始长为L+num-1的长度的房子清空。

思路：

操作2比较简单，延迟标记就行。
操作1，需要统计lmaxn , rmaxn , maxn 来统计连续的0的个数; 
这题和前面几题有所差异，我不需要lnum,rnum;
其实需要不需要我们要看up(int n) 里是否需要。

void up(int n)
{
    f[n].lmaxn = (  f[n*2].lmaxn==f[n*2].len ) ? f[n*2].lmaxn+f[n*2+1].lmaxn : f[n*2].lmaxn;
    f[n].rmaxn = (  f[n*2+1].rmaxn == f[n*2+1].len ) ? f[n*2+1].rmaxn+f[n*2].rmaxn : f[n*2+1].rmaxn;

    f[n].maxn = max(f[n*2].maxn,f[n*2+1].maxn);
    f[n].maxn = max( f[n*2].rmaxn+f[n*2+1].lmaxn,f[n].maxn );
}
如果为lnum = 1  或 rnum = 1，那么其对应的值就是为0，所以相加也是没有关系的。
可以不判断lnum, rnum;

同时，讨论query() 。
当左儿子节点的max>=len 时，递归到左儿子节点。
如果此时不满足不是讨论  右儿子节点  而是讨论
左儿子节点的右端点的最大值+右儿子节点的左端点的最大值是否满足>=len,即
if(f[n*2].rmax+f[n*2+1].lmax>=len)
     return f[n*2].r-f[n*2].rmax+1;
返回最左的端点位置。
然后才是讨论右儿子节点的情况。
**/
#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cstdlib>
using namespace std;

struct node
{
    int l,r,len;
    int lmaxn,rmaxn,maxn;
    bool setFlag;
    int setNum;
}f[50002*4];

void up(int n)
{
    f[n].lmaxn = (  f[n*2].lmaxn==f[n*2].len ) ? f[n*2].lmaxn+f[n*2+1].lmaxn : f[n*2].lmaxn;
    f[n].rmaxn = (  f[n*2+1].rmaxn == f[n*2+1].len ) ? f[n*2+1].rmaxn+f[n*2].rmaxn : f[n*2+1].rmaxn;

    f[n].maxn = max(f[n*2].maxn,f[n*2+1].maxn);
    f[n].maxn = max( f[n*2].rmaxn+f[n*2+1].lmaxn,f[n].maxn );
}
void build(int l,int r,int n)
{
    int mid=(l+r)/2;
    f[n].l = l;
    f[n].r = r;
    f[n].len = (r-l+1);
    f[n].setFlag = false;
    f[n].setNum = 0;
    f[n].lmaxn = f[n].rmaxn = f[n].maxn = 0;
    if(l == r)
    {
        f[n].lmaxn = f[n].rmaxn = f[n].maxn = 1;
        return ;
    }
    build(l,mid,n*2);
    build(mid+1,r,n*2+1);
    up(n);
}

void down(int n)
{
    f[n*2].setFlag = true;
    f[n*2].setNum = f[n].setNum;
    f[n*2].lmaxn = f[n*2].rmaxn = f[n*2].maxn = f[n*2].len*f[n].setNum;

    f[n*2+1].setFlag = true;
    f[n*2+1].setNum = f[n].setNum;
    f[n*2+1].lmaxn = f[n*2+1].rmaxn = f[n*2+1].maxn = f[n*2+1].len*f[n].setNum;

    f[n].setFlag = false;
}
void update(int l,int r,int size1,int n)
{
    int mid = (f[n].l + f[n].r)/2;
    if(f[n].l == l && f[n].r == r)
    {
        f[n].setFlag = true;
        f[n].setNum = size1;
        f[n].lmaxn = f[n].rmaxn = f[n].maxn = f[n].len*size1;
        return;
    }
    if(f[n].setFlag == true) down(n);
    if(mid>=r) update(l,r,size1,n*2);
    else if(mid<l) update(l,r,size1,n*2+1);
    else
    {
        update(l,mid,size1,n*2);
        update(mid+1,r,size1,n*2+1);
    }
    up(n);
}

int query(int len , int  n)
{
    if(f[n].maxn<len) return 0;
    if(f[n].setFlag == true) down(n);
    if(f[n*2].maxn >= len) return query(len,n*2);
    else if(f[n*2].rmaxn + f[n*2+1].lmaxn>=len)
        return f[n*2].r - f[n*2].rmaxn +1;
    else return query(len,n*2+1);
}
int main()
{
    int n,m;
    int size1,l,r,len;
    while(scanf("%d%d",&n,&m)>0)
    {
        build(1,n,1);
        while(m--)
        {
            scanf("%d",&size1);
            if(size1==1)
            {
                scanf("%d",&len);
                int ans = query(len,1);
                printf("%d\n",ans);
                if(ans>0) update(ans,ans+len-1,0,1);
            }
            else if(size1==2)
            {
                scanf("%d%d",&l,&r);
                r=l+r+-1;
                update(l,r,1,1);
            }
        }
    }
    return 0;
}