BZOJ 1901: Zju2112 Dynamic Rankings( 树状数组套主席树 )

裸的带修改主席树.. 之前用BIT套Splay( http://www.cnblogs.com/JSZX11556/p/4625552.html )A过..但是还是线段树好写...而且快(常数比平衡树小). 时空复杂度是O(Nlog(N)+Mlog^2(N))

-------------------------------------------------------------------------

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<cctype>

using namespace std;

#define H(v) (lower_bound(Hash, Hash + Hn, v) - Hash + 1)

const int maxn = 10009;

int N, Q;

int seq[maxn];

int Hash[maxn << 1], Hn;

int Val, Pos;

inline int read() {

char c = getchar();

for(; !isdigit(c); c = getchar());

int ret = 0;

for(; isdigit(c); c = getchar())

ret = ret * 10 + c - ‘0‘;

return ret;

}

struct Event {

int l, r, v;

Event(int _l = 0, int _r = 0, int _v = 0) :

l(_l), r(_r), v(_v) {

}

} q[maxn];

void Init() {

Hn = 0;

N = read(), Q = read();

for(int i = 1; i <= N; i++)

Hash[Hn++] = (seq[i] = read());

for(int i = 0; i < Q; i++) {

char c = getchar();

for(; c != ‘C‘ && c != ‘Q‘; c = getchar());

if(c == ‘C‘) {

int p = read(), v = read();

q[i] = Event(-1, p, v);

Hash[Hn++] = v;

} else {

int l = read() - 1, r = read();

q[i] = Event(l, r, read());

}

}

sort(Hash, Hash + Hn);

Hn = unique(Hash, Hash + Hn) - Hash;

}

struct Node {

Node *lc, *rc;

int v;

} pool[5000000], *pt, *Null, *Root[maxn], *V[maxn];

void Init_sgt() {

pt = pool;

Null = pt++;

Null->v = 0;

Null->lc = Null->rc = Null;

}

Node* Modify(Node* t, int l, int r) {

Node* o = pt++;

o->v = t->v + Val;

if(l != r) {

int m = (l + r) >> 1;

if(Pos <= m) {

o->lc = Modify(t->lc, l, m);

o->rc = t->rc;

} else {

o->lc = t->lc;

o->rc = Modify(t->rc, m + 1, r);

}

}

return o;

}

void Build() {

Root[0] = Null;

Val = 1;

for(int i = 1; i <= N; i++) {

Pos = seq[i] = H(seq[i]);

Root[i] = Modify(Root[i - 1], 1, Hn);

}

}

Node *L[20], *R[20];

int Ln, Rn;

void Work() {

for(int i = 1; i <= Hn; i++)

V[i] = Null;

for(int i = 0; i < Q; i++)

if(~q[i].l) {

Ln = Rn = 0;

for(int p = q[i].l; p; p -= p & -p)

L[Ln++] = V[p];

for(int p = q[i].r; p; p -= p & -p)

R[Rn++] = V[p];

Node *_L = Root[q[i].l], *_R = Root[q[i].r];

int l = 1, r = Hn;

while(l < r) {

int cnt = _R->lc->v - _L->lc->v, m = (l + r) >> 1;

for(int j = 0; j < Ln; j++)

cnt -= L[j]->lc->v;

for(int j = 0; j < Rn; j++)

cnt += R[j]->lc->v;

if(cnt >= q[i].v) {

_L = _L->lc;

_R = _R->lc;

for(int j = 0; j < Ln; j++)

L[j] = L[j]->lc;

for(int j = 0; j < Rn; j++)

R[j] = R[j]->lc;

r = m;

} else {

q[i].v -= cnt;

_L = _L->rc;

_R = _R->rc;

for(int j = 0; j < Ln; j++)

L[j] = L[j]->rc;

for(int j = 0; j < Rn; j++)

R[j] = R[j]->rc;

l = m + 1;

}

}

printf("%d\n", Hash[l - 1]);

} else {

Pos = seq[q[i].r], Val = -1;

for(int p = q[i].r; p <= Hn; p += p & -p)

V[p] = Modify(V[p], 1, Hn);

Pos = seq[q[i].r] = H(q[i].v), Val = 1;

for(int p = q[i].r; p <= Hn; p += p & -p)

V[p] = Modify(V[p], 1, Hn);

}

}

int main() {

Init();

Init_sgt();

Build();

Work();

return 0;

}

------------------------------------------------------------------------

1901: Zju2112 Dynamic Rankings

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 5988  Solved: 2489
[Submit][Status][Discuss]

Description

给定一个含有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,然后读入一系列的指令,包括询问指令和修改指令。对于每一个询问指令,你必须输出正确的回答。 第一行有两个正整数n(1≤n≤10000),m(1≤m≤10000)。分别表示序列的长度和指令的个数。第二行有n个数,表示a[1],a[2]……a[n],这些数都小于10^9。接下来的m行描述每条指令,每行的格式是下面两种格式中的一种。 Q i j k 或者 C i t Q i j k (i,j,k是数字,1≤i≤j≤n, 1≤k≤j-i+1)表示询问指令,询问a[i],a[i+1]……a[j]中第k小的数。C i t (1≤i≤n,0≤t≤10^9)表示把a[i]改变成为t。

Input

对于每一次询问,你都需要输出他的答案,每一个输出占单独的一行。

Output

Sample Input

5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3

Sample Output

3
6

HINT

20%的数据中,m,n≤100; 40%的数据中,m,n≤1000; 100%的数据中,m,n≤10000。

Source

时间: 2024-08-17 01:01:52

BZOJ 1901: Zju2112 Dynamic Rankings( 树状数组套主席树 )的相关文章

【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

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

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

[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

[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<=

zoj 2112 Dynamic Rankings(树状数组套主席树)

题意:对于一段区间,每次求[l,r]的第k大,存在单点修改操作: 思路: 学习主席树参考: http://blog.csdn.net/wjf_wzzc/article/details/24560117(各种形式) http://blog.csdn.net/bossup/article/details/31921235(推荐) http://blog.csdn.net/xiaofengcanyuexj/article/details/25553521?utm_source=tuicool(图解)

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