可持久化线段树（主席树）

最新推荐文章于 2022-11-15 19:29:36 发布
最新推荐文章于 2022-11-15 19:29:36 发布
阅读量195 收藏
点赞数
分类专栏： 可持久化线段树 文章标签： 主席树 可持久化线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sizeof_you/article/details/82808418
版权

qwq我大概又是机房最后一个学主席树的了吧

其实之前一直都在讲···只是没做题

 

做了几道以后发现都是一个套路qwq关键就是能不能看出来要用主席树

主要可以解决：

静态/动态区间第k大（树上也可以）

一些有关区间的带某些限制的询问（如出现次数等）

 

先把模板粘上来：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int maxn=200005+200000*18;
int n,m,a[maxn],root[maxn],tot;
int ls[maxn],rs[maxn],sum[maxn],b[maxn],p[maxn];

inline void build(int &k,int L,int R){
    k=++tot;
    if(L<R){
        int mid=(L+R)>>1;
        build(ls[k],L,mid); build(rs[k],mid+1,R);
        return;
    }
}

inline void update(int &k,int pre,int L,int R,int c){
    k=++tot;
    ls[k]=ls[pre],rs[k]=rs[pre],sum[k]=sum[pre]+1;
    if(L<R){
        int mid=(L+R)>>1;
        if(c<=mid) update(ls[k],ls[pre],L,mid,c);
        else update(rs[k],rs[pre],mid+1,R,c);
    }
}

inline int query(int u,int v,int L,int R,int k){
    if(L==R) return L;
    int x=sum[ls[v]]-sum[ls[u]];
    if(x>=k) return query(ls[u],ls[v],L,(L+R)>>1,k);
    else return query(rs[u],rs[v],((L+R)>>1)+1,R,k-x);
}

inline int rd(){
    int x=0,f=1;char c=' ';
    while(c<'0' || c>'9') {if(c=='-')f=-1;c=getchar();}
    while(c<='9' && c>='0') x=x*10+c-'0',c=getchar();
    return x*f;
}

int main(){
    n=rd(); m=rd();
    for(int i=1;i<=n;i++) a[i]=rd(),b[i]=a[i];
    sort(a+1,a+1+n);
    int cnt=unique(a+1,a+n+1)-a-1;
    build(root[0],1,cnt);
    for(int i=1;i<=n;i++){
        b[i]=lower_bound(a+1,a+cnt+1,b[i])-a;
        update(root[i],root[i-1],1,cnt,b[i]);
    }
    while(m--){
        int l=rd(),r=rd(),k=rd();
        printf("%d\n",a[query(root[l-1],root[r],1,cnt,k)]);
    }
    return 0;
}

然后是一些比较裸的题：

SPOJ10628

树上的路径也可以看做区间，每个节点的前一个版本是父亲节点，然后在query的时候稍作修改：

sum[x]+sum[y]-sum[lca]-sum[fa[lca]]

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define N 100005
#define M 2000005
using namespace std;
int n,m,cnt,head[N],a[N],b[N],num,dep[N],f[N][20];
int root[N],sum[M],ls[M],rs[M],tot;

inline int rd(){
	int x=0,f=1;char c=' ';
	while(c<'0' || c>'9') {if(c=='-')f=-1;c=getchar();}
	while(c<='9' && c>='0') x=x*10+c-'0',c=getchar();
	return x*f; 
}

struct EDGE{
	int to,nxt;
}edge[N<<1];
inline void add(int x,int y){
	edge[++cnt].nxt=head[x]; edge[cnt].to=y; head[x]=cnt;
}

inline int LCA(int x,int y){
	if(dep[x]<dep[y]) swap(x,y);
	for(int i=17;i>=0;i--)
		if(dep[f[x][i]]>=dep[y]) x=f[x][i];
	if(x==y) return x;
	for(int i=17;i>=0;i--)
		if(f[x][i]!=f[y][i])
			x=f[x][i],y=f[y][i];
	return f[x][0];
}

inline void build(int &k,int L,int R){
	k=++tot;
	if(L<R){
		int mid=(L+R)>>1;
		build(ls[k],L,mid); build(rs[k],mid+1,R);
		return;
	}
}

inline void update(int &k,int pre,int L,int R,int p){
	k=++tot;
	ls[k]=ls[pre],rs[k]=rs[pre],sum[k]=sum[pre]+1;
	if(L<R){
		int mid=(L+R)>>1;
		if(p<=mid) update(ls[k],ls[pre],L,mid,p);
		else update(rs[k],rs[pre],mid+1,R,p);
	} return;
}

inline int query(int u,int v,int lca,int fa,int L,int R,int k){
	if(L==R) return L;
	int tmp=sum[ls[v]]+sum[ls[u]]-sum[ls[lca]]-sum[ls[fa]];
	int mid=(L+R)>>1;
	if(tmp>=k) return query(ls[u],ls[v],ls[lca],ls[fa],L,mid,k);
	else return query(rs[u],rs[v],rs[lca],rs[fa],mid+1,R,k-tmp);
}

inline void dfs(int u,int fa){
	for(int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to; if(v==fa) continue;
		dep[v]=dep[u]+1; f[v][0]=u;
		a[v]=lower_bound(b+1,b+num+1,a[v])-b;
		update(root[v],root[u],1,num,a[v]);
		for(int j=1;j<=17;j++)
			f[v][j]=f[f[v][j-1]][j-1];
		dfs(v,u);
	} return;
}

int main(){
	n=rd(); m=rd();
	for(int i=1;i<=n;i++) a[i]=rd(),b[i]=a[i];
	sort(b+1,b+n+1);
	num=unique(b+1,b+n+1)-b-1;
	for(int i=1;i<n;i++){
		int x=rd(),y=rd();
		add(x,y); add(y,x);
	}
	add(0,1);
	build(root[0],1,num);
	dfs(0,0);
	while(m--){
		int u=rd(),v=rd(),k=rd(),x=LCA(u,v);
		int ans=query(root[u],root[v],root[x],root[f[x][0]],1,num,k);
		printf("%d\n",b[ans]);
	}
	return 0;
}

[POI2014]KUR-Couriers

相当于找区间众数，但据说这个没法在nlogn复杂度求解，但是它只让求出现次数>(r-l+1)的

因此每次主席树query的时候找值大于这个值得就行了

找到叶子说明找到了答案，否则返回0

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define N 500005
#define M 11000000
using namespace std;
int n,m,a[N],root[N],ls[M],rs[M],sum[M],tot;

inline int rd(){
    int x=0,f=1;char c=' ';
    while(c<'0' || c>'9') {if(c=='-')f=-1;c=getchar();}
    while(c<='9' && c>='0') x=x*10+c-'0',c=getchar();
    return x*f; 
}

inline void build(int &k,int L,int R){
    k=++tot;
    if(L<R){
        int mid=(L+R)>>1;
        build(ls[k],L,mid); build(rs[k],mid+1,R);
        return;
    }
}

inline void update(int &k,int pre,int L,int R,int p){
    k=++tot;
    ls[k]=ls[pre],rs[k]=rs[pre],sum[k]=sum[pre]+1;
    if(L<R){
        int mid=(L+R)>>1;
        if(p<=mid) update(ls[k],ls[pre],L,mid,p);
        else update(rs[k],rs[pre],mid+1,R,p);
    } return;
}

inline int query(int u,int v,int L,int R,int k){
    if(L==R) return L;
    int x=sum[ls[v]]-sum[ls[u]],y=sum[rs[v]]-sum[rs[u]];
    int mid=(L+R)>>1;
    if(x>k) return query(ls[u],ls[v],L,mid,k);
    else if(y>k) return query(rs[u],rs[v],mid+1,R,k);
    else return 0;
}

int main(){
    n=rd(); m=rd();
    for(int i=1;i<=n;i++) a[i]=rd();
    build(root[0],1,n);
    for(int i=1;i<=n;i++)
        update(root[i],root[i-1],1,n,a[i]);
    while(m--){
        int l=rd(),r=rd();
        int ans=query(root[l-1],root[r],1,n,(r-l+1)/2);
        printf("%d\n",ans);
    }
    return 0;
}

bzoj2653

让区间中位数最大，套路地想二分答案去做

把小于mid的设成-1，大于等于的设成1，然后找最大区间和看是否>=0

但是这样做复杂度爆炸，考虑每次二分改变的1的个数总共不会多于n个

所以可以将数值排序后建主席树，然后判断时求区间max

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define N 20005
#define M 400005
#define LL long long
using namespace std;
int n,m,num,root[M],ls[M],rs[M],sum[M],lmx[M],rmx[M],tot;
int a[N],ans,q[5];
pair<int,int> b[N];

inline int rd(){
	int x=0,f=1;char c=' ';
	while(c<'0' || c>'9') {if(c=='-')f=-1;c=getchar();}
	while(c<='9' && c>='0') x=x*10+c-'0',c=getchar();
	return x*f; 
}

inline void pushup(int x){
	int lson=ls[x],rson=rs[x];
	sum[x]=sum[lson]+sum[rson];
//	lmx[x]=max(lmx[x],max(lmx[lson],sum[lson]+lmx[rson]));
//	rmx[x]=max(rmx[x],max(rmx[rson],sum[rson]+rmx[lson]));不能这样写qwq 
	lmx[x]=max(lmx[lson],sum[lson]+lmx[rson]);
	rmx[x]=max(rmx[rson],sum[rson]+rmx[lson]);
}

inline void build(int &k,int L,int R){
	k=++tot;
	if(L==R){
		sum[k]=lmx[k]=rmx[k]=1;
		return;
	}
	int mid=(L+R)>>1;
	build(ls[k],L,mid); build(rs[k],mid+1,R);
	pushup(k);
}

inline void update(int &k,int pre,int L,int R,int p,int val){
	k=++tot;
	ls[k]=ls[pre],rs[k]=rs[pre];
	if(L==R) {
		sum[k]=lmx[k]=rmx[k]=val;
		return;
	}
	int mid=(L+R)>>1;
	if(p<=mid) update(ls[k],ls[pre],L,mid,p,val);
	else update(rs[k],rs[pre],mid+1,R,p,val);
	pushup(k); return;
}

inline int query_all(int u,int L,int R,int l,int r){
	if(l==L && r==R) return sum[u];
	int mid=(L+R)>>1;
	if(r<=mid) return query_all(ls[u],L,mid,l,r);
	else if(l>mid) return query_all(rs[u],mid+1,R,l,r);
	else return query_all(ls[u],L,mid,l,mid)+query_all(rs[u],mid+1,R,mid+1,r); 
}

inline int query_left(int u,int L,int R,int l,int r){
	if(l==L && r==R) return lmx[u];
	int mid=(L+R)>>1;
	if(r<=mid) return query_left(ls[u],L,mid,l,r);
	else if(l>mid) return query_left(rs[u],mid+1,R,l,r);
	else return max(query_left(ls[u],L,mid,l,mid),query_all(ls[u],L,mid,l,mid)+query_left(rs[u],mid+1,R,mid+1,r));
}

inline int query_right(int u,int L,int R,int l,int r){
	if(l==L && r==R) return rmx[u];
	int mid=(L+R)>>1;
	if(r<=mid) return query_right(ls[u],L,mid,l,r);
	else if(l>mid) return query_right(rs[u],mid+1,R,l,r);
	else return max(query_right(rs[u],mid+1,R,mid+1,r),query_all(rs[u],mid+1,R,mid+1,r)+query_right(ls[u],L,mid,l,mid));
}

inline bool check(int k,int a,int b,int c,int d){
	int tmp=0;
	if(b+1<c) tmp+=query_all(root[k],0,n-1,b+1,c-1);
	tmp+=query_left(root[k],0,n-1,c,d);
	tmp+=query_right(root[k],0,n-1,a,b);
	return tmp>=0;
}

int main(){
	n=rd();
	for(int i=0;i<n;i++){
		a[i]=rd();
		b[i]=make_pair(a[i],i);
	}
	sort(b,b+n);
	build(root[0],0,n-1);
	for(int i=1;i<n;i++)
		update(root[i],root[i-1],0,n-1,b[i-1].second,-1);
	m=rd();
	while(m--){
		for(int i=1;i<=4;i++) q[i]=rd(),q[i]=(q[i]+ans)%n;
		sort(q+1,q+5);
		int ll=0,rr=n-1,res;
		while(ll<=rr){
			int mid=(rr+ll)>>1;
			if(check(mid,q[1],q[2],q[3],q[4])) ll=mid+1,res=mid;
			else rr=mid-1;
		}
		printf("%d\n",ans=b[res].first);
	}
	return 0;
}

 

QAQQQQQQQQQQQ
关注
专栏目录
11.1.5 蓝桥杯树形结构之线段树可持久化线段树(主席树)
tang7mj的博客
02-13 435
主席树是可持久化线段树的一种，得名于发明者Herbert S. Wilf教授的昵称"主席"。它通过保存每次操作后线段树的版本来实现持久化，使得我们能够访问和查询历史版本的数据。与传统线段树不同，主席树在更新时不会覆盖旧的节点，而是创建新的节点，从而保留了所有历史信息。主席树将线段树的强大功能与数据的持久化相结合，提供了一种解决动态数据问题的高效方法。通过主席树，我们不仅可以解决传统线段树能够处理的问题，还能查询到数据的历史状态，大大扩展了线段树的应用范围。
主席树入门-可持久化线段树
amino_acid0617的博客
11-03 211
主席树的发明，源于权值线段树，所以我们先来看看权值线段树。 该篇博客以poj2104为例，逐步详解。 2104大致题意： n个数，m个询问。每个询问会给一组[l,r,k]，求区间(l,r)之间的第k小值。 权值线段树 在上面的例子中，假设我们只涉及一个区间的修改以及查询，那么我们就可以建立一个权值线段树。权值线段树是记录权值的线段树。记录权值指的是，每个节点上存的是区间内的数字出现的总次数。 比如...
主席树 | 莫队 ---- Codeforces Round #716 (Div. 2) D. Cut and Stick [主席树or莫队优化] 区间众数问题（静态）
weixin_45630722的博客
05-12 508
题目链接 题目大意： 就是给你nnn个数,和q次询问，每次询问给你一个区间[l,r][l,r][l,r]，问你把区间里面的数分配成最少多少块,使得块内出现最多次数的数不超过区间长度的一半(除不尽向上取整) 解题思路： 假设一个区间的众数是xxx个,那么不是众数的个数为rx=(r−l+1)−x;rx=(r-l+1)-x;rx=(r−l+1)−x; 1.如果区间的众数没超过一半，那么我们直接划分成一个区间就好了 因为如果众数都没超过一半，那么其他数那铁都超不了一半。 2.如果这个区间的众数超过了一半，那么我
区间众数（主席树+分块）
lcl1234567890lcl的博客
07-22 1372
P4168 [Violet]蒲公英 众所周知，线段树不可用于区间反转，区间众数 这个题最先思考的是建一颗主席树，由于有权值线段树的影子在里面，所以就有一个简单的思路： 查询的时候想办法找区间内出现最多的数，主席树的查询，恰好可以，求到出现次数，但是如何找到出现的次数又成了新的问题，加之还要求最小的众数，又构成了新的问题 最早的想法是二分，但是后来发现问题不具有单调性，所以pass 想了很久，最后还是妥协了，还是要用分块 简单的说，是要进行预处理,即处理每两个块之间的众数，时间复杂度O(n1.5)。 查询：
【HDU4348】To The Moon-主席树（可持久化线段树）区间修改+区间询问
Maxwei_wzj的OI世界
03-15 681
【HDU4348】To The Moon-主席树（可持久化线段树）区间修改+区间询问
数列分块入门9(区间众数)
Exception
01-13 560
原题：https://loj.ac/problem/6285 题解:基本题意求[l,r]的最小众数，对于集合 A,B 显然 mode(A and B)属于 mode(A) and B。这样就可以分块，预处理f[i][j]表示i-j的众数。每次查询时暴力查询头尾两块的数和中间块的众数就可以，关于查询x在[l,r]出现了几次，用动态数组存放x的下标，二分查找就好了。可以先给a数组离散化。这道题块的大...
LOJ---6285：数列分块入门 9【区间众数】
KobeDuu
03-29 913
题目： https://loj.ac/problem/6285 分析： 如果只查询众数的个数，完全可以莫队，加数时容易维护众数的数量，删除数时，众数的数量要么减1，要么不变，只需再开一个标记数组维护众数的数量即可 根据陈立杰---《区间众数解题报告》实现了下面两种解法 解法一： 块数分成sqrt(n)超时了，150可以过（分块真毒瘤） #pragma GCC optimize(2)...
洛谷 P3834 【模板】可持久化线段树 2（主席树）
qq_38232157的博客
11-15 237
主席树
可持久化专题（一）——浅谈主席树：可持久化线段树
CXR的博客
08-08 6217
前言 不得不说，可持久化数据结构真是太难了！ 由于数据结构这东西真的太玄学了，学这个主席树我真的学了很久。 简介 主席树为什么叫主席树？据说因为它是一个名字缩写为HJTHJTHJT的神犇发明的，与当时主席的名字缩写一样…… 主席树实质上就是一棵可持久化线段树，它的具体实现可以看下面。 让我们从值域线段树开始说起 要学主席树，我们就要先学值域线段树。 值域线段树的区间存的并不...
上古时期(大雾)的数据结构pdf
QuantAsk
12-21 322
分块+点分治+Treap by WYCby\ WYCby WYC Part1 分块 概念 就是将nnn个数分成若干个块，然后要处理的时候整块一起的加上局部的直接暴力。 如果将块的大小分配好一般每次都是O(n)O(\sqrt n)O(n​)的。 而且因为十分暴力，所以有很多优秀的性质。 实现方法 怎么暴力的还用讲实现方法，好吧，讲一些基础的 要求区间求和，区间修改 对于每...
主席树入门详解二（学习笔记）（例题SPOJ - DQUERY 求区间数字种类数）
QDU_ZXF的博客
07-22 3867
主席树入门详解一链接 https://blog.csdn.net/weixin_42165981/article/details/81131661 Start~ 看了前一篇博客，应该已经对最基础的主席树有了一个大概的掌握。主席树的本质就是一堆线段树的集合（也就是包含历史版本的线段树），所以需要用一堆线段树来解决的问题，就可以用主席树来解决。主席树与线段树最大的区别就是主席树的左右儿子的节点编...
[四校联考P3] 区间颜色众数 (主席树)
diansi4274的博客
10-17 323
主席树 Description 给定一个长度为 N 颜色序列A，有M个询问：每次询问一个区间里是否有一种颜色的数量超过了区间的一半，并指出是哪种颜色。 Input 输入文件第一行有两个整数：N和C 输入文件第二行有N个1到C之间的整数，表示颜色序列A 输入文件第三行一个整数M，表示询问个数；接下来M行每行两个整数A和B，表示询问的区间是[A, B]。 Output 输出M行。对于第...
分块9 区间众数（分块写法）
permi_yaxileni的博客
11-25 331
求区间众数 更简单点的方法就是离线莫队，或者主席树，但是分块还是写写比较好 这题没测过，原因是我账号密码忘记了，反正就是好几个因素都有，导致我懒得测 分块9题目链接 思路就是 预处理出来每块到每块间的众数 对于一个L，R 要么是中间大的连续整块的众数为答案，要么就是不完整块中的某个数，一个数的个数可以提前存每个数出现的位置，二分求L,R间该数出现多少次 证明下时间复杂度 预处理每块到每块间的众数，总共有sqrt块 枚举l，跑到底是n复杂度，所以预处理是nsqrtn 枚举不完整...
数列分块求区间众数（学习笔记）
qq_35160381的博客
05-17 2907
数列分块 1. 区间加法，区间求和 简单分析一下：将数列划分为n−−√n\sqrt{n}个块，对于区间修改，整块的进行atag标记一下，非整块的最多只有2n−−√2n2\sqrt n个，暴力加一下 复杂度：O(n−−√)O(n)O(\sqrt n) #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cmath&gt...
P3567-Couriers-(出现的次数大于区间个数的一半==静态第K小主席树模板)
qq_42576687的博客
05-08 327
题目 假如一个数在区间出现的次数大于一半,第(r-l+3)/2小的一定是这个数，然后只要检测这个数出现的次数是否>一半即可。 #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> using namespace std; const int N=5e...
求区间不同数的个数【主席树求解】
逐梦者
09-12 1199
在线 模板 #include&lt;iostream&gt; #include&lt;algorithm&gt; #include&lt;cstring&gt; using namespace std; const int N=100010; int a[N],b[N],rt[N*20],ls[N*20],rs[N*20],sum[N*20],vis[N*20]; int id; voi...
P3567 [POI2014]KUR-Couriers 主席树
weixin_30389003的博客
08-02 105
给一个数列，每次询问一个区间内有没有一个数出现次数超过一半 主席树水题 // luogu-judger-enable-o2 #include<bits/stdc++.h> using namespace std; //input by bxd #define rep(i,a,b) for(int i=(a);i<=(b);i++) #defi...
区间 分块的暴力做法
CutieDeng的博客
08-12 883
区间 Description 萌萌哒Salroey最近得到了一个长度为n的正整数数列Si，下标从1开始标号，她现在想让你对于一个给定正整数k，求出tj表示区间[j,j+k-1]中所有元素的乘积（1≤j≤n-k+1）。 为了方便输出，你只需要把所有tj对P取模之后，输出它们的异或和。 Input 第一行三个正整数n,k,P,分别表示序列长度，区间长度和模数。 ...
c++可持久化线段树
最新发布
07-28
C++可持久化线段树是一种高效处理区间操作的数据结构，它可以在每次修改操作后保存一份新的线段树副本，并且可以在不影响原有版本的情况下进行查询操作。 这种数据结构的基本思想是通过复用已有线段树的节点，来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值