poj 3667(区间合并)

题意:

有N个房间

有两种操作:

1 表示当前有Di个人要入住，且房间号必须连续，并输出最左边满足要求的,没有满足要求的输出0

2 表示从Xi房间开始总共Di个房间要退房。

解题思路:

在线段树的结构体里增加几个域值:

lsum : 表示从该结点的左端点开始的连续的个数。

rum : 同上相反

sum : 表示该结点最大连续值

lazy ：标记

所以：

我们可以向query 找到最左边个满足的房间的序号。。

判断左的sum>=要找得值 ，则往左子树走，否则往右子树走。

且在向上更新时：

      当前结点的lsum = 左子树的lsum

      当前结点的rsum = 右子树的rsum

       当前结点的sum = max （左子树.sum,max(右子树.sum,左子树.rsum+右子树.lsum)）;

注意:

query 与 update 要 向下更新

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXN0 50001
#define l1(x) ((x)<<1)
#define r1(x) ((x)>>1)
struct TRnode{
    int L,R,lsum,rsum,sum;
    int c;
};
TRnode TR[MAXN0<<2];
int max(int aa,int bb){
    return aa>bb?aa:bb;
}
void buildTR(int L,int R,int k){
    TR[k].L = L;
    TR[k].R = R;
    TR[k].c = 0;
    if(L==R){
        TR[k].lsum = TR[k].sum = TR[k].rsum = 1;
        return;
    }
    int mid = r1(L+R);
    int k1,k2;
    k1 = l1(k);
    k2 = k1+1;
    buildTR(L,mid,k1);
    buildTR(mid+1,R,k2);
    TR[k].lsum  = TR[k].rsum = TR[k].sum = TR[k1].sum+TR[k2].sum;
}
void pd(int k,int k1,int k11){
    if(TR[k].c==1){
        TR[k1].sum = TR[k1].rsum = TR[k1].lsum = TR[k].lsum;
        TR[k11].sum = TR[k11].lsum = TR[k11].rsum = TR[k].rsum;
    }
    else {
        TR[k1].lsum = TR[k1].R - TR[k1].L + 1;
        TR[k1].rsum = TR[k1].lsum;
        TR[k1].sum = TR[k1].rsum;
        TR[k11].lsum = TR[k11].R - TR[k11].L + 1;
        TR[k11].rsum = TR[k11].lsum;
        TR[k11].sum = TR[k11].lsum;
    }
    TR[k1].c = TR[k11].c = TR[k].c;
    TR[k].c = 0;
}
void pu(int k,int k1,int k11){
    int tmp0 = TR[k1].R - TR[k1].L+1;
    if(TR[k1].lsum == tmp0){
        TR[k].lsum = TR[k1].lsum + TR[k11].lsum;
    }
    else {
        TR[k].lsum = TR[k1].lsum;
    }
    tmp0 = TR[k11].R - TR[k11].L +1;
    if(tmp0==TR[k11].rsum){
        TR[k].rsum = TR[k11].rsum + TR[k1].rsum;
    }
    else {
        TR[k].rsum = TR[k11].rsum;
    }
    TR[k].sum = max(TR[k].lsum,max(TR[k].rsum,TR[k1].rsum+TR[k11].lsum));
    TR[k].sum = max(TR[k].sum,max(TR[k1].sum,TR[k11].sum));
}
int query(int D,int k){
    if(TR[k].sum<D){
        return 0;
    }
    int k1,k11,H;
    k1 = l1(k);
    k11 = k1 + 1;
    if(TR[k].c>0){
        pd(k,k1,k11);
    }
    if(TR[k1].sum>=D){
        H = query(D,k1);
    }
    else if(TR[k1].rsum+TR[k11].lsum>=D){
        H = TR[k1].R - TR[k1].rsum +1;
    }
    else {
        H =  query(D,k11);
    }
    //pu(k,k1,k11);
    return H;
}
void update(int L,int R,int k,int w){
    if(TR[k].L==L&&TR[k].R==R){
        if(w==0){
            TR[k].lsum = 0;
            TR[k].rsum = 0;
            TR[k].sum = 0;
            TR[k].c=1;
        }
        else {
            TR[k].lsum = TR[k].R - TR[k].L + 1;
            TR[k].rsum = TR[k].R - TR[k].L + 1;
            TR[k].sum = TR[k].lsum;
            TR[k].c = 2;
        }
        return;
    }
    int k1,k11;
    k1 = l1(k);
    k11 = k1 + 1;
    if(TR[k].c){
        pd(k,k1,k11);
    }
    int mid = r1(TR[k].L+TR[k].R);
    if(mid>=R){
        update(L,R,k1,w);
    }
    else if(mid<L){
        update(L,R,k11,w);
    }
    else {
        update(L,mid,k1,w);
        update(mid+1,R,k11,w);
    }
    pu(k,k1,k11);
}
int main(){
    int N,M,W,D,X;
    //freopen("/Users/gatsby/desktop/hotel/hotel.2.in", "r", stdin);
    //freopen("/Users/gatsby/desktop/out", "w", stdout);
    while(scanf("%d%d",&N,&M)!=EOF){
        
        buildTR(1,N,1);
        while(M--){
            scanf("%d",&W);
            if(W==1){
                scanf("%d",&D);
                int ans = query(D, 1);
                printf("%d\n",ans);
                if(ans)
                    update(ans,ans+D-1,1,0);
            }
            else {
                scanf("%d%d",&X,&D);
                update(X, X+D-1, 1, 1);
            }
        }
    }
    
    return 0;
}