主席树的不同建树方式

最新推荐文章于 2021-09-07 19:31:54 发布
最新推荐文章于 2021-09-07 19:31:54 发布
阅读量578 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 主席树 树苣结垢
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WeYoungg/article/details/77800653

主席树，又叫可持久化线段树，一种可持久化的数据结构。
一种基本用处是查询区间中排名为k的数字；还有一种是普通的线段树操作区间修改，区间查询，或者区间历史查询；另外还有一种用处是求区间有多少个不同的数字
它们的建树方式有所不同，

第一种的建树方式是先把所有数字去重+离散化，然后得到不重复数字的个数n，然后[l,r]这个节点里存的是当前前缀中[a[l] , a[r]]有多少个数字，这里跟普通的线段树存的东西不太一样，有点类似于权值线段树，不过是离散之后的权值线段树。

第二种的建树方式就是和线段树一样，然后每次修改新增一个 根，把需要修改的节点新建出来(利用lazy可以使得每次新建的节点不超过log n 个)。然后就可以回到过去查询历史的区间信息。有个地方要注意一下，这里的lazy实际上没有pushdown操作，而是标记了区间被加了多少，然后在查询的时候，把这个区间的值层层累加传递下去，直到目标区间，这样减少了pushdown中新增的lazy节点，节省了大量的空间。

第三种的建树方式和第二种类似，如果可以离线的话，我们知道可以让r排序，然后从小到大枚举r。假设当前枚举到r，a[r]前一次出现的位置记为p，p位置减去1，r位置加上1，然后查询[L,R]的和就是这一段有多少个不同数字出现。但是如果是在线的话，当我们询问到r的时候，会把前面某一个点减去，假设下次询问r-x时，就有可能这个点已经被减去导致结果变小。 所以一棵线段树是不够的，我们考虑建n棵线段树，但是每次插入一个 r ，实际上只会新增两条链，(如果该数字没有出现过则是一条)。
然后每次查询[l,r]，就是以第r棵线段树的根的[L,R]这段的和。
贴一下几种用法的模板题
第一种用法的模板题，hdu2665

#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<set>
#include<map>
#include<time.h>
#include<cstdio>
#include<vector>
#include<list>
#include<stack>
#include<queue>
#include<iostream>
#include<stdlib.h>
using namespace std;
#define  LONG long long
const int   INF=0x3f3f3f3f;
const LONG  MOD=1e9+ 7;
const double PI=acos(-1.0);
#define clrI(x) memset(x,-1,sizeof(x))
#define clr0(x) memset(x,0,sizeof x)
#define clr1(x) memset(x,INF,sizeof x)
#define clr2(x) memset(x,-INF,sizeof x)
#define EPS 1e-10
#define lson  l , mid , rt<< 1
#define rson  mid + 1 ,r , (rt<<1)+1
#define root 1, n , 1
const int MAXN = 1e5 ;
struct Tree{
    int l, r ;
    int val ;
}tree[MAXN *30+ 30];
int N , n ;
int a[100100] ;
int Root[100100] ;
int tot = 0;
int num[100100] ;
void Push_up(int rt )
{
    tree[rt].val = tree[tree[rt].l].val + tree[tree[rt].r].val ;
}
int Build(int l, int r)
{
    int rt = tot ++ ;
    if(l == r)
    {
        tree[rt].val = 0 ;
        return rt ;
    }
    int mid = (l + r) / 2;
    tree[rt].l = Build(l , mid ) ;
    tree[rt].r = Build(mid + 1, r) ;
    Push_up(rt) ;
    return rt ;
}
void Hash()
{
    sort(a + 1, a +N+1 ) ;
    n = unique(a +1 , a + N +1 ) - a - 1;
}
int Update(int l ,int r , int rt , int x)
{
    tot ++ ;
    int now = tot ;
    tree[now] = tree[rt] ;
    if(l ==r )
    {
        tree[now].val ++ ;
        return now;
    }
    int mid = ( l + r ) / 2;
    if( x <= a[mid])
        tree[now].l = Update(l , mid , tree[now].l ,x) ;
    else
        tree[now].r = Update(mid + 1, r , tree[now].r , x) ;
    Push_up( now ) ;
    return now  ;
}
int Que( int l , int r , int R_rt ,int L_rt , int k)
{
    if(  ( l == r) )
        return a[l];
    int mid = (l +r ) / 2;
    if(k > tree[tree[R_rt].l].val - tree[tree[L_rt].l].val )
        return Que(mid+1 ,r , tree[R_rt].r,tree[L_rt].r , k - tree[tree[R_rt].l].val + tree[tree[L_rt].l].val  ) ;
    else
        return Que(l , mid ,tree[R_rt].l, tree[L_rt].l , k ) ;
}
int main()
{
    int T ;
    cin >> T ;
    int m ;
    while(T --)
    {
        tot = 0 ;
        scanf("%d%d",&N ,&m);
        for(int i =1 ; i <= N ;++ i)
            scanf("%d",&a[i]),num[i] = a[i] ;
        Hash() ;
        int now = 0 ;
        Root[0] = Build(1 , n );
        int p ;
        for(int i = 1;i<= N ; ++ i)
            Root[i] = Update(1 , n , Root[i-1] , num[i] ) ;
        int K ;
        int l , r ;
        while(m --)
        {
            scanf("%d%d%d",&l,&r, &K) ;
            cout<<Que(1,n,Root[r],Root[l-1] , K)  <<endl ;;
        }
    }
}

第二种用法区间更新，区间查询，区间历史查询,hdu4348

#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<set>
#include<map>
#include<time.h>
#include<cstdio>
#include<vector>
#include<list>
#include<stack>
#include<queue>
#include<iostream>
#include<stdlib.h>
using namespace std;
#define  LONG long long
const int   INF=0x3f3f3f3f;
const LONG  MOD=1e9+ 7;
const double PI=acos(-1.0);
#define clrI(x) memset(x,-1,sizeof(x))
#define clr0(x) memset(x,0,sizeof x)
#define clr1(x) memset(x,INF,sizeof x)
#define clr2(x) memset(x,-INF,sizeof x)
#define EPS 1e-10
#define lson  l , mid , rt<< 1
#define rson  mid + 1 ,r , (rt<<1)+1
#define root 1, m , 1
const int MAXN = 100000*30+55;
struct Tree{
    LONG Sum ;
    int l ,r ;
    LONG lazy ;
}tree[MAXN ];

int tot = 0;
int Root[101000] ;
int now =0 ;
int  Build(int l ,int r )
{
    tot ++ ;
    int rt = tot ;
    tree[rt].lazy = 0 ;
    if ( l == r)
    {
        scanf("%lld" , &tree[rt].Sum) ;
        return rt ;
    }
    int mid =  (l+r) / 2;
    tree[rt].l = Build(l,mid ) ;
    tree[rt].r = Build(mid+1 , r  );
    tree[rt].Sum = tree[tree[rt].l].Sum + tree[tree[rt].r].Sum ;
    return rt ;
}
int Update(int L, int R , int l ,int r ,int rt , LONG val )
{
    tot ++ ;
    int now = tot ;
    tree[now] = tree[rt] ;
    if( L <=  l && r <= R)
    {
        tree[ now ].Sum += ( r - l + 1) * val ;
        tree[ now ].lazy += val ;
        return now ;
    }
    int mid = ( l +r )/ 2;
    if( L <= mid)
    tree[now].l = Update(L, R , l,mid, tree[now].l , val) ;
    if(R > mid )
        tree[now].r = Update(L ,R , mid + 1 ,r , tree[now].r  ,val ) ;
    tree[now].Sum = tree[tree[now].l ].Sum + tree[tree[now].r].Sum + ( r - l + 1) * tree[now].lazy  ;
    return now ;
}
LONG Query(int L ,int R  , int l , int r ,int rt  ,LONG val )
{
    if(L <= l && r <= R)
        return tree[rt].Sum + ( r - l + 1) *val ;
    int mid = ( l +r )/ 2;
    LONG ans = 0;
    if(L <= mid)
        ans += Query(L , R , l , mid , tree[rt].l , val + tree[rt].lazy) ;
    if(R > mid )
        ans += Query(L ,R , mid + 1 ,r ,tree[rt].r , val + tree[rt].lazy) ;
    return ans ;
}
int main()
{
    int n , m;
    while(~scanf("%d%d",&n,&m))
    {
        tot= 0 ;
        now= 0;
        Root[now] = 1;
        char op[5] ;
        int l ,r ;
        LONG val ;
        int t ;
        Root[now] = Build(1 , n ) ;
        while(m -- )
        {
            scanf("%s" , op);
            if(op[0] =='C')
            {
                scanf("%d%d%lld",&l,&r ,&val) ;
                Root[++now] = Update(l ,r , 1 , n ,Root[now-1] , val) ;
            }
            else if(op[0] == 'Q')
            {
                scanf("%d%d",&l, &r ) ;
                printf("%lld\n",Query(l ,r ,1,n,Root[now] , 0) ) ;
            }
            else if(op[0] == 'H')
            {
                scanf("%d%d%d",&l ,&r ,&t) ;
                printf("%lld\n",Query(l , r ,1 , n , Root[t] , 0) ) ;
            }
            else
                scanf("%d",&now ) ;
        }
    }
}

求区间不同数字个数的用法spoj DQUERY

#include<bits/stdc++.h>
using namespace std;
#define  LONG long long
const int   INF=0x3f3f3f3f;
const LONG  MOD=1e9+ 7;
const double PI=acos(-1.0);
#define clrI(x) memset(x,-1,sizeof(x))
#define clr0(x) memset(x,0,sizeof x)
#define clr1(x) memset(x,INF,sizeof x)
#define clr2(x) memset(x,-INF,sizeof x)
#define EPS 1e-10
const int MAXN = 3e4+10 ;
struct Tree
{
    int l ,r ;
    int sum ;
}tree[MAXN*30];
int Root[30100] ;
int pos[1001000] ;
int tot = 0;
int Build(int l ,int r)
{
    tot ++ ;
    int now = tot ;
    tree[now].sum = 0 ;
    if( l == r)return now ;
    int mid = (l + r ) / 2;
    tree[now].l = Build( l , mid ) ;
    tree[now].r = Build( mid + 1, r ) ;
    return now ;
}
int Update(int p, int l ,int r ,int rt , int val)
{
    tot ++ ;
    int now = tot ;
    tree[now] = tree[rt] ;
    if( r == l && p == l)
    {
        tree[now].sum += val ;
        return now ;
    }
    int mid = ( l + r) / 2 ;
    if( p <= mid)
        tree[now].l = Update(p , l , mid , tree[now].l , val ) ;
    else
        tree[now].r = Update( p , mid + 1, r , tree[now].r , val) ;
    tree[now].sum =  tree[tree[now].l ].sum + tree[tree[now].r].sum  ;
    return now ;
}

int Que(int L ,int R  , int l ,int r , int  R_rt )
{
    if( L <= l && r <= R )
        return tree[R_rt].sum  ;
    int mid = ( l + r ) / 2;
    int res = 0 ;
    if(L <= mid )
        res += Que( L , R , l ,mid , tree[R_rt].l ) ;
    if(R > mid)
        res += Que(L , R , mid + 1, r , tree[R_rt].r ) ;
    return res ;
}
int main()
{
    int n ;
    while(cin >> n)
    {
        clr0(pos) ;
        int tmp ,p , q ;
        Root[0 ] = Build(1 , n ) ;
        for(int i =  1;i <= n ;++ i)
        {
            scanf("%d",&tmp) ;
            p = pos[tmp] ;
            Root[i] = Update( i , 1 , n , Root[i-1],1 ) ;
            if(p != 0)
                Root[i] = Update(p , 1 , n , Root[i],-1 ) ;
            pos[tmp] = i ;
        }
        cin >> q ;
        int l ,r ;
        int res2 ,res1 ;
        while(q --)
        {
            scanf("%d%d",&l,&r);
            res1 = Que( l , r , 1 , n , Root[r] ) ;
            printf("%d\n",res1  ) ;
        }
    }
}
ACM竞赛算法之线段树
Boss_Xie的博客
01-12 1149
线段树是一个很重要的数据结构，而且在算法竞赛中用处也十分巨大，但很多人往往认为线段树是一个算法，可以完成某些功能，但是实际上完全可以把它看成是一个容器，用来执行的操作可以按照需求修改 首先思考如下问题： 思考一、现在如果有一个长度为n的序列，有m次操作，操作中包含区间求和，某点修改，并且n和m特别大 思考二、现在给你一个长度为n的序列，有m次操作，操作中仅包含求区间内最大值或最小值的问题
【学习笔记】主席树
blog
08-13 280
主席树（可持久化线段树 学习笔记
动态主席树
OI_ljq的博客
02-08 516
浅谈动态主席树 所有有关静态主席树的内容都不再赘述,可以单击查看 基本思想 区间第k小的问题我们可以用静态主席树来维护，但是一些题目往往会增加修改操作，那么我们应该怎么做呢，先看例题。 给定一个含有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)...
主席树（简单理解）
solity-_-的博客
10-23 370
2020JMU天梯校选题目记录思路离散化+去重插入建树区间查询 pta题目链接 邪恶学长 单纯的模板题目，求区间第k大 思路 离散化+去重 离散化的目的是防止数据过大，建树过程中造成内存过大。大致过程就是讲整组数据排序，然后按照顺序赋予一个序号，使得序号和数据对应，建树插入的就是对应序号。去重就是删除重复的部分采用一个函数unique将重复的部分放到最后，并返回重复部分的第一个地址，要求数据有序 for (int i = 1; i <= n; i++) { cin &g
树上主席树（洛谷 P2633 Count on a tree）
平凡人Kalzn的博客
09-29 243
题目链接 学了学树上主席树。之前一直以为树上主席树必须和树链剖分结合，学了之后发现不用。直接按照自然dfs序建树。每个节点都继承自它的fa节点。然后我们查询某路径(x,y)： tr[x].sum+tr[y].sum−tr[lca(x,y)].sum−tr[fa(lca(x,y))].sumtr[x].sum + tr[y].sum - tr[lca(x,y)].sum - tr[fa(lca(x,...
权值线段树和主席树入门
09-25
权值线段树和主席树入门PPT，权值线段树，顾名思义就是记录权值的线段树，普通的线段树直接以坐标为l，r建树，而权值线段树是以大小来建树，树上寸的信息是该权值的数量，而通过建树时二分从小到大的性质，可以用这...
HDU 4348 To the moon 主席树 + 区间更新
弱智就要多努力
10-01 1126
题目：http://acm.hdu.edu.cn/showproblem.php?pid=4348 题意：给定长度为n的数组，有四种操作：C l r d把[l, r]内的元素全部加上d并把时间计数器加1，Q l r查询[l, r]内元素的和，H l r t查询t时刻[l, r]内元素的和，B t返回时刻t(保证只向前而不向后跳) 思路：跳回之前的某个状态，明显是可持久化数据结构，这题就是明显的
C++主席树的单点修改&单点查询模板代码详解
Andysun06的博客
08-13 497
部分操作和线段树相似，本文不作解释，如果对未作解释的部分有疑问的，可以看这篇博文，讲得很详细 #include<iostream> #include<cstdio> #define reint register int using namespace std; int n,m; int s[1000005],v,loc,value,p,root[1000005],top; //s存原数组，v,loc,value,p意义与题目相同，root存根，top统计节点数 struct n.
【算法学习】主席树入门
热门推荐
Pengwill's Blog
07-04 2万+
主席树入门 原理 主席树入门 主席树，也叫做可持久化线段树，准确来说，应该叫做可持久化权值线段树，因为其中的每一颗树都是一颗权值线段树。 所谓权值线段树，就是指线段树的叶子节点保存的是当前值的个数。这样说起来比较抽象，下面用具体例子来简单阐述。 如有数列：2 1 2 5 1 1 1 3，不难统计出，数列中数字1出现了4次，数字2出现了2次，数字3、数字5都出现了1次，对于这...
线段树及主席树---板子题
NP_hard的博客
12-19 361
文章目录线段树及主席树个人理解线段树理解线段树模板主席树理解（可持久化线段树）问题 A: 敌兵布阵题目描述输入输出样例输入样例输出代码问题 B: 最大数题目描述输入输出样例输入样例输出代码问题 C: Distinct Characters Queries(英文题面)(线段树)题目描述输入输出样例输入样例输出代码问题 D: Kth number题目描述输入输出样例输入样例输出代码目的 线段树及主席树 个人理解 线段树理解 由于只是一个个人笔记，故这里不再赘述 参考博客 https://www.cnblogs.
主席树 （动态）图文讲解让你一次就懂 zoj2112为例
WilliamSun0122的博客
09-07 8135
主席树（动态）学动态主席树之前一定要先会静态主席树。 静态主席树：http://blog.csdn.net/williamsun0122/article/details/77871278参考博客：http://www.cnblogs.com/Empress/p/4659824.html 这个博客讲的是对的，不过它的图和代码好像是错的，虽然能过，但应该是数据不够强，具体怎么错的它的博客下面评论有。
To the moon(主席树)两种方法带你完成哟
weixin_43925900的博客
01-15 472
如果我们用可持续化线段树去完成这道题。最大的难题是如何保证后来生成的树不会对以前的树产生影响
主席树进阶
weixin_30387663的博客
08-03 130
HDU-4348 To the moon Description You‘ve been given N integers A [1], A [2],..., A [N]. On these integers, you need to implement the following operations: 1. C l r d: Adding a constant d for every...
主席树学习笔记
萌の上揺れ
02-21 317
今天学习了一个特殊的线段树结构，主席树。概念：主席树是一种可持久化的线段树结构，然后没了= =用途：主席树的最基本用途是查询a[l]a[l]……a[r]a[r]的x∈[L,R]x\in \left [ L, R \right ]的xx的个数。 引申还可以查询区间中第K小的数是什么。等等……结构：对于主席树的结构理解，我自己阅读多篇他人的博客，才终于明白了是怎么一回事。不知是博客写的不好还是我的理解
可修改主席树(树状数组套主席树)
yzyyylx的博客
01-26 641
作用 普通主席树可以查询区间k小值,但若直接修改,则复杂度极大,而可修改主席树通过树状数组的辅助来修改,大大缩小了时间复杂度,缺点是空间复杂度过大. 修改的时间复杂度为O((logn)^2),空间复杂度为O(n*logn^2). 实现方法 为了减小修改复杂度,可以修改每个区间管理的范围. 传统主席树每个点对应的主席树管理一个前缀,而可修改主席树因为树状数组在处理动态区间和上有优势
主主主主主席树Orz
the CodeRoom of wjfwzzc
04-27 3154
断断续续一个月，才稍稍搞明白一点主席树，真是累煞我也。果然遇上这种高级
主席树学习小结
colorfulshark
01-28 441
可持久化线段树，也叫作函数式线段树，也就是主席树，（。。。因为先驱就是fotile主席。。Orz。。。） 网上的教程很少啊，有的教程写得特别简单，4行中文，然后就是一篇代码～～ 这里，我将从查找区间第k小值（不带修改）题的可持久化线段树做法中，讲一讲主席树。 /*只是略懂，若有错误，还请多多包涵！*/ 可持久化数据结构(Persistent data structure
【算法与数据结构】——主席树，可持久化线段树
气派飞鹰的博客
09-07 191
参考文章ACM数据结构（一）——主席树 可持久化专题（一）——浅谈主席树：可持久化线段树
可持久化线段树（主席树）入门笔记
weixin_30246221的博客
02-20 230
何为可持久化线段树 　 我们通常建立的线段树是可以支持修改操作更新操作和查询操作的，却不支持保存你更改每个操作的历史版本。而可持久化线段树就是可以保存各个历史版本的线段树。 最朴素的保存各个历史版本的线段树就是将每次更改后的线段树都保存下来，但是这样操作有个很严重的问题：太吃空间了。你n次修改就要保存n+1棵树，数据量一大，你所需要的空间就直线上升。 那有没有什么好解决...
红黑树建树过程模拟及可视化演示
GDI技术在绘制红黑树时，会按照红黑树的特性进行颜色的设置和节点的连接线绘制，使得用户能够直观地看到红黑树的结构，理解树的平衡状态以及数据的组织方式。 红黑树的应用非常广泛，在诸如C++ STL中的map、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值