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;
}