权值线段树&&可持久化线段树&&主席树

Posted 2022-12-10 yzhx

权值线段树

顾名思义，就是以权值为下标建立的线段树。

现在让我们来考虑考虑上面那句话的产生的三个小问题:

1. 如果说权值作为下标了,那这颗线段树里存什么呢?
————— 这颗线段树中, 记录每个值出现的次数

2.权值很大怎么办?数组空间不够啊
————— 可以先离散化,再记录

3.那权值线段树到底是用来干嘛的呢?
————— 可以快速求出第k小值（其实主要还是为了主席树做铺垫啦）

那第k小值该怎么求呢???
从树根依次往下
若当前值K大于左儿子的值,则将K-=左儿子的值,然后访问右儿子
若当前值K小于左儿子的值,则直接访问左儿子
直到访问到叶子节点时,那么该节点所代表的那个数就是要求的第k小值
(因为其实节点中存的值是该值域区间的数字出现次数,所以第k小值前面一定会有k-1个数出现过)

代码就不给了

可持久化线段树

普通的线段树单点修改操作与区间查询自然不是问题
可是
假如当前询问若干修改操作之前的区间呢???

仔细想想
.
.
.
最暴力的做法无疑是对于每个修改操作重开一个线段树,
可是...这样显然空间开不下
那我们能不能优化一下呢

我们看看对于一次单点修改,这颗线段树操作前和操作后有什么不同吧

有点小丑,凑合着看
观察一下这两颗树,发现它们有区别的地方仅仅在于红色的方框
哎??? 这不是此次操作修改的目标元素到根的路径吗

既然只有这条路径变了,那我们就只复制这条路径好了,不用再复制整棵树了
所以空间就能大大的缩小了(log级)

代码 (洛谷模板)

#include<bits/stdc++.h>
using namespace std;
#define re register
#define ll long long
#define get getchar()
#define in inline
in int read()

    int x=1,t=0; char ch=get;
    while((ch<'0' || ch>'9') && ch!='-') ch=get;
    if(ch=='-') ch=get,x=-1;
    while(ch<='9' && ch>='0') t=t*10+ch-'0', ch=get;
    return t*x;

const int _=1e6+6;
int n,m,a[_],tot,root[_<<5],ls[_<<5],rs[_<<5],val[_<<5]; // ls == leftson,rs == rightson
in int build(int l,int r)

    int now=++tot;
    if(l==r)
    
        ls[now]=rs[now]=0;
        val[now]=a[l];
        return now;
    
    int mid=(l+r)>>1;
    ls[now]=build(l,mid);
    rs[now]=build(mid+1,r);
    return now;
 //初始时的线段树
in int add(int k,int l,int r,int x,int t)

    int now=++tot;
    if(l==r)
    
        val[now]=t;
        ls[now]=rs[now]=0;
        return now;
     //到了目标点,修改它
    ls[now]=ls[k],rs[now]=rs[k];
    int mid=(l+r)>>1;
    if(x<=mid) ls[now]=add(ls[now],l,mid,x,t); //若目标点在原树的左子树上,则新建左儿子
    else rs[now]=add(rs[now],mid+1,r,x,t); //若在右儿子上,同理
    return now;
 //修改并添加新路径
in int query(int k,int l,int r,int x)

    if(l==r) return val[k];
    int mid=(l+r)>>1;
    if(x<=mid) return query(ls[k],l,mid,x);
    else return query(rs[k],mid+1,r,x);
 //查询
int main()

    n=read(),m=read();
    for(re int i=1;i<=n;i++)
        a[i]=read();
    root[0]=build(1,n);
    for(re int i=1;i<=m;i++)
    
        int v=read(),o=read();
        if(o==1)
        
            int x=read(),y=read();
            root[i]=add(root[v],1,n,x,y);
        
        else
        
            int x=read();
            cout<<query(root[v],1,n,x)<<endl;
            root[i]=root[v];
        
    
    /*for(re int i=0;i<=10;i++)
    
        cout<<"case #"<<i<<":    ";
        for(re int j=1;j<=n;j++)
        cout<<query(root[i],1,n,j)<<' ';
        cout<<endl;
    //打印每个历史版本 */ 
    return 0;

/*
 9.30 By yzhx
*/

静态主席树

可以用来求区间第k小/大值

说白了,就是把我们上面讲到的两个东西加起来,也就是用 可持久化权值线段树

再来看建树的具体步骤:
1.建一颗空线段树
2.依次把每个值加入这颗线段树(看做是一个修改操作)

查询:
(若当前查询的区间 l~r)
则直接把历史版本r 与 历史版本l-1, 直接加减,就能得到当前这个区间每个数出现的情况了

代码 (洛谷模板)

#include<bits/stdc++.h>
using namespace std;
#define re register
#define ll long long
#define in inline
#define get getchar()
in int read()

    int t=0,x=1; char ch=get;
    while((ch<'0' || ch>'9') && ch!='-') ch=get;
    if(ch=='-') ch=get,x=-1;
    while( ch<='9' && ch>='0') t=t*10+ch-'0', ch=get;
    return t*x;

const int _=2e5+5;
int tot,cnt,n,m,a[_],b[_],sum[_<<6],ls[_<<6],rs[_<<6],root[_];
in int build(int l,int r)

    int now=++cnt;
    if(l==r)
    
        sum[now]=ls[now]=rs[now]=0;
        return now;
    
    int mid=(l+r)>>1;
    ls[now]=build(l,mid),rs[now]=build(mid+1,r);
    return now;
 //建一颗空树
in int add(int k,int l,int r,int x)

    int now=++cnt;
    if(l==r)
    
        ls[now]=rs[now]=0;
        sum[now]=sum[k]+1;
        return now;
    
    int mid=(l+r)>>1;
    ls[now]=ls[k],rs[now]=rs[k],sum[now]=sum[k];
    if(x<=mid) ls[now]=add(ls[k],l,mid,x);
    else rs[now]=add(rs[k],mid+1,r,x);
    sum[now]=sum[rs[now]]+sum[ls[now]];
    return now;
 //加入每个元素
in int query(int k1,int k2,int l,int r,int x)

    if(l==r) return a[l];
    int mid=l+r>>1;
    int t=sum[ls[k2]]-sum[ls[k1]];
    if(x<=t) return query(ls[k1],ls[k2],l,mid,x);
    else return query(rs[k1],rs[k2],mid+1,r,x-t);
 //查询
int main()

    n=read(),m=read();
    for(re int i=1;i<=n;i++)
        b[i]=a[i]=read();
    sort(a+1,a+n+1);
    tot=unique(a+1,a+n+1)-(a+1);
    root[0]=build(1,n);
    for(re int i=1;i<=n;i++)
    
        //  if(i<=tot) cout<<a[i]<<' ';
        int x=lower_bound(a+1,a+tot+1,b[i])-a;
        root[i]=add(root[i-1],1,tot,x);
    
    //cout<<endl;
    for(re int i=1;i<=m;i++)
    
        int l=read(),r=read(),k=read();
        printf("%d\n",query(root[l-1],root[r],1,tot,k));