POJ 3667 Hotel（成段更新，区间合并）

题意：有N个房间，M次操作。1 a表示找到连续的长度为a的空房间，如果有多解，优先左边的，即表示入住。2 b len把起点为b长度的len的房间清空，即退房。

用co作为延迟标记，如果为-1表示当前区间是两个状态，如果是0表示一种状态，即区间内都没有人入住，如果是1也表示一种状态，表示满客。在线段树节点里保存三个值，端点左边的(lmx)、右边的(rmx)最长的连续的空闲的房间数，总的空闲的房间数目（mx）。查询的时候，依次查询端点左边的连续的空闲房间，左子区间的，左子区间和右子区间连接起来，右区间部分是否满足题意。区间合并还是一样。如果左子区间的lmax等于左子区间的dis，那么父区间的lmx，除了继承左子区间lmx之外，还要加上右子区间的lmx。右端点的同理。

/*代码风格更新后*/
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

#define LL(x) (x<<1)
#define RR(x) (x<<1|1)
#define MID(a,b) (a+((b-a)>>1))
const int N=50005;

struct node
{
	int lft,rht;
	int flag,mx,lmx,rmx;
	int len(){return rht-lft+1;}
	int mid(){return MID(lft,rht);}
	void init(){mx=lmx=rmx=len();}
	void fun(int tmp)
	{
		if(tmp==1) mx=lmx=rmx=0;
		else mx=lmx=rmx=len();
		flag=tmp;//忘记添加延迟标记
	}
};

int n,m;

struct Segtree
{
	node tree[N*4];
	void down(int ind)
	{
		if(tree[ind].flag)
		{
			tree[LL(ind)].fun(tree[ind].flag);
			tree[RR(ind)].fun(tree[ind].flag);
			tree[ind].flag=0;
		}
	}
	void up(int ind)
	{
		tree[ind].lmx=tree[LL(ind)].lmx;
		tree[ind].rmx=tree[RR(ind)].rmx;
		tree[ind].mx=max(tree[LL(ind)].mx,tree[RR(ind)].mx);

		if(tree[LL(ind)].lmx==tree[LL(ind)].len())
			tree[ind].lmx+=tree[RR(ind)].lmx;
		if(tree[RR(ind)].rmx==tree[RR(ind)].len())
			tree[ind].rmx+=tree[LL(ind)].rmx;

		tree[ind].mx=max(tree[ind].mx,max(tree[ind].lmx,tree[ind].rmx));
		tree[ind].mx=max(tree[ind].mx,tree[LL(ind)].rmx+tree[RR(ind)].lmx);
	}
	void build(int lft,int rht,int ind)
	{
		tree[ind].lft=lft;	tree[ind].rht=rht;
		tree[ind].flag=0;	tree[ind].init();
		if(lft!=rht)
		{
			int mid=tree[ind].mid();
			build(lft,mid,LL(ind));
			build(mid+1,rht,RR(ind));
		}
	}
	void updata(int st,int ed,int ind,int valu)
	{
		int lft=tree[ind].lft,rht=tree[ind].rht;
		if(st<=lft&&rht<=ed) tree[ind].fun(valu);
		else
		{
			down(ind);
			int mid=tree[ind].mid();
			if(st<=mid) updata(st,ed,LL(ind),valu);
			if(ed> mid) updata(st,ed,RR(ind),valu);
			up(ind);
		}
	}
	int query(int valu,int ind)
	{
		if(tree[ind].lft==tree[ind].rht) return tree[ind].lft;
		else
		{
		    down(ind);//查询的时候,记得....
            int pos;
            if(tree[LL(ind)].mx>=valu) pos=query(valu,LL(ind));
            else if(tree[LL(ind)].rmx+tree[RR(ind)].lmx>=valu) pos=tree[LL(ind)].rht-tree[LL(ind)].rmx+1;
            else pos=query(valu,RR(ind));
            up(ind);//查询的时候,记得....
            return pos;
		}
	}
}seg;
int main()
{
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		seg.build(1,n,1);
		while(m--)
		{
			int a,b,c,pos=0;
			scanf("%d",&a);
			if(a==1)
			{
				scanf("%d",&b);
				if(seg.tree[1].mx>=b)
				{
					pos=seg.query(b,1);
					seg.updata(pos,pos+b-1,1,1);
				}
				printf("%d\n",pos);
			}
			else
			{
				scanf("%d%d",&b,&c);
				seg.updata(b,b+c-1,1,-1);
			}
		}
	}
	return 0;
}

/*代码风格更新前*/
#include <iostream>
#include <cstdio>
using namespace std;
const int N=50005;
struct node
{
    int left,right,co;
    int lmax,rmax,mmax;
    int mid(){return left+(right-left)/2;}
    int dis(){return right-left+1;}
    void change(int a)
    {
        co=a;
        if(co==0) lmax=rmax=mmax=dis();
        else lmax=rmax=mmax=0;
    }
};
void unin(node &a,node &b,node &c)
{
    a.lmax=b.lmax;  a.rmax=c.rmax;
    a.mmax=max(max(b.mmax,c.mmax),b.rmax+c.lmax);
    if(b.lmax==b.dis()) a.lmax+=c.lmax;
    if(c.rmax==c.dis()) a.rmax+=b.rmax;
}
struct Segtree
{
    node tree[N*4];
    void build(int left,int right,int r)
    {
        tree[r].left=left;  tree[r].right=right;
        tree[r].lmax=tree[r].rmax=tree[r].mmax=tree[r].dis();
        tree[r].co=-1;
        if(left<right)
        {
            int mid=tree[r].mid();
            build(left,mid,r*2);
            build(mid+1,right,r*2+1);
        }
    }
    void updata(int be,int end,int r,int co)
    {
        if(be<=tree[r].left&&tree[r].right<=end)
        {
            tree[r].change(co);
        }
        else
        {
            if(tree[r].co!=-1)
            {
                tree[r*2].change(tree[r].co);
                tree[r*2+1].change(tree[r].co);
                tree[r].co=-1;
            }
            int mid=tree[r].mid();
            if(be<=mid) updata(be,end,r*2,co);
            if(end>mid) updata(be,end,r*2+1,co);
            unin(tree[r],tree[r*2],tree[r*2+1]);
        }
    }
    int query(int len,int r)
    {
        if(tree[r].lmax>=len) return tree[r].left;
        else if(tree[r*2].mmax>=len) return query(len,r*2);
        else if(tree[r*2].rmax+tree[r*2+1].lmax>=len) return tree[r*2].right-tree[r*2].rmax+1;
        else return query(len,r*2+1);
    }
}seg;
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    seg.build(1,n,1);
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        scanf("%d",&a);
        if(a==1)
        {
            scanf("%d",&b);
            if(seg.tree[1].mmax>=b)
            {
                int pos=seg.query(b,1);
                printf("%d\n",pos);
                seg.updata(pos,pos+b-1,1,1);
            }
            else puts("0");
        }
        else
        {
            scanf("%d%d",&b,&c);
            seg.updata(b,b+c-1,1,0);
        }
    }
    return 0;
}