poj 3667 Hotel （线段树的合并操作）

Hotel

The cows are journeying north to Thunder Bay in Canada to gain cultural enrichment and enjoy a vacation on the sunny shores of Lake Superior. Bessie, ever the competent travel agent, has named the Bullmoose Hotel on famed Cumberland Street as their vacation residence. This immense hotel has N (1 ≤ N ≤ 50,000) rooms all located on the same side of an extremely long hallway (all the better to see the lake, of course).

The cows and other visitors arrive in groups of size D_i (1 ≤ D_i ≤ N) and approach the front desk to check in. Each group i requests a set of D_i contiguous rooms from Canmuu, the moose staffing the counter. He assigns them some set of consecutive room numbers r..r+D_i-1 if they are available or, if no contiguous set of rooms is available, politely suggests alternate lodging. Canmuu always chooses the value of rto be the smallest possible.

Visitors also depart the hotel from groups of contiguous rooms. Checkout i has the parameters X_i and D_i which specify the vacating of rooms X_i ..X_i +D_i-1 (1 ≤ X_i ≤ N-D_i+1). Some (or all) of those rooms might be empty before the checkout.

Your job is to assist Canmuu by processing M (1 ≤ M < 50,000) checkin/checkout requests. The hotel is initially unoccupied.

Input

* Line 1: Two space-separated integers: N and M
* Lines 2..M+1: Line i+1 contains request expressed as one of two possible formats: (a) Two space separated integers representing a check-in request: 1 and D_i (b) Three space-separated integers representing a check-out: 2, X_i, and D_i

Output

* Lines 1.....: For each check-in request, output a single line with a single integer r, the first room in the contiguous sequence of rooms to be occupied. If the request cannot be satisfied, output 0.

Sample Input

10 6
1 3
1 3
1 3
1 3
2 5 5
1 6

Sample Output

1
4
7
0
5

线段树

题意：有一个线段，从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

这样就全部维护好了

代码学习了小HH的代码风格

楼主太懒，没心思写这个代码了。

体谅一下，贴了https://www.cnblogs.com/scau20110726/archive/2013/05/07/3065418.html

 #include <cstdio>
 #include <cstring>
 #define lch(i) ((i)<<1)
 #define rch(i) ((i)<<1|1)
 #define max(a,b) ((a)>(b)?(a):(b))
 #define min(a,b) ((a)<(b)?(a):(b))
 #define N  50010
 #define INF  0x3f3f3f3f

 struct node
 {
     int l,r;
     int mark;
     int tlen,llen,rlen;
     int mid(){
         return (l+r)>>;
     }
     int cal_len(){
         return r-l+;
     }
     void updata_len(){
         tlen = llen = rlen = ( mark ?  : cal_len() );
     }
 }t[*N];

 void build(int l ,int r ,int rt)
 {
     t[rt].l = l; t[rt].r = r;
     t[rt].tlen = t[rt].llen = t[rt].rlen = t[rt].cal_len();
     t[rt].mark = ;
     if(l == r) return ;
     int mid = t[rt].mid();
     build(l , mid , lch(rt));
     build(mid+ , r , rch(rt));
     return ;
 }

 int query(int w ,int rt)
 {
     if(t[rt].l == t[rt].r && w == ) //叶子特判
         return t[rt].l;
     if(t[rt].mark != -) //延迟标记，父亲信息传递给儿子
     {
         t[lch(rt)].mark = t[rch(rt)].mark = t[rt].mark;
         t[rt].mark = -;
         t[lch(rt)].updata_len(); //传递信息后更新孩子的区间覆盖情况
         t[rch(rt)].updata_len(); //传递信息后更新孩子的区间覆盖情况
     }
     if(t[lch(rt)].tlen >= w) //左孩子的可用区间可以满足，那么一定在左孩子区间内
         return query(w , lch(rt));
     else if(t[lch(rt)].rlen + t[rch(rt)].llen >= w) //横跨左右孩子且连续的区间可以满足，那么可以直接返回下标
         return ( t[lch(rt)].r - t[lch(rt)].rlen +  );
     else if(t[rch(rt)].tlen >= w) //右孩子的可用区间可以满足，那么去右孩子处找
         return query(w , rch(rt));
     else //找不到可用的区间
         return ;
 }

 void updata(int l ,int r ,int val ,int rt)
 {
     if(t[rt].l == l && t[rt].r == r)
     {
         t[rt].mark = val;
         t[rt].updata_len();
         return ;
     }
     if(t[rt].mark != -) //延迟标记，父亲信息传递给儿子
     {
         t[lch(rt)].mark = t[rch(rt)].mark = t[rt].mark;
         t[rt].mark = -;
         t[lch(rt)].updata_len(); //传递信息后更新孩子的区间覆盖情况
         t[rch(rt)].updata_len(); //传递信息后更新孩子的区间覆盖情况
     }
     int mid = t[rt].mid();
     if(l > mid) //修改的区间在右孩子
         updata(l , r , val , rch(rt));
     else if(r <= mid) //修改的区间在左孩子
         updata(l , r , val , lch(rt));
     else
     {
         updata(l , mid , val , lch(rt));
         updata(mid+ , r , val , rch(rt));
     }
     int tmp = max(t[lch(rt)].tlen , t[rch(rt)].tlen);
     t[rt].tlen = max(tmp , t[lch(rt)].rlen + t[rch(rt)].llen);
     t[rt].llen = t[lch(rt)].llen;
     t[rt].rlen = t[rch(rt)].rlen;
     if(t[lch(rt)].tlen == t[lch(rt)].cal_len() )
         t[rt].llen += t[rch(rt)].llen;
     if(t[rch(rt)].tlen == t[rch(rt)].cal_len() )
         t[rt].rlen += t[lch(rt)].rlen;
     return ;
 }

 int main()
 {
     int n,m;
     scanf("%d%d",&n,&m);
     build(,n,);
     while(m--)
     {
         int choose;
         scanf("%d",&choose);
         if(choose == ) //查询操作
         {
             int w;
             scanf("%d",&w);
             int index = query(w,);
             printf("%d\n",index);
             if(index)
                 updata(index , index+w- ,  , );
         }
         else
         {
             int l,len;
             scanf("%d%d",&l,&len);
             updata(l , l+len- ,  , );
         }
     }
     return ;
 }