POJ 3667 線段樹區間合併

【題目鏈接】
http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=10354

【解題報告】
題目大意：長度爲N的空位序列，有兩種操作：
1.把連續的a個位置填滿，如果有多種情況可以滿足，選擇最左邊的。
2.把從a開始連續的b個位置清空

這道題目非常類似動態區間最大和的解決方法。對於線段樹的節點我們維護三個量：
max_pre表示區間左端連續空位長度
max_sub,max_suf依次類推。
這三個量的更新方法可以參考動態區間最大和。

那麼每個節點的更新就變成了：
如果該點可以被查詢區間覆蓋，整體賦值，打上lazy標記；
否則將該節點的標記pushdown，在該節點的子樹裏繼續更新，知道查詢區間全部被更新；

查詢變成了這樣：
如果查詢區間完全落在當前節點的max_pre裏，就在它的左子樹裏查找，
如果查詢區間橫跨左子樹的max_suf和右子樹的max_pre,就直接返回連續區間起點（想想爲什麼）
如果查詢區間完全落在當前節點的max_suf裏，就在它的右子樹繼續查找。

這樣這個題就沒有任何難點了，是道很裸的區間合併問題。

【參考代碼】

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

const int maxn=50000+50;
int N,M;

struct Node
{
      int max_sub,max_pre,max_suf;
      int cover;  //-1表示未標記，0表示全部賦值爲0,1表示全部賦值爲1
      void sets(  int sum=0, int pre=0, int suf=0, int cover=-1  )
      {
            this->max_sub=sum; this->max_pre=pre;
            this->max_suf=suf; this->cover=cover;
      }
};
Node tree[maxn*4];

void build(  int O, int L, int R )
{
      if( L==R )
      {
            tree[O].sets(  1,1,1,-1  );
      }
      else
      {
            int mid=(L+R)/2;
            build(  O*2, L, mid );
            build( O*2+1, mid+1, R );
            tree[O].sets(   R-L+1, R-L+1, R-L+1,-1 );
      }
}


void pushdown(  int O, int L, int R  )
{
      int lc=O*2, rc=O*2+1;
      int mid=(R+L)/2;
      if(  tree[O].cover==0 )  //這段區間全部是空位
      {
            tree[lc].sets(  mid-L+1, mid-L+1, mid-L+1, 0  );
            tree[rc].sets(   R-mid, R-mid, R-mid, 0  );
            tree[O].cover=-1;
      }
      else if(  tree[O].cover==1 )
      {
            tree[lc].sets(  0,0,0,1 );
            tree[rc].sets( 0,0,0,1 );
            tree[O].cover=-1;
      }
}

void maintain( int O, int L, int R  )
{
      int lc=O*2,rc=O*2+1,mid=(L+R)/2;
      if( L<R )
      {
           tree[O].max_pre=tree[lc].max_pre;
           if(  tree[lc].max_pre==mid-L+1 )tree[O].max_pre+=tree[rc].max_pre;
           tree[O].max_suf=tree[rc].max_suf;
           if( tree[rc].max_suf==R-mid ) tree[O].max_suf+=tree[lc].max_suf;
           tree[O].max_sub=max(     max(  tree[lc].max_sub,tree[rc].max_sub ),tree[lc].max_suf+tree[rc].max_pre   );
      }
}

void update(  int O, int L, int R, int qL, int qR, int cur  )  //RE
{
      int lc=O*2,rc=O*2+1;

      if( qL<=L && R<=qR  )
      {

            if(  cur==0  )  tree[O].sets(   R-L+1,R-L+1,R-L+1,0 );
            else  tree[O].sets(  0,0,0,1  );
      }
      else
      {
            pushdown( O,L,R );
            int mid=(L+R)/2;
            if(  qL<=mid ) update(  lc, L,mid, qL,qR, cur );
            if(  qR>mid )  update( rc, mid+1,R, qL,qR, cur );
            maintain( O,L,R );
      }
}

int query( int O, int L, int R, int c  )   //
{
      if(   L==R )  return L;
      pushdown(O,L,R);
      int mid=(L+R)/2,lc=O*2,rc=O*2+1;

      if(  tree[lc].max_sub>=c )  return query(  lc,L,mid,c  );   //全部落在左區間
      else if(  tree[lc].max_suf+tree[rc].max_pre>=c  )   //跨越左右區間
      {
            return mid-tree[lc].max_suf+1;
      }
      else return query(  rc,mid+1,R,c );  //全部落在右區間
}

int main()
{
      while(~scanf( "%d%d",&N,&M ))
      {
            build( 1,1,N  );
            while(M--)
            {
                  int cur; scanf( "%d",&cur );
                  if( cur==1 )    //在最左邊放連續a個空位
                  {
                        int a;
                        scanf( "%d",&a );
                        if(  tree[1].max_sub<a  )  printf( "0\n"  );
                        else
                        {
                              int p=query( 1,1,N, a  );  //查詢a個連續空位的隊首
                              printf( "%d\n",p );
                              update(  1,1,N, p,p+a-1,1  );  //p..p+a-1的連續位置賦值爲1
                        }
                  }
                  else
                  {
                        int a,b;
                        scanf( "%d%d",&a,&b  );
                        update( 1,1,N,a,a+b-1,0 );
                  }
            }
      }

      return 0;
}