poj 3667 Hotel (线段树)

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

Hotel

Time Limit: 3000MS		Memory Limit: 65536K
Total Submissions: 9484		Accepted: 4066

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, and D_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

USACO 2008 February Gold

 

【题解】：

　　线段树：

struct Nod
{
    int l,r;
    int ml,mm,mr;  //左边的空位，区间最大的空位，右边的空位
}node[N<<2];

查找的时候优先向左边查找插入；

注意各种状态的更新

详见代码

 

【code】：

 /**
 judge status: Accepted      exe.time:563MS
 exe.memory 2712K    language:C++
 */

 #include<iostream>
 #include<stdio.h>
 #include<string.h>
 #include<algorithm>

 #define N 50010

 #define lson p<<1
 #define rson p<<1|1

 using namespace std;

 struct Nod
 {
     int l,r;
     int ml,mm,mr;  //左边的空位，区间最大的空位，右边的空位
 }node[N<<];

 int id;

 void building(int l,int r,int p)//建树
 {
     node[p].l = l;
     node[p].r = r;
     node[p].mm=node[p].mr=node[p].ml= r-l+;
     if(l==r)    return;
     int mid = (l+r)>>;
     building(l,mid,lson);
     building(mid+,r,rson);
 }

 void judgeChange(int p)  //向下更新，状态延迟标记，当搜索到整个区间一样时，向下更新一层，然后进行操作
 {
     if(node[p].mm==node[p].r-node[p].l+)
     {
         node[lson].ml=node[lson].mm=node[lson].mr=node[lson].r-node[lson].l+;
         node[rson].ml=node[rson].mm=node[rson].mr=node[rson].r-node[rson].l+;
     }
     if(node[p].mm==)
     {
         node[lson].ml=node[lson].mm=node[lson].mr=;
         node[rson].ml=node[rson].mm=node[rson].mr=;
     }
 }

 void findId(int p,int val)  //查找可以开房间的起始位置
 {
     if(node[p].l==node[p].r&&val==) //当val为1并且已经达到叶子节点，说明没有孩子了，不必再往下查找
     {
         id = node[p].l;
         return;
     }
     judgeChange(p);  //状态延迟标记更新
     if(node[p].mm>=val)  //区间最大连续>=val时
     {
         if(node[lson].mm>=val)  //优先左边搜索
         {
             findId(lson,val);
         }
         else if(node[rson].ml+node[lson].mr>=val)  //然后中间
         {
             id = node[lson].r - node[lson].mr + ;
         }
         else if(node[rson].mm>=val)  //最后右边
         {
             findId(rson,val);
         }
     }
 }

 void Up(int p)  //向上更新状态
 {
     node[p].ml = node[lson].ml;
     node[p].mr = node[rson].mr;
     if(node[lson].ml==node[lson].r-node[lson].l+)
     {
         node[p].ml+=node[rson].ml;
     }
     if(node[rson].mr==node[rson].r-node[rson].l+)
     {
         node[p].mr+=node[lson].mr;
     }
     node[p].mm = max(node[lson].mm,node[rson].mm);
     node[p].mm = max(node[p].mm,node[lson].mr+node[rson].ml);
     node[p].mm = max(node[p].mm,node[p].ml);
     node[p].mm = max(node[p].mm,node[p].mr);
 }

 void update(int l,int r,int p,int op) //更新
 {
     if(node[p].l==l&&node[p].r==r)
     {
         if(op==)   node[p].ml=node[p].mm=node[p].mr=;  //执行操作1
         else    node[p].ml=node[p].mm=node[p].mr=r-l+;  //执行操作2
         return;
     }
     judgeChange(p);  //状态延迟标记更新
     int mid = (node[p].l+node[p].r)>>;
     if(r<=mid)  update(l,r,lson,op);
     else if(l>mid)  update(l,r,rson,op);
     else
     {
         update(l,mid,lson,op);
         update(mid+,r,rson,op);
     }
     Up(p);  //由左右孩子节点向上更新ml，mm，mr值
 }

 int main()
 {
     int n,m;
     scanf("%d%d",&n,&m);
     building(,n,);
     while(m--)
     {
         int op,a,b;
         scanf("%d",&op);
         if(op==)
         {
             scanf("%d",&a);
             id = ;
             findId(,a);  //查找可插入位置
             printf("%d\n",id);
             if(id)   update(id,id+a-,,);   //在id位置插入a个数，即在[id,id+a-1]插入
         }
         else if(op==)
         {
             scanf("%d%d",&a,&b);
             update(a,a+b-,,);  //在a位置删除b个数，即把在[a,a+b-1]区间清空
         }
     }
     return ;
 }