POJ hotel 线段数维护区间长度，输出最左端值（hdu 屌丝女神）

分类：线段树维护长度题目,连续区间

题目大意：Hotel有N（1 ≤ N ≤ 50,000）间rooms，并且所有的rooms都是连续排列在同一边，groups需要check in 房间，要求房间的编号为连续的r..r+Di-1并且r是最小的；visitors同样可能check out，并且他们每次check out都是编号为Xi ..Xi +Di-1 (1 ≤ Xi ≤ N-Di+1)的房间，题目的输入有两种样式：
1  a     :  groups需要check in  a间编号连续的房间
2  a   b ： visitors  check out 房间，其中房间编号是 a…a+b-1

要求对于每次request，输出为groups分配数目为a的房间中编号最小的房间编号（left）

题意：有一个线段，从1到n，下面m个操作，操作分两个类型，以1开头的是查询操作，以2开头的是更新操作
1 w  表示在总区间内查询一个长度为w的可用区间，并且要最靠左，能找到的话返回这个区间的左端点并占用了这个区间，找不到返回0 
好像n=10 ， 1 3 查到的最左的长度为3的可用区间就是[1,3]，返回1，并且该区间被占用了
2 a len , 表示从单位a开始，清除一段长度为len的区间（将其变为可用，不被占用），不需要输出
因此看sample的话就可以理解了

记录一下自己的感悟：
用线段树，首先要定义好线段树的节点信息，一般看到一个问题，很难很快能确定线段树要记录的信息
做线段树不能为了做题而做，首先线段树是一种辅助结构，它是为问题而生的，因而必须具体问题具体分析
回忆一下RMQ问题，其实解决RMQ有很多方法，根本不需要用到线段树，用线段树解决RMQ，其实是利用线段树的性质来辅助解决这个问题
回忆一下求矩形面积并或周长并的问题，一般使用的是扫描线法，其实扫描线法和线段树一点关系都没有，扫描线法应该归为计算几何的算法，
使用线段树只是为了辅助实现扫描线法
因而回到这题，要解，必须分析问题本质，才去思考怎么用线段树来辅助，另外为什么能用线段树辅助是可行的，这个问题似乎更有价值

1 查询操作，找一段长度为W的没被覆盖的最左的区间
2 更新操作，将某段连续的区域清空

更新操作相对容易解决，关键是怎么实现查询操作
既然是要找一段长度至少为W的区间，要做到这点，其实不难，我们可以在每个线段树的节点里增加一个域tlen，表示该区间可用的区间的最大长度，
至于这个tlen区间的具体位置在哪里不知道，只是知道该区间内存在这么一段可用的区间，并且注意，这个tlen表示的是最大长度，该节点可能有多段可用的区间，但是最长的长度是tlen
记录了这个信息，至少能解决一个问题，就是能不能找到一个合适的区间。如果查询的区间长度W > 总区间的tlen，那么查询一定是失败的（总区间中可以的最大区间都不能满足那就肯定失败）
但这远远不够，其一查询是要返回区间的具体位置的，这里无法返回位置，另外是要查询最左区间，最左的且满足>=W的区间可能不是这个tlen区间

那么我们进一步思考这个问题
首先我们先增加两个域,llen,rlen
llen表示一个区间从最左端开始可用的且连续的最大长度
例如区间[1,5]，覆盖情况为[0,0,0,1,1]，llen = 3，从最左端有3格可以利用
区间[1,5]，覆盖情况为[1,0,0,0,0]，llen = 0，因为从最左端开始找不到1格可用的区间
rlen表示一个区间从最右端开始可用的且连续的最大长度
例如区间[1,5]，覆盖情况为[1,0,1,0,0]，rlen = 2，从最右端有2格可以利用
区间[1,5]，覆盖情况为[0,0,0,0,1]，rlen = 0，因为从最右端开始找不到1格可用的区间
对于一个区间，我们知道它左半区间的tlen，和右半区间的tlen，如果左半区间的tlen >= W ,那么我们一定能在左边找到（满足最左），所以可以深入到左半区间去确定该区间的具体位置
如果左端的不满足，那么我们要先考虑横跨两边的区间（因为要满足最左），因而记录的llen,rlen可以派上用场，一段横跨的区间，
那么是 左边区间rrlen + 右边区间llen ，如果满足的话，就是该区间了，它的位置也是可以确定的
如果横跨的区间不满足，那么就在右半区间找，如果右半区间的tlen >= W , 那么可以在右半区间找到，所以深入到右半区间去确定它的具体位置，否则的话，整个查询就失败了

可见查询是建立在tlen,llen,rlen这个信息之上的，而每次查询后其实伴随着修改，而且还有专门的修改操作，这些修改操作都会改变tlen,llen,rlen的值，所以在更新的时候是时刻维护这些信息

关于这3个信息的维护
当前区间的tlen = max{ 左半区间tlen , 右半区间tlen , 左半区间rlen+右半区间llen} （这个不难理解吧，取左右较大的那个，或者横跨中间的那个）

如果左半区间全部可以用: 当前区间llen = 左半区间llen(tlen) + 右半区间llen 
左半区间部分能用: 当前区间llen = 左半区间llen

如果右半区间全部能用: 当前区间rlen = 右半区间rlen(tlen) + 左半区间rlen
右半区间部分能用: 当前区间rlen = 右半区间rlen

这样就全部维护好了

#include <stdio.h>
#include <algorithm>
#include <iostream>
using namespace std;
#define lson l, m, rt<<1  
#define rson m+1, r, rt<<1|1  
const int maxn = 50001;  
int n, mNum, op, a, b;  
int sum[maxn<<2], lsum[maxn<<2], rsum[maxn<<2], lazy[maxn<<2];//lazy表示是否被占用的状态 0未占用 1占用了 -1表示无lazy标记
//长度是空闲长度  
void BuildTree(int l, int r, int rt)  
{  
    lazy[rt] = -1;  
    lsum[rt] = rsum[rt] = sum[rt] = r-l+1;  
    if (l == r)  
        return ;  
    int m = (l+r)>>1;  
    BuildTree(lson);  
    BuildTree(rson);  
}  
  
void PushDown(int rt, int len)  
{  
    if (lazy[rt] != -1)  
    {    
        lazy[rt<<1] = lazy[rt<<1|1] = lazy[rt];  
        lsum[rt<<1] = rsum[rt<<1] = sum[rt<<1] = lazy[rt]==1 ? 0:(len-(len>>1)); //lazy[rt]==1 ——占满了  
        lsum[rt<<1|1] = rsum[rt<<1|1] = sum[rt<<1|1] = lazy[rt]==1 ? 0:(len>>1);  
        lazy[rt] = -1;  
    }  
}  
  
int query(int w, int l, int r, int rt)  
{  
    if (l == r)
        return l;//left  
      
    PushDown(rt, r-l+1);     
      
    int m = (l+r)>>1;  
    if (sum[rt<<1] >= w)    //左连续区间长度   
        return query(w, lson);  
    else if (rsum[rt<<1]+lsum[rt<<1|1] >= w) // 左区间后半部分与右区间左半部分长度   
        return m-rsum[rt<<1]+1;  
    else                    // 右连续区间长度   
        return query(w, rson);  
}  
  
  
void PushUp(int rt, int len)  
{  
    lsum[rt] = lsum[rt<<1];   // 左区间的左半部分   
    rsum[rt] = rsum[rt<<1|1]; // 右区间的右半部分   
      
    if (lsum[rt] == len-(len>>1))  
        lsum[rt] += lsum[rt<<1|1];  
    if (rsum[rt] == len>>1)  
        rsum[rt] += rsum[rt<<1];  
      
    sum[rt] = max(rsum[rt<<1]+lsum[rt<<1|1], max(sum[rt<<1], sum[rt<<1|1]));  
}  
  
void UpDate(int L, int R, int c, int l, int r, int rt)  
{  
    if (L<=l && r<=R)  
    {  
        lsum[rt] = rsum[rt] = sum[rt] = c ? 0 : r-l+1;  
        lazy[rt] = 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()  
{  
    scanf("%d %d", &n, &mNum);  
    BuildTree(1, n, 1);  
    for (int i=1; i<=mNum; ++i)  
    {  
        scanf("%d", &op);  
        if (op == 1)  
        {     
            scanf("%d", &a);  
            if (sum[1] < a)  
                printf("0\n");   
            else  
            {  
                int pos = query(a, 1, n, 1);  
                printf("%d\n", pos);  
                UpDate(pos, pos+a-1, 1, 1, n, 1);     
            }  
        }  
        else  
        {  
            scanf("%d %d", &a, &b);  
            UpDate(a, a+b-1, 0, 1, n, 1);    
        }  
    }  
      
    return 0;  
}