[COGS257]动态排名系统 树状数组套主席树

257. 动态排名系统

时间限制:5 s   内存限制:512 MB

[问题描述]
给定一个长度为N的已知序列A[i](1<=i<=N),要求维护这个序列,能够支持以下两种操作:
1、查询A[i],A[i+1],A[i+2],...,A[j](1<=i<=j<=N)中,升序排列后排名第k的数。
2、修改A[i]的值为j。
所谓排名第k,指一些数按照升序排列后,第k位的数。例如序列{6,1,9,6,6},排名第3的数是6,排名第5的数是9。
[输入格式]
第一行包含一个整数D(0<=D<=4),表示测试数据的数目。接下来有D组测试数据,每组测试数据中,首先是两个整数N(1<=N<=50000),M(1<=M<=10000),表示序列的长度为N,有M个操作。接下来的N个不大于1,000,000,000正整数,第i个表示序列A[i]的初始值。然后的M行,每行为一个操作
Q i j k 或者
C i j
分别表示查询A[i],A[i+1],A[i+2],...,A[j](1<=i<=j<=N)中,升序排列后排名第k的数,和修改A[i]的值为j。
[输出格式]
对于每个查询,输出一行整数,为查询的结果。测试数据之间不应有空行。
[样例输入]
2
5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3
5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3
[样例输出]
3
6
3
6

题解:

如果你没有听过“树状数组套主席树”这个概念,你选择可以移步我的讲解

本题就是一个树状数组套主席树的板子题,如果用指针打的话操作时可以用vector存下需要更改的几棵树,进行修改

查询时候和普通的静态查询也是类似的,只不过是子树数据数量之和与k比较

这些东西还是通过代码可以更好的理解……代码见下:

 1 #include <cstdio>
 2 #include <cstring>
 3 #include <algorithm>
 4 #include <vector>
 5 using namespace std;
 6 const int N=10100,MAXN=1000000000ll;
 7 int n,val[N],tp;
 8 struct node
 9 {
10     node *ch[2];int cnt;
11     node(){cnt=0;ch[1]=ch[0]=NULL;}
12     inline void update(){cnt=ch[0]->cnt+ch[1]->cnt;}
13 }*null=new node(),*root[N*2];
14 vector<node*>v[5];
15 inline node* newnode()
16 {
17     node *o=new node();
18     o->ch[0]=o->ch[1]=null;
19     return o;
20 }
21 inline int lowbit(int a){return a&-a;}
22 inline void get_query(int id,int pos)
23 {
24     v[id].clear();
25     while(pos)v[id].push_back(root[pos]),pos-=lowbit(pos);
26 }
27 inline void get_set(int id,int pos)
28 {
29     v[id].clear();
30     while(pos<=n)v[id].push_back(root[pos]),pos+=lowbit(pos);
31 }
32 inline void set(vector<node*> o,int l,int r,int pos,int opt)
33 {
34     while(l<r)
35     {
36         int mi=(l+r)>>1;
37         for(int i=0,len=o.size();i<len;i++)if(o[i]!=null)o[i]->cnt+=opt;
38         if(pos<=mi)
39         {
40             r=mi;
41             for(int i=0,len=o.size();i<len;o[i]=o[i]->ch[0],i++)
42                 if(o[i]->ch[0]==null)o[i]->ch[0]=newnode();
43         }
44         else
45         {
46             l=mi+1;
47             for(int i=0,len=o.size();i<len;o[i]=o[i]->ch[1],i++)
48                 if(o[i]->ch[1]==null)o[i]->ch[1]=newnode();
49         }
50     }
51     for(int i=0,len=o.size();i<len;i++)
52     {
53         if(o[i]==null)o[i]=newnode();
54         o[i]->cnt+=opt;
55     }
56 }
57 inline int query(int a,int b,int l,int r,int k)
58 {
59     get_query(1,a-1);get_query(2,b);
60     while(l<r)
61     {
62         int tmp=0,mi=(l+r)>>1;
63         for(int i=0,len=v[1].size();i<len;i++)if(v[1][i]!=null)tmp-=v[1][i]->ch[0]->cnt;
64         for(int i=0,len=v[2].size();i<len;i++)if(v[2][i]!=null)tmp+=v[2][i]->ch[0]->cnt;
65         if(tmp>=k)
66         {
67             for(int i=0,len=v[1].size();i<len;i++)v[1][i]=v[1][i]->ch[0];
68             for(int i=0,len=v[2].size();i<len;i++)v[2][i]=v[2][i]->ch[0];
69             r=mi;
70         }
71         else
72         {
73             for(int i=0,len=v[1].size();i<len;i++)v[1][i]=v[1][i]->ch[1];
74             for(int i=0,len=v[2].size();i<len;i++)v[2][i]=v[2][i]->ch[1];
75             k-=tmp,l=mi+1;
76         }
77     }
78     return r;
79 }
80 inline void change(int a,int b)
81     {get_set(1,a);set(v[1],1,MAXN,val[a],-1);set(v[1],1,MAXN,b,1);val[a]=b;}
82 int main()
83 {
84     int m,a,b,c;char s[3];
85     null->ch[0]=null->ch[1]=null;
86     scanf("%d%d",&n,&m);
87     for(int i=1;i<=n;i++)root[i]=newnode();
88     for(int i=1;i<=n;i++)scanf("%d",&val[i]),get_set(1,i),set(v[1],1,MAXN,val[i],1);
89     while(m--)
90     {
91         scanf("%s",s);
92         if(s[0]==‘Q‘)scanf("%d%d%d",&a,&b,&c),printf("%d\n",query(a,b,1,MAXN,c));
93         else scanf("%d%d",&a,&b),change(a,b);
94     }
95 }
时间: 2024-10-08 08:52:28

[COGS257]动态排名系统 树状数组套主席树的相关文章

[BZOJ 3196] 二逼平衡树 树状数组套主席树

3196: Tyvj 1730 二逼平衡树 Time Limit: 10 Sec  Memory Limit: 128 MBSubmit: 3357  Solved: 1326[Submit][Status][Discuss] Description 您需要写一种数据结构(可参考题目标题),来维护一个有序数列,其中需要提供以下操作:1.查询k在区间内的排名2.查询区间内排名为k的值3.修改某一位值上的数值4.查询k在区间内的前驱(前驱定义为小于x,且最大的数)5.查询k在区间内的后继(后继定义为

关于树状数组套主席树的一些博客

哇仿佛磕了几百年啊; 废话不多说,以下是帮助很大的一些blog: ZOJ 2112 Dynamic Rankings (动态第k大,树状数组套主席树) 主席树全纪录(这个很好) 主席树乱讲(没啥关系,不过有些题目可以刷??) 随笔分类 - 数据结构---主席树(同上) 原文地址:https://www.cnblogs.com/wwtt/p/10099695.html

BZOJ 3196 Tyvj 1730 二逼平衡树 ——树状数组套主席树

[题目分析] 听说是树套树.(雾) 怒写树状数组套主席树,然后就Rank1了.23333 单点修改,区间查询+k大数查询=树状数组套主席树. [代码] #include <cstdio> #include <cstring> #include <cstdlib> #include <cmath> #include <set> #include <map> #include <string> #include <alg

【BZOJ1901】Dynamic Rankings,树状数组套主席树

Time:2016.05.09 Author:xiaoyimi 转载注明出处谢谢 传送门(权限) 题面 1901: Zju2112 Dynamic Rankings Time Limit: 10 Sec Memory Limit: 128 MB Submit: 6678 Solved: 2777 [Submit][Status][Discuss] Description 给定一个含有n个数的序列a[1],a[2],a[3]--a[n],程序必须回答这样的询问:对于给定的i,j,k,在a[i],a

【树状数组套主席树】带修改区间K大数

P2617 Dynamic Rankings 题目描述给定一个含有n个数的序列a[1],a[2],a[3]……a[n],程序必须回答这样的询问:对于给定的i,j,k,在a[i],a[i+1],a[i+2]……a[j]中第k小的数是多少(1≤k≤j-i+1),并且,你可以改变一些a[i]的值,改变后,程序还能针对改变后的a继续回答上面的问题.你需要编一个这样的程序,从输入文件中读入序列a,然后读入一系列的指令,包括询问指令和修改指令. 对于每一个询问指令,你必须输出正确的回答. 输入输出格式输入格

【树套树】【树状数组套主席树】

这是你顾第一次写[树套树]!!!!!!!! [原题] 求区间第k小元素,区间可修改 [正解] 如果没有修改的话,就直接写搞个主席树利用前缀和加加减减一下就好了.但是多了个修改,修改以为着从当前修改节点k到往后n-k个树顶所代表的树全部都要修改,这是一件非常操蛋的事情.回想起多年前学数据结构初步的时候,区间批量修改无非就是树状数组or线段树.故我们借用树状数组的轮廓来构建主席树的各树顶. 对树状数组每个节点,我们都当成是主席树的树顶,改树顶所涵盖的区间与树状数组该节点意义相同. [查询]查询区间[

浅谈树状数组套主席树

话说主席树还没写就先写这一篇了\(qwq\) 回顾一下主席树的实现过程:类似查分思想,将线段树的每次修改看做函数式以支持可持久化.因为这样的线段树是可减的. 那么我们维护信息的时候,就要维护每一次新形成的信息.但是我们可以根据前一个信息的基础上进行改动,而不必要去再建一棵树. 所以总而言之,是前缀和的思想. 那么,当需要修改的时候,怎么做呢? 考虑普通的区间操作,当做单点修改的时候,一般用树状数组,线段树和分块.最好实现的就是树状数组. 考虑用树状数组来维护主席树的信息. 树状数组中维护了每一次

[COGS 257]动态排名系统 树状数组套主席树

主席树就是所谓可持久化线段树.目前只会打区间k值操作. 那么带修改的呢?因为主席树目的上也是搞前缀和,所以类比数组操作,套一个树状数组就可以了. 谨以此纪念此类型树套树入门 #include<iostream> #include<cstdio> #include<cstring> using namespace std; #define pos(i,a,b) for(int i=(a);i<=(b);i++) #define N 51000 #include<

【BZOJ 1901】【Zju 2112】 Dynamic Rankings 动态K值 树状数组套主席树模板题

达神题解传送门:http://blog.csdn.net/dad3zz/article/details/50638360 说一下我对这个模板的理解: 看到这个方法很容易不知所措,因为动态K值需要套树状数组,而我一开始根本不知道该怎么套,, 学习吧,,, 然后我自己脑补如果不套会如何?后来想到是查询O(logn),修改是O(nlogn),很明显修改的复杂度太大了,为了降低修改的复杂度,我们只得套上树状数组来维护前缀和使它的n的复杂度降低为logn,从而修改的复杂度变为O(log2n).但因为我们套