poj 3667 Hotel

变量，此题维持3个变量，假设区间l[l,r]这个区间需要保存这个区间的最大值，从l开始的最大值，以及以r结尾的最大值，对于COVER空闲为1，非空闲为0.

大概思路：对与1：先query操作找出能够容纳给定范围的第一个下标，然后update更新操作。

              对于2：操作直接update操作

query操作：根据大小需要的连续房间进行qury操作，当然要先进行pushdown操作，即将当前节点cover状态赋予子代， 然后如果这个需要的房间大小如果小于其左孩子的大小

                则访问孩子，另外如果是左孩子的右最大值+右孩子的左孩子最大值 大于value，很明显，就是直接左边孩子的开始处，如果都不是，则剩下的是右孩子了。。

pushdow：操作就只有一个功能判断当前节点被什么覆盖，如果COVER不为-1，则被0或者是1覆盖，然后直接将其孩子的区间就是全为覆盖值乘以其范围，如果为-1，不需要覆

                操作。

update：根据更新区间操作，如果除开pushup那一部分就是一个更新区间为1或者0的操作。

pushup:一个区间（称为S):    的左最大是看左孩子的左最大，如果左孩子的左最大等于自身的区间，则S的左最大还需要包括S右孩子的左最大，同理S区间的右最大也是如此。

           然后S区间的最大值就为左孩子的最大值，或者右孩子的最大值，或者是左孩子的右最大与右孩子的左最大之和。

#include<cstdio>

#include<cstdlib>

#include<cmath>

#include<cstring>

#define MAXN 55555

int lmax[MAXN<<2],rmax[MAXN<<2],mmax[MAXN<<2],cover[MAXN<<2];

void build(int l,int r,int id);

void update(int left,int right,int l,int r,int id,int value);

int query(int value,int l,int r,int id);

void pushdown(int id,int l,int r);

void pushup(int id,int l,int r);

int max(int a,int b);

int main()

{

     int n,m,op,value,left,right,i;

     while(scanf("%d%d",&n,&m)==2)

     {

         build(1,n,1);

         while(m--)

         {

             scanf("%d",&op);

             if(op==1)

             {

                 scanf("%d",&value);

                 if(value>mmax[1])

                     printf("0\n");

                 else

                 {

                   left=query(value,1,n,1);

                   printf("%d\n",left);

                   update(left,left+value-1,1,n,1,0);



                 }

             }

             else

             {

                 scanf("%d%d",&left,&right);

                 update(left,left+right-1,1,n,1,1);

             }

         }





     }





}

void build(int l,int r,int id)

{

    lmax[id]=rmax[id]=mmax[id]=(r-l+1);

    cover[id]=-1;

    if(l==r)

        return;

        int mid=l+r>>1;

    build(l,mid,id<<1);

    build(mid+1,r,id<<1|1);

}

void update(int left,int right,int l,int r,int id,int value)

{

    if(left<=l&&right>=r)

    {

        cover[id]=value;

        rmax[id]=mmax[id]=lmax[id]=(r-l+1)*value;

        return ;





    }

    if(l==r)

    return ;

    int mid=l+r>>1;

    pushdown(id,l,r);

    if(left<=mid)

        update(left,right,l,mid,id<<1,value);

    if(right>mid)

        update(left,right,mid+1,r,id<<1|1,value);

    pushup(id,l,r);









}

int query(int value,int l,int r ,int id)

{

    if(l==r)

        return l;

        pushdown(id,l,r);

    int mid=l+r>>1;

    if(mmax[id<<1]>=value)

          return query(value,l,mid,id<<1);

    else if(rmax[id<<1]+lmax[id<<1|1]>=value)

        return mid-rmax[id<<1]+1;

    else return query(value,mid+1,r,id<<1|1);

    //pushup(id,l,r);

}

void pushdown(int id,int l,int r)

{

    if(cover[id]!=-1)

    {

        int mid=l+r>>1;

        cover[id<<1]=cover[id<<1|1]=cover[id];

        lmax[id<<1]=mmax[id<<1]=rmax[id<<1]=(mid-l+1)*cover[id];

        lmax[id<<1|1]=rmax[id<<1|1]=mmax[id<<1|1]=(r-mid)*cover[id];

        cover[id]=-1;

    }

}

void pushup(int id,int l,int r)

{

    int mid=r+l>>1;

   rmax[id]=rmax[id<<1|1]+((rmax[id<<1|1]==r-mid)?rmax[id<<1]:0);

   lmax[id]=lmax[id<<1]+((lmax[id<<1]==mid-l+1)?lmax[id<<1|1]:0);

   mmax[id]=max(max(mmax[id<<1],mmax[id<<1|1]),rmax[id<<1]+lmax[id<<1|1]);

}

int max(int a,int b)

{

    return a>=b?a:b;

}