hdu 5412 CRB and Queries 求动态区间第k小 树套树

最新推荐文章于 2021-03-06 13:39:18 发布
最新推荐文章于 2021-03-06 13:39:18 发布
阅读量754 收藏
点赞数
分类专栏： 线段树 树 文章标签： 树状数组 区间第k值 SBT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/inf_force/article/details/47859681
版权

题意：
给n个数，然后有两个操作
1.把第i个点的值修改为v
2.求[l,r]区间内第k小的数

树状数组+平衡树。
我写了两份代码：树状数组+SBT和树状数组+Treap
代码：

//author: CHC
//First Edit Time:  2015-08-20 14:10
#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <set>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <algorithm>
#include <limits>
#include <time.h>
using namespace std;
typedef long long LL;
const int MAXN=1e+5 + 1000;
const int INF = numeric_limits<int>::max();
const LL LL_INF= numeric_limits<LL>::max();
struct SBT
{
    int left,right,size,key;
    void Init()
    {
        left=right=0;
        size=1;
    }
}tree[MAXN*30];
int tot,root[MAXN<<2],n;
void left_rotate(int &x)//左旋
{
    int y=tree[x].right;
    tree[x].right=tree[y].left;
    tree[y].left=x;
    tree[y].size=tree[x].size;
    tree[x].size=tree[tree[x].left].size+tree[tree[x].right].size+1;
    x=y;
}
void right_rotate(int &x)//右旋
{
    int y=tree[x].left;
    tree[x].left=tree[y].right;
    tree[y].right=x;
    tree[y].size=tree[x].size;
    tree[x].size=tree[tree[x].left].size+tree[tree[x].right].size+1;
    x=y;
}
void maintain(int &x,int flag)
{
    if(flag==0)
    {
        if(tree[tree[tree[x].left].left].size > tree[tree[x].right].size)
            right_rotate(x);
        else if(tree[tree[tree[x].left].right].size > tree[tree[x].right].size)
            left_rotate(tree[x].left),right_rotate(x);
        else return;
    }
    else
    {
        if(tree[tree[tree[x].right].right].size > tree[tree[x].left].size)
            left_rotate(x);
        else if(tree[tree[tree[x].right].left].size > tree[tree[x].left].size)
            right_rotate(tree[x].right),left_rotate(x);
        else return;
    }
    maintain(tree[x].left,0);
    maintain(tree[x].right,1);
    maintain(x,0);
    maintain(x,1);
}
//插入元素，相同元素放在右子树中
void insert(int &x,int key)
{
    if(x==0)
    {
        x=++tot;
        tree[x].Init();
        tree[x].key=key;
    }
    else
    {
        tree[x].size++;
        if(key<tree[x].key)insert(tree[x].left,key);
        else insert(tree[x].right,key);
        maintain(x,key>=tree[x].key);
    }
}
//删除key值的元素
int del(int &x,int key)
{
    if(!x)return 0;
    tree[x].size--;
    if(key==tree[x].key || (key<tree[x].key&&tree[x].left==0)
            || (key>tree[x].key&&tree[x].right==0))
    {
        if(tree[x].left && tree[x].right)
        {
            int p=del(tree[x].left,key+1);
            tree[x].key=tree[p].key;
            return p;
        }
        else
        {
            int p=x;
            x=tree[x].left+tree[x].right;
            return p;
        }
    }
    else return del(key<tree[x].key?tree[x].left:tree[x].right,key);
}
int _rank(int x,int val){
    if(x==0)return 0;
    if(tree[x].key<=val)return tree[tree[x].left].size+1+_rank(tree[x].right,val);
    return _rank(tree[x].left,val);
}
void print(int x,int d){
    if(!x)return ;
    printf("%d %d\n",tree[x].key,d);
    print(tree[x].left,d+1);print(tree[x].right,d+1);
}
int A[MAXN];
void Add(int x,int v){
    while(x<=n){
        //printf("x:%d\n",x);
        insert(root[x],v);
        x+=x&-x;
    }
}
void Del(int x,int v){
    while(x<=n){
        del(root[x],v);
        x+=x&-x;
    }
}
int Sum(int x,int v){
    int cnt=0;
    while(x>0){
        cnt+=_rank(root[x],v);
        x-=x&-x;
    }
    return cnt;
}
struct Q {
    int type,l,r,v;
}cs[MAXN];
int res[MAXN*2];
int main()
{
    //int size = 256 << 20; // 256MB  
    //char *p = (char*)malloc(size) + size;  
    //__asm__("movl %0, %%esp\n" :: "r"(p));
    //freopen("1007.in","r",stdin);
    //freopen("10071.out","w",stdout);
    //time_t now=clock();
    int q;
    while(~scanf("%d",&n)){
        memset(root,0,sizeof(root));
        tot=0;
        res[0]=0;
        for(int i=1;i<=n;i++)scanf("%d",&A[i]),res[++res[0]]=A[i];
        scanf("%d",&q);
        for(int i=0;i<q;i++){
            scanf("%d",&cs[i].type);
            if(cs[i].type==1){
                scanf("%d%d",&cs[i].l,&cs[i].v);
                res[++res[0]]=cs[i].v;
            }
            else {
                scanf("%d%d%d",&cs[i].l,&cs[i].r,&cs[i].v);
            }
        }
        sort(res+1,res+1+res[0]);
        res[0]=unique(res+1,res+1+res[0])-res-1;
        for(int i=0;i<q;i++){
            if(cs[i].type==1){
                cs[i].v=lower_bound(res+1,res+1+res[0],cs[i].v)-res;
            }
        }
        //printf("res0:%d\n",res[0]);
        //for(int i=1;i<=res[0];i++)printf("%d ",res[i]);
        //puts("");
        for(int i=1;i<=n;i++)A[i]=lower_bound(res+1,res+1+res[0],A[i])-res;
        //for(int i=1;i<=n;i++)printf("%d ",A[i]);
        //puts("");
        //build(1,n,1);
        //print(root[1],0);
        //puts("here__");
        for(int i=1;i<=n;i++){
            Add(i,A[i]);
        }
        //puts("here");
        for(int i=0;i<q;i++){
            if(cs[i].type==1){
                //update(1,n,1,cs[i].l,cs[i].v);
                Del(cs[i].l,A[cs[i].l]);
                Add(cs[i].l,cs[i].v);
                A[cs[i].l]=cs[i].v;
            }
            else {
                int l=1,r=res[0],ans=res[0];
                while(l<=r){
                    int mid=(l+r)>>1;
                    int t=Sum(cs[i].r,mid)-Sum(cs[i].l-1,mid);
                    if(t>=cs[i].v){
                        ans=mid;
                        r=mid-1;
                    }
                    else l=mid+1;
                }
                printf("%d\n",res[ans]);
            }
        }
    }
    //printf("%.2lf\n",1.0*(clock()-now)/CLOCKS_PER_SEC);
    return 0;
}

代码2：

//author: CHC
//First Edit Time:    2015-08-20 12:15
#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <set>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <algorithm>
#include <limits>
using namespace std;
typedef long long LL;
const int MAXN=1e+5 + 1000;
const int INF = numeric_limits<int>::max();
const LL LL_INF= numeric_limits<LL>::max();
class Treap {
    public:
        struct node {
            node *ch[2];
            int v,p,sz;
            node(int _v,node *_n){ v=_v; ch[0]=ch[1]=_n; p=rand(); sz=1; }
            void update(){sz=ch[0]->sz+ch[1]->sz+1;}
            void fixch(node *left,node *right){ch[0]=left;ch[1]=right;}
        };
        node *root,*null;
        Treap(){
            null=new node(0,0);
            null->fixch(null,null); null->sz=0;
            root=null;
        }
        void rotate(node *&t,bool d){
            node *_t=t->ch[d];
            t->ch[d]=_t->ch[!d];
            _t->ch[!d]=t;
            t->update();
            _t->update();
            t=_t;
        }
        void __insert(node *&t,int val){
            if(t==null){
                t=new node(val,null);
                return ;
            }
            bool d=(t->v < val);
            __insert(t->ch[d],val);
            if(t->ch[d]->p < t->p)rotate(t,d);
            t->update();
        }
        void __del(node *&t,int val){
            if(t==null)return ;
            if(t->v==val){
                node *tmp=t;
                if(t->ch[0]==null){
                    t=t->ch[1];
                    delete tmp;
                    return ;
                }
                if(t->ch[1]==null){
                    t=t->ch[0];
                    delete tmp;
                    return ;
                }
                bool d=t->ch[1]->p < t->ch[0]->p;
                rotate(t,d);
                __del(t->ch[!d],val);
            }
            else {
                bool d=(t->v < val);
                __del(t->ch[d],val);
            }
            t->update();
        }
        int __rank(node *t,int val){
            if(t==null)return 0;
            if(t->v <= val)return t->ch[0]->sz+1+__rank(t->ch[1],val);
            //return t->ch[1]->sz+1+__rank(t->ch[0],val);
            return __rank(t->ch[0],val);
        }
        void __clean(node *&t){
            if(t==null)return ;
            if(t->ch[0]!=null)__clean(t->ch[0]);
            if(t->ch[1]!=null)__clean(t->ch[1]);
            delete t;
            t=null;
        }
        void insert(int val){ __insert(root,val); }
        void del(int val){ __del(root,val); }
        int rank(int val){ return __rank(root,val);}
        void clean(){ __clean(root); }
        ~Treap(){ clean(); delete null; }
}tr[MAXN];
#define lson L,mid,rt<<1
#define rson mid+1,R,rt<<1|1
int A[MAXN],n;
void Add(int pos,int v){
    while(pos<=n){
        tr[pos].insert(v);
        pos+=pos&-pos;
    }
}
void Del(int pos,int v){
    while(pos<=n){
        tr[pos].del(v);
        pos+=pos&-pos;
    }
}
int Sum(int pos,int v){
    int cnt=0;
    while(pos>0){
        cnt+=tr[pos].rank(v);
        pos-=pos&-pos;
    }
    return cnt;
}
struct Q {
    int type,l,r,v;
}cs[MAXN];
int res[MAXN*2];
int main()
{
    //int size = 256 << 20; // 256MB  
    //char *p = (char*)malloc(size) + size;  
    //__asm__("movl %0, %%esp\n" :: "r"(p));
    //freopen("1007.in","r",stdin);
    //freopen("10071.out","w",stdout);
    while(~scanf("%d",&n)){
        res[0]=0;
        for(int i=1;i<=n;i++)scanf("%d",&A[i]),res[++res[0]]=A[i];
        int q;
        //printf("%d\n",query(1,n,1,1,n,4));
        scanf("%d",&q);
        for(int i=0;i<q;i++){
            scanf("%d",&cs[i].type);
            if(cs[i].type==1){
                scanf("%d%d",&cs[i].l,&cs[i].v);
                res[++res[0]]=cs[i].v;
            }
            else {
                scanf("%d%d%d",&cs[i].l,&cs[i].r,&cs[i].v);
            }
        }
        sort(res+1,res+1+res[0]);
        res[0]=unique(res+1,res+1+res[0])-res-1;
        //printf("res0:%d\n",res[0]);
        //for(int i=1;i<=res[0];i++)printf("%d ",res[i]);
        //puts("");
        for(int i=1;i<=n;i++){
            A[i]=lower_bound(res+1,res+1+res[0],A[i])-res;
        }
        //build(1,n,1);
        for(int i=0;i<q;i++){
            if(cs[i].type==1){
                cs[i].v=lower_bound(res+1,res+1+res[0],cs[i].v)-res;
            }
        }
        for(int i=0;i<=n;i++)tr[i].clean();
        for(int i=1;i<=n;i++){
            Add(i,A[i]);
        }
        for(int i=0;i<q;i++){
            if(cs[i].type==1){
                //while(A[cs[i].l]<=0||A[cs[i].l]>res[0]);
                Del(cs[i].l,A[cs[i].l]);
                Add(cs[i].l,cs[i].v);
                A[cs[i].l]=cs[i].v;
            //update(1,n,1,cs[i].l,cs[i].v);
            }
            else {
                int l=1,r=res[0],ans=res[0];
                while(l<=r){
                    int mid=(l+r)>>1;
                    int t=Sum(cs[i].r,mid)-Sum(cs[i].l-1,mid);
                    //if(query(1,n,1,cs[i].l,cs[i].r,mid)>=cs[i].v){
                    if(t>=cs[i].v){
                        ans=mid;
                        r=mid-1;
                    }
                    else l=mid+1;
                }
                printf("%d\n",res[ans]);
            }
        }
    }
    return 0;
}
CHCXCHC
关注
专栏目录
HDU 5412 CRB and Queries 整体二分
山科小菜鸡
07-25 218
Problem Description There are N boys in CodeLand. Boy i has his coding skill Ai. CRB wants to know who has the suitable coding skill. So you should treat the following two types of queries. Query 1: ...
HDU 5412 题解
ez_yww的博客
07-06 327
有一个序列，两种操作。 1 l v：把第l个数改成v 2 l r k：查询l~r中的第k小数。
hdu5412
08-26 112
这道题是待修改的求区间k小值，本来是想用树状数组+主席树，结果超时，用整体二分，结果因为数组开小了，一直wr，（再一次警告自己：wr有可能是数组开小了，但是小的又不是很多时，有可能是wr，而不是re） 代码参考：http://blog.csdn.net/hdu2014/article/details/47834431 （感觉草莓味的软糖比草莓好吃！） 2015.8.29： ...
hdu5412(动态区间第k大）
weixin_30648963的博客
08-20 110
CRB and Queries Time Limit: 12000/6000 MS (Java/Others)Memory Limit: 131072/131072 K (Java/Others)Total Submission(s): 231Accepted Submission(s): 41 Problem Description There areNboys in ...
HDU4819：Mosaic（二维线段树简单模板，树套树，单独修改，区间查询）
蒲公英殇的博客
03-06 280
二维线段树模板题之一
hdu 6058 Kanade's sum [区间第k大数求和] [2017 Multi-University Training Contest - Team 3]
hint
08-01 423
点击打开题目 题意:给你一个序列, 求每个区间的第k大的数的和, 如果不存在第k大的数, 则这个数为0. 分析:一个很直观的思路就是算每个数的贡献, 对于这个序列中的数$a_i$, 枚举有多少区间第k大的数为$a_i$. *往前枚举找到k - 1个比$a_i$大的数,往后枚举找到k - 1个比$a_i$大的数. 然后将左边第i大的数到第i + 1大(包含i但不
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
03-05
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
可持久化线段树入门题 hdu2665 求区间第k小的数
Nicolas
09-16 2692
注意：这题题意写错了，不是区间第k大，而是区间第k小， WA了一地，看了discuss才知道，坑啊 参考了clj的论文《可持久化数据结构研究》，具体做法论文里很明确。 其实思想还是建多颗线段树，只是把这些线段树数据不相同的部分另外建了一些节点。 对于m个询问，每次要建log(n)的节点，需要 n*2+mlog(n)的内存，这题写得不好数组就开不下了 #include #inc
DP.rar_DP_hdu_动态规划_动态规划 C++
09-20
动态规划（Dynamic Programming，简称DP）是解决复杂问题的一种强大算法思想，主要应用于优化问题，通过将大问题分解为小的、相互关联的部分，逐步求解。在编程竞赛和实际编程问题中，尤其是在C++语言中，动态规划是...
hdu 5412 CRB and Queries(动态区间第k大值，区间能修改)（整体二分，树状数组套平衡树，线段树套treap）
piaocoder
08-25 2416
题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=5412 解题思路： 官方题解： In this problem, we can use BIT and Treap. We use BIT for coding skill and each element of BIT is Treap. First, for eac
hdu5412：CRB and Queries （整体二分+树状数组）
KsCla
08-08 472
题目传送门：http://acm.hdu.edu.cn/showproblem.php?pid=5412题目大意：现在给出序列A，要求你支持以下两个操作： 1 l v：将l位置的数修改成v 2 l r k：询问l到r的数中第k大的数是多少 多组测试数据。题目分析：这题是我人生中的第一道整体二分题啊。 我们先将每一个1操作变成两个修改操作：Update(l,A[l],-1);Updtae(l,
HDU 5412 CRB and Queries(整体二分 | CDQ分治)
只玩三国的程序猿的专栏
02-02 666
题意： 给定一个数列，有两种操作，单点修改和区间第k大值。 分析： 整体二分的裸题吧算是，整体二分和CDQ分治还是有点不同的，主要是他还把答案二分出来了，每次判定的时候都会把答案往他应该去的地方放，到了最后就是要查询的答案了，讲的话太复杂，还是看代码理解吧 代码：// // Created by CQU_CST_WuErli // Copyright (c) 2016 CQU_CST_
HDU 5412 CRB and Queries【整体二分+树状数组】
Mr.Phoebe的专栏
08-21 1517
裸动态区间第K大 据说树套树很容易MLE，要有很厉害的姿势才能够 于是就只能用整体二分代码有加注释，学自这儿// whn6325689 // Mr.Phoebe // http://blog.csdn.net/u013007900 #include <algorithm> #include <iostream> #include <iomanip> #include
hdu5412--CRB and Queries（整体二分）
随风的专栏
08-26 1799
题目链接：点击打开链接 题目大意：给出n个数的初始序列，有两种操作，1 l v将第l个数换成v，2 l r k 问在区间[l,r]内的第k大是多少，并输出 经典的题目，但是树状数组+主席树（TLE）伸展树（MLE），听说他们用的块状链表，zhazha表示不会，后来补题，发现整体二分是一个好方法。 首先，这个整体二分是将数据范围和操作放到一起，不断二分数据的范围，可以得到有某些操作可以被完成，
HDU 5412 CRB and Queries (Kth number 整体二分 动态转静态)
每一次AC都是一种感动
07-04 499
题意： 给出长度为n的数列，m次操作 操作分为 1 x y 将x位置的数改成y 2 x y k 查询【x ， y】区间内的第k小数 分析： 有了POJ 2104 那题的静态整体二分的基础后就非常好做了 还是离线处理的方法，将所有数据读入然后再整体二分 对于修改操作，将它分为删除操作和添加操作，仔细想想，这样做并不影响整体二分的结果，因为一次修改操作只对后面的有影响， 而后面
hdu 5412 CRB and Queries（线段树套笛卡尔树 - 动态区间第k大）
不慌不忙、不急不躁
08-21 1246
题目链接：hdu 5412 CRB and Queries 首先对所有出现过的值排序，建立线段树，每个线段树的节点是一棵笛卡尔树，笛卡尔树记录区间下标值。 #include #include #include #include using namespace std; #define lson(x) (x<<1) #define rson(x) ((x<<1)|1)
HDU 5412 CRB and Queries 求区间第k小 CDQ分治+整体二分
inf_force
09-04 1236
恩。。CDQ分治是个神奇的东西。。其思想基于分治。。可以实现大部分离线的带修改的询问 资料：http://www.cnblogs.com/zig-zag/archive/2013/04/18/3027707.html //author: CHC //First Edit Time: 2015-09-04 13:18 #include <iostream> #include <cstdio> #
Hdu-5412 CRB and Queries(整体二分)
WZJRJ28
10-07 338
Description There are N boys in CodeLand.  Boy i has his coding skill Ai.  CRB wants to know who has the suitable coding skill.  So you should treat the following two types of queries.  Que
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值