数据结构 - 主席树

好文推荐

1. 权值线段树、主席树学习
2. 树状结构之主席树

求区间第K大

【模板】可持久化线段树 1（主席树）

题目

题目传送门：luogu3834【模板】可持久化线段树 1（主席树）

代码

#include<bits/stdc++.h>
using namespace std;

const int maxn=2e5+5;

int n,m,len,cnt;
int a[maxn],dire[maxn],root[maxn];

struct node
{
	int l,r,sum;
}tree[maxn*20];//空间复杂度 O(N*logN) 
//开18会RE 
template<typename T>inline void read(T &x)
{
	x=0;bool f=0;char c=getchar();
	while(c<'0'||c>'9') {f|=(c=='-');c=getchar();}
	while(c>='0'&&c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	if(f) x=-x;
}

template<typename T>void putch(const T x)
{
	if(x>9) putch(x/10);
	putchar((x%10)|48);
}

template<typename T>void put(const T x)
{
	if(x<0) putchar('-'),putch(-x);
	else putch(x);
}

int getid(int x)
{
	return lower_bound(dire+1,dire+len+1,x)-dire;//-1+1
	//lower_bound返回第一个大于等于x的位置，upper_bound返回第一个大于x的位置 
}

void readdata()
{
	read(n);read(m);
	for(int i=1;i<=n;++i) {read(a[i]);dire[i]=a[i];}
	sort(dire+1,dire+n+1);
	len=unique(dire+1,dire+n+1)-dire-1;//减去首位置得到去重数列的长度 
	//unique排序，把重复的数排到后面，返回去重后的第一个重复的数的地址）
}

void update(int l,int r,int &x,int y,int k)//注意取址 ，x代表当前，y代表以前
{
	tree[++cnt]=tree[y];tree[cnt].sum++;x=cnt;//%%%%
	//自上而下的更新
	if(l==r) return;
	int mid=(l+r)>>1;
	if(mid>=k) update(l,mid,tree[x].l,tree[y].l,k);
	else update(mid+1,r,tree[x].r,tree[y].r,k);
	
}

int query(int l,int r,int x,int y,int k)
{
	if(l==r) return l;//返回位置 
	int sum=tree[tree[y].l].sum-tree[tree[x].l].sum;
	int mid=(l+r)>>1;
	//mid 是树上的位置，
	//sum是数值的左半部分的个数 
	
	if(k<=sum) return query(l,mid,tree[x].l,tree[y].l,k);
	else return query(mid+1,r,tree[x].r,tree[y].r,k-sum);
}

void work()
{
	for(int i=1;i<=n;++i) update(1,n,root[i],root[i-1],getid(a[i]));
	//unique针对的是相邻元素，所以对于顺序顺序错乱的数组成员，或者容器成员，需要先进行排序
	//以root[i]为根的树记录了第1~i个数的信息
	//每一个root[i]都是一颗完整线段树的根  
	for(int i=1;i<=m;++i)
	{
		int x,y,k;
		read(x);read(y);read(k);
		put(dire[query(1,n,root[x-1],root[y],k)]);
		putchar('\n');
	}
}

int main()
{
	readdata();
	work();
	return 0;
}

可持久化数组

【模板】可持久化数组（可持久化线段树/平衡树）

题目传送门：luogu3919【模板】可持久化数组（可持久化线段树/平衡树）

/***************************
User：Mandy.H.Y
Language:c++
Problem:luogu3919
Algorithm:
Date:2019.7.31
***************************/

/*
算法模型：可持久化线段树（主席树）

空间复杂度：O((n+m)logn)
时间复杂度：O((n+m)logn)其中
预处理：O(nlogn)
单次修改：O(logn)
单次查询：O(logn)
*/

#include<bits/stdc++.h>
#define lson l,mid
#define rson mid + 1,r
#define Max(x,y) (x) > (y) ? (x) : (y)
#define Min(x,y) (x) < (y) ? (x) : (y)

using namespace std;

const int maxn = 1e6 + 5;

int n,m,cnt,loc,change;
int root[maxn];

struct PST{
	int l,r,val;	
}tree[maxn * 25];
//开25倍，不然会RE 
template<class T>inline void read(T &x){
	x = 0;bool flag = 0;char ch = getchar();
	while( ! isdigit(ch)) flag |= ch == '-',ch = getchar();
	while(isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48),ch = getchar();
	if(flag) x = -x;
}

template<class T>void putch(const T x){
	if(x > 9) putch(x / 10);
	putchar(x % 10 | 48);
}

template<class T>void put(const T x){
	if(x < 0) putchar('-'),putch(-x);
	else putch(x);
}

void file(){
	freopen("tree.in","r",stdin);
//	freopen("tree.out","w",stdout);
}

void buildtree(int &cur,int l,int r){
	cur = ++cnt;
	//注意左右儿子 
	if(l == r){
		read(tree[cnt].val);
		tree[cnt].l = l,tree[cnt].r = r;
		return;
	}
	int mid = (l + r) >> 1;
	//左右儿子的修改 
	buildtree(tree[cur].l,lson);//cur 
	buildtree(tree[cur].r,rson);
	
}
	
void modify(int l,int r,int &cur,int pre){
	tree[++cnt] = tree[pre];
	cur = cnt;
	
	if(l == r){
		tree[cnt].val = change;
		return;
	}
	
	int mid = (l + r) >> 1; 
	//%%%cur
	//%%%  loc <= mid
	if(loc <= mid) modify(lson,tree[cur].l,tree[pre].l);
	else modify(rson,tree[cur].r,tree[pre].r);//cur
}

int query(int l,int r,int pre,int &cur){
	cur = ++cnt;
	tree[cnt] = tree[pre];
	
	if(l == r) return tree[pre].val;
	int mid = (l + r) >> 1;
	
	if(loc <= mid) return query(lson,tree[pre].l,tree[cur].l);
	else return query(rson,tree[pre].r,tree[cur].r);
	
}

void readdata(){
	read(n);read(m);
	buildtree(root[0],1,n);
}

void work(){
	
	for(int i = 1;i <= m; ++ i){
		int v,opt;
		read(v);read(opt);
		if(opt == 1){
			read(loc),read(change);
			modify(1,n,root[i],root[v]);
		}else{
			read(loc);
			put(query(1,n,root[v],root[i]));
			puts("");
		}
	}
}

int main(){
//	file();
	readdata();
	work();
	return 0;
}