• POJ 3667 线段树区间合并


    http://www.cnblogs.com/scau20110726/archive/2013/05/07/3065418.html

    用线段树,首先要定义好线段树的节点信息,一般看到一个问题,很难很快能确定线段树要记录的信息
    做线段树不能为了做题而做,首先线段树是一种辅助结构,它是为问题而生的,因而必须具体问题具体分析
    回忆一下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 <iostream>
    #include <string>
    #include <cstring>
    #include <cstdlib>
    #include <cstdio>
    #include <cmath>
    #include <algorithm>
    #include <stack>
    #include <queue>
    #include <cctype>
    #include <vector>
    #include <iterator>
    #include <set>
    #include <map>
    #include <sstream>
    using namespace std;
    
    #define mem(a,b) memset(a,b,sizeof(a))
    #define pf printf
    #define sf scanf
    #define spf sprintf
    #define pb push_back
    #define debug printf("!
    ")
    #define MAXN 65535*2
    #define MAX(a,b) a>b?a:b
    #define blank pf("
    ")
    #define LL long long
    #define ALL(x) x.begin(),x.end()
    #define INS(x) inserter(x,x.begin())
    #define pqueue priority_queue
    #define INF 0x3f3f3f3f
    
    #define ls (rt<<1)
    #define rs (rt<<1|1)
    
    int n,m;
    
    int a[MAXN<<3],col[MAXN<<3],lsum[MAXN<<3],rsum[MAXN<<3],ans;
    
    void build(int l,int r,int rt)
    {
        a[rt] = lsum[rt] = rsum[rt] = r-l+1;
        col[rt] = -1;
        if(l==r) return;
        int mid = (l+r)>>1;
        build(l,mid,ls);
        build(mid+1,r,rs);
    }
    
    void PushDown(int rt,int k)
    {
        if(col[rt]!=-1)
        {
            col[ls] = col[rs] = col[rt];
            lsum[ls] = rsum[ls] = a[ls] = col[rt]?0:(k-(k>>1));
            lsum[rs] = rsum[rs] = a[rs] = col[rt]?0:(k>>1);
            col[rt] = -1;
        }
    }
    
    void PushUp(int rt,int k)
    {
        lsum[rt] = lsum[ls];
        rsum[rt] = rsum[rs];
    
        if(lsum[rt] == k-(k>>1)) lsum[rt]+=lsum[rs];
        if(rsum[rt] == k>>1) rsum[rt]+=rsum[ls];
    
        a[rt] = max(rsum[ls] + lsum[rs],max(a[ls],a[rs]));
    }
    
    void update(int val,int L,int R,int l,int r,int rt)
    {
        if(L <= l && r <= R)
        {
            a[rt] = lsum[rt] = rsum[rt] = val?0:r-l+1;
            col[rt] = val;
            return;
        }
        PushDown(rt,r-l+1);
        int mid = (l+r)>>1;
        if(L <= mid) update(val,L,R,l,mid,ls);
        if(R > mid) update(val,L,R,mid+1,r,rs);
        PushUp(rt,r-l+1);
    }
    
    int query(int c,int l,int r,int rt)
    {
        if(l==r) return 1;
    
        PushDown(rt,r-l+1);
    
        int mid = (l+r)>>1;
        if(a[ls]>=c) return query(c,l,mid,ls);
        else if(rsum[ls]+lsum[rs] >= c) return mid - rsum[ls] +1;
        else return query(c,mid+1,r,rs);
    }
    
    
    int main()
    {
        int i,j;
        while(~sf("%d%d",&n,&m))
        {
            build(1,n,1);
            for(i=0;i<m;i++)
            {
                int tmp,c,d;
                sf("%d",&tmp);
                if(tmp==1)
                {
                    sf("%d",&c);
                    if(a[1]<c) pf("0
    ");
                    else
                    {
                        int v = query(c,1,n,1);
                        pf("%d
    ",v);
                        update(1,v,v+c-1,1,n,1);
                    }
                }
                else
                {
                    sf("%d%d",&c,&d);
                    update(0,c,c+d-1,1,n,1);
                }
            }
        }
        return 0;
    
    }
  • 相关阅读:
    linux上mysql安装详细教程
    druid部署
    druid.io本地集群搭建 / 扩展集群搭建
    CentOS7.1.x+Druid 0.12 集群配置
    Python小项目四:实现简单的web服务器
    hadoop学习---运行第一个hadoop实例
    Hadoop集群完全分布式坏境搭建
    mysql备份与恢复
    mysql登录的三种方式
    nginx代理,负载均衡
  • 原文地址:https://www.cnblogs.com/qlky/p/5745065.html
Copyright © 2020-2023  润新知