洛谷P2617 Dynamic Rankings【树状数组套主席树】

$$DynamicRankings$$

题目描述
给定一个含有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≤100000)，m(1≤m≤100000)。分别表示序列的长度和指令的个数。

第二行有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。

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

输入输出样例
输入样例#1：
5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3
输出样例#1：
3
6

经典的树状数组套主席树的题目，求动态区间第k大，如果是静态的话，只要用前缀和计算出区间各个数的数量和就好了，但是现在存在更新的情况。在普通的单点更新，区间求和的问题中，用到了树状数组来代替前缀和，这里其实也一样，把主席树套到树状数组里去就好了，树状数组的每个节点都存一棵主席树，为了节省空间，我们先保存原始的主席树，然后树状数组用来存更新的结果，每次更新树状数组上logn个节点上的主席树的logn条边，求和的时候用原始的主席树求出区间前缀和之后再加上树状数组求出的区间更新的和就好了

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn = 1e6+7;
int seq[maxn],s_root[maxn],b_root[maxn],use[maxn],n,m,cnt,nn;	//s_root[i]是初始主席树每个权值的根,b_root是树状数组每个节点的根
vector<int> vec;												//用于离散化
int lowbit(int x){return x&(-x);}														
int Getid(int x){return lower_bound(vec.begin(),vec.end(),x)-vec.begin()+1;}//离散化之后的标号
struct Query{													//离线记录询问和更新
	int l,r,k;
	bool q;
}que[maxn];
struct LJT_Tree{
	struct Node{													//节点信息
		int l,r,sum;
	}node[maxn*400];
	void build(int l,int r,int &rt){								//初始化建树
		node[rt=++cnt].sum = 0;
		if(l+1==r) return;
		int mid = (l+r)>>1;
		build(l,mid,node[rt].l);
		build(mid,r,node[rt].r);
	}
	void update(int l,int r,int &now,int pre,int pos,int val){//当前区间[l,r),根据节点pre新建节点now,更新位置在pos,改变量为val
		node[now=++cnt] = node[pre];
		node[now].sum+=val;
		if(l+1==r) return;
		int mid = (l+r)>>1;
		if(pos<mid) update(l,mid,node[now].l,node[pre].l,pos,val);
		else update(mid,r,node[now].r,node[pre].r,pos,val);
	}
	void modify(int pos,int k,int val){					//更新树状数组的节点，序列位置为pos，更新主席树中权值为k的位置，改变1(加或减)
		while(pos<nn){
			update(1,nn,b_root[pos],b_root[pos],k,val);
			pos+=lowbit(pos);
		}
	}
	int getsum(int pos){
		int res = 0;
		while(pos){
			res+=node[node[use[pos]].l].sum;
			pos-=lowbit(pos);
		}
		return res;
	}
	int query(int l,int r,int L,int R,int lt,int rt,int k){//[l,r):当前区间.[L,R):需要更改的区间.lt、rt:初始主席树上的节点，用于相减.k:第k大
		if(l+1==r) return l;
		int mid = (l+r)>>1;
		int sum = getsum(R)-getsum(L)+node[node[rt].l].sum-node[node[lt].l].sum;
		if(sum>=k){
			for(int i=L;i;i-=lowbit(i)) use[i] = node[use[i]].l;
			for(int i=R;i;i-=lowbit(i)) use[i] = node[use[i]].l;
			return query(l,mid,L,R,node[lt].l,node[rt].l,k);
		}
		else{
			for(int i=L;i;i-=lowbit(i)) use[i] = node[use[i]].r;
			for(int i=R;i;i-=lowbit(i)) use[i] = node[use[i]].r;
			return query(mid,r,L,R,node[lt].r,node[rt].r,k-sum);
		}
	}
}Seg_Tree;
int main(){
	vec.clear();cnt = 0;
	scanf("%d %d",&n,&m);
	for(int i=1;i<=n;i++) scanf("%d",&seq[i]),vec.push_back(seq[i]);
	for(int i=1;i<=m;i++){
		char op[2];
		scanf("%s",op);
		if(op[0]=='Q'){
			scanf("%d %d %d",&que[i].l,&que[i].r,&que[i].k);
			que[i].q = true;
		}
		else{
			scanf("%d %d",&que[i].l,&que[i].k);
			que[i].q = false; vec.push_back(que[i].k);
		}
	}
	sort(vec.begin(),vec.end());
	vec.erase(unique(vec.begin(),vec.end()),vec.end());						//离散化
	nn = vec.size()+1;														//总元素数量
	Seg_Tree.build(1,nn,s_root[0]);											//初始建空树
	for(int i=1;i<=n;i++) Seg_Tree.update(1,nn,s_root[i],s_root[i-1],Getid(seq[i]),1);
	for(int i=1;i<=n;i++) b_root[i] = s_root[0];							//初始化树状数组(主席树为树状数组每个节点的信息)
	for(int i=1;i<=m;i++){
		if(!que[i].q){
			Seg_Tree.modify(que[i].l,Getid(seq[que[i].l]),-1);
			Seg_Tree.modify(que[i].l,Getid(que[i].k),1);
			seq[que[i].l] = que[i].k;
		}
		else{
			for(int j=que[i].l-1;j;j-=lowbit(j)) use[j] = b_root[j];
			for(int j=que[i].r;j;j-=lowbit(j))	 use[j] = b_root[j];
			printf("%d\n",vec[Seg_Tree.query(1,nn,que[i].l-1,que[i].r,s_root[que[i].l-1],s_root[que[i].r],que[i].k)-1]);
		}
	}
	return 0;
}