poj 3667

线段树

题意：有一个线段，从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 <cstdio>
#include <stack>
#include <set>
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <list>
#include <functional>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <string>
#include <map>
#include <iomanip>
#include <cmath>
#define LL long long
#define ULL unsigned long long
#define SZ(x) (int)x.size()
#define Lowbit(x) ((x) & (-x))
#define MP(a, b) make_pair(a, b)
#define MS(arr, num) memset(arr, num, sizeof(arr))
#define PB push_back
#define F first
#define S second
#define ROP freopen("input.txt", "r", stdin);
#define MID(a, b) (a + ((b - a) >> 1))
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define lrt rt << 1
#define rrt rt << 1|1
#define root 1,n,1
#define BitCount(x) __builtin_popcount(x)
#define BitCountll(x) __builtin_popcountll(x)
#define LeftPos(x) 32 - __builtin_clz(x) - 1
#define LeftPosll(x) 64 - __builtin_clzll(x) - 1
const double PI = acos(-1.0);
const LL INF = (((LL)1)<<62)+1;
using namespace std;
const double eps = 1e-5;
const int MAXN = 300 + 10;
const int MOD = 1000007;
const double M=1e-8;
const int N=50100;
typedef pair<int, int> pii;
typedef pair<int, string> pis;
const int d[4][2]={{0,1},{0,-1},{-1,0},{1,0}};
int n,m;
struct tree
{
    int len,llen,rlen,lazy;
};
tree st[N<<2];
void build(int l,int r,int rt)
{
    st[rt].len=st[rt].llen=st[rt].rlen=r-l+1;
    st[rt].lazy=-1;
    if (l==r) return ;
    int mid=MID(l,r);
    build(lson);
    build(rson);
}
void pushup(int l,int r,int rt)  // 区间合并
{
    st[rt].llen=st[lrt].llen;
    st[rt].rlen=st[rrt].rlen;
    int mid=MID(l,r);
    if (st[rt].llen==mid-l+1) st[rt].llen+=st[rrt].llen;     // 左区间全空
    if (st[rt].rlen==r-mid) st[rt].rlen+=st[lrt].rlen;      // 右区间全空
    st[rt].len=max(max(st[lrt].len,st[rrt].len),st[lrt].rlen+st[rrt].llen);
}
void pushdown(int l,int r,int rt)
{
    if (st[rt].lazy!=-1) {
        st[lrt].lazy=st[rrt].lazy=st[rt].lazy;
        if (st[rt].lazy) {
            st[lrt].len=st[lrt].llen=st[lrt].rlen=0;
            st[rrt].len=st[rrt].llen=st[rrt].rlen=0;
        }
        else {
            int mid=MID(l,r);
            st[lrt].len=st[lrt].llen=st[lrt].rlen= mid-l+1;
            st[rrt].len=st[rrt].llen=st[rrt].rlen=r-mid;
        }
        st[rt].lazy=-1;
    }
}
void updata(int a,int b,int c,int l,int r,int rt)
{
    if (a>r || b<l) return ;
    if (a<=l && r<=b) {
        st[rt].lazy=c;
        if (!c) {    //  check out
            st[rt].len=st[rt].llen=st[rt].rlen=r-l+1;
        }
        else {      //  check in
            st[rt].len=st[rt].llen=st[rt].rlen=0;
        }
        return ;
    }
    pushdown(l,r,rt);
    int mid=MID(l,r);
    if (a<=mid) updata(a,b,c,lson);
    if (b>mid) updata(a,b,c,rson);
    pushup(l,r,rt);
}
int query(int len,int l,int r,int rt)
{
    if (l==r && len==1) return l;
    pushdown(l,r,rt);
    int mid=MID(l,r);
    if (st[lrt].len>=len) return query(len,lson);       // 去左区间寻找
    else if (st[lrt].rlen+st[rrt].llen>=len) return mid-st[lrt].rlen+1;  //  满足题意的区间跨越了两段区间
    else if (st[rrt].len>=len) return query(len,rson);  // 去右区间寻找
    return 0;
}
int main()
{
    int i,j;
    while(~scanf("%d%d",&n,&m))
    {
        int a,b,c;
        build(root);
        for (i=0;i<m;i++) {
            scanf("%d",&a);
            if(a==1) {
                scanf("%d",&b);
                int t=query(b,root);
                printf("%d\n",t);
                if (t)   // 忘记加这个句子，结果多调了几个小时，悲剧啊~~~~
                   updata(t,t+b-1,1,root);
            }
            else {
                scanf("%d%d",&b,&c);
                updata(b,b+c-1,0,root);
            }
        }
    }
}