POJ 3667(线段树+lazy思想)

题目链接:http://poj.org/problem?id=3667

题目的意思很简单，给定你一个数字N，表示有N个房间(编号为1到N)，然后有M个询问操作:

1. 1 x:查询操作，如果N个房间中，存在有x个连续的房间，那么，输出满足条件的最小房间起始标号，并分配这x个房间，如果不存在，则输出0.

2. 2 x y:将[x,y]这段区间的房间置为空.

这是典型的一道线段树的区间合并的题目，具体的就不做过多的解释。这里顺便说一下的是，这道题目也体现出了关于内存分配策略的思想。(看了discuss才发现的，当时根本就没想到能跟内存分配联系起来。。。。).

具体实现代码:

#include
#include
#define MAX_N 50090
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
struct Node
{
    int front,rear;     //front:当前区间最左边连续的房间数目,rear:当前区间最右边连续的房间数目.
    int lazy,sum;      //lazy存在三种状态(-1,1,0):
                      //-1:表示当前区间没有懒操作标记，1:表示当前区间为满，0:表示当前区间为空
                     //sum值表示当前区间存在的最大连续的可分配的房间数目
}tree[MAX_N<<2];
void PushUp(int rt,int len)
{
    tree[rt].front = tree[rt<<1].front;
    tree[rt].rear = tree[rt<<1|1].rear;
    //判断左支树是否为满
    if(tree[rt].front == len - (len>>1))
        tree[rt].front +=tree[rt<<1|1].front;
    //判断右支树是否为满
    if(tree[rt].rear == (len>>1))
        tree[rt].rear +=tree[rt<<1].rear;
    tree[rt].sum = std::max(tree[rt<<1].rear+tree[rt<<1|1].front,std::max(tree[rt<<1].sum,tree[rt<<1|1].sum));
}
void PushDown(int rt,int len)
{
    if(tree[rt].lazy!=-1)
    {
        tree[rt<<1].lazy = tree[rt<<1|1].lazy = tree[rt].lazy ;
        tree[rt<<1].front = tree[rt<<1].rear = tree[rt<<1].sum = tree[rt].lazy ? 0 : len - (len>>1);
        tree[rt<<1|1].front = tree[rt<<1|1].rear = tree[rt<<1|1].sum = tree[rt].lazy ? 0 : (len>>1);
        tree[rt].lazy = -1;
    }
}
void build(int l,int r,int rt)
{
    tree[rt].rear = tree[rt].front = tree[rt].sum = r - l + 1;
    tree[rt].lazy = -1;
    if(l==r)
        return ;
    int m = (l+r)>>1;
    build(lson);
    build(rson);
}
int query(int len,int l,int r,int rt)
{
    if(l==r)
        return l;
    int m = (l+r)>>1;
    //递归查询左支，这里面存在一个小的优化，不过效率不怎么明显，只是快了10+ms而已
    if(len <= tree[rt<<1].sum )
        return len <= tree[rt<<1].front ? l : query(len,lson);
    //合并的区间能满足条件，直接返回
    else if(len <= tree[rt<<1].rear + tree[rt<<1|1].front)
        return m-tree[rt<<1].rear+1;
    //递归查询右支，与查询左支类似
    else
        return len <= tree[rt<<1|1].front ? m+1 : query(len,rson);
}
void update(int L,int R,int c,int l,int r,int rt)
{
    if(L<=l&&r<=R)
    {
        tree[rt].front=tree[rt].rear=tree[rt].sum= c ? 0 : r-l+1;
        tree[rt].lazy = c;
        return ;
    }
    PushDown(rt,r-l+1);
    int m = (l+r)>>1;
    if(L <= m)
        update(L,R,c,lson);
    if(R > m)
        update(L,R,c,rson);
    PushUp(rt,r-l+1);
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    build(1,n,1);
    while(m--)
    {
        int op,a,b;
        scanf("%d",&op);
        if(op&0x1)
        {
            scanf("%d",&a);
            printf("%d\n",b = a > tree[1].sum ? 0 : query(a,1,n,1));
            if(b)
                update(b,b+a-1,1,1,n,1);
        }
        else
        {
            scanf("%d%d",&a,&b);
            update(a,a+b-1,0,1,n,1);
        }
    }
    return 0;
}