可持久化线段树模板 主席树

可持久化数据结构

可持久化前提：本身的拓扑结构不变

作用：记录修改了的历史邦本

主席树

可持久化线段树：简单思想就是每个被修改的节点重新建立一个节点 其余的节点连向先前版本。

由于线段树每次每次修改区间的操作数量都是logn级别的故可以保证 算法时间复杂度 为 mlogn

模板题

两道题目都来源于洛谷可持久化线段树模板题

如题，你需要维护这样的一个长度为 NN 的数组，支持如下几种操作

1. 在某个历史版本上修改某一个位置上的值
2. 访问某个历史版本上的某一位置的值

此外，每进行一次操作（对于操作2，即为生成一个完全一样的版本，不作任何改动），就会生成一个新的版本。版本编号即为当前操作的编号（从1开始编号，版本0表示初始状态数组）

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstring>
#include <string>
#include <cstdio>
using namespace std;
const int N = 1e6+5;


struct node
{
    int l,r,val;
}tri[4*N+50*N];
int idx;
int n,m;
int root[N];
int a[N];

int build(int l,int r)
{
    int p = ++idx;
    if(l==r)
    {
        tri[p].val = a[l];
        return p;
    }
    int mid = l + r >> 1;
    tri[p].l = build(l,mid);
    tri[p].r = build(mid+1,r);
    return p;
}

int insert(int q,int l,int r,int k,int x)//修改k号点的值 为x
{
    int p = ++idx;
    tri[p] = tri[q];
    if(l==r)
    {
        tri[p].val = x;
        return p;
    }
    int mid = l + r >> 1;
    if(k<=mid)tri[p].l = insert(tri[q].l,l,mid,k,x);
    else tri[p].r = insert(tri[q].r,mid+1,r,k,x);
    return p;
}

int query(int p,int l,int r,int k)
{
    if(l==r)return tri[p].val;
    int mid = l + r >> 1;
    if(k<=mid)return query(tri[p].l,l,mid,k);
    else return query(tri[p].r,mid+1,r,k);
}

int main()
{
    cin>>n>>m;

    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    //建立0号版本
    root[0] = build(1,n);

    int a,b,c,opt;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&a,&opt,&b);
        if(opt==1)
        {
            scanf("%d",&c);
            root[i] = insert(root[a],1,n,b,c);
        }
        else
        {
            root[i] = root[a];
            printf("%d\n",query(root[a],1,n,b));
        }
    }
    return 0;
}

给定长度为N的整数序列A，下标为 1∼N。

现在要执行M次操作，其中第i次操作为给出三个整数Li,Ri,Ki，求A[Li],A[Li+1],…,A[Ri] (即A的下标区间[Li,Ri])中第kiki小的数是多少。

/*
    由于输入的数字很大 但是总数很小 所以我们需要先进行离散化操作
    
    可持久化线段树：> 由于线段树每次每次修改区间的操作数量都是logn级别的故可以保证 算法时间复杂度 为 mlogn

    查询区间 内的数字有多少 那么就是查询不同版本之间的数量差 于是将原问题转化为 可持久化线段树
*/
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 2e5+10;
int a[N];
int n,m;
vector<int> nums;
int root[N];
struct node
{
    int l,r,cnt;
}tri[N*4+N*50];
int idx;
int find(int x)
{
    return lower_bound(nums.begin(),nums.end(),x) - nums.begin();
}

int build(int l,int r)
{
    int p = ++idx;
    if(l==r)return p;
    int mid = l + r >> 1;
    tri[p].l = build(l,mid),tri[p].r = build(mid+1,r);
    return p;
}

int insert(int q,int l,int r,int x)
{
    int p = ++idx;
    tri[p] = tri[q];
    if(l==r)
    {
        tri[p].cnt++;
        return p;
    }
    int mid = l + r >> 1;
    if(x<=mid)tri[p].l = insert(tri[q].l,l,mid,x);
    else tri[p].r = insert(tri[q].r,mid+1,r,x);
    tri[p].cnt = tri[tri[p].l].cnt + tri[tri[p].r].cnt;
    return p;
}

int query(int p,int q,int l,int r,int x)
{
    if(l==r)return r;
    int cnt = tri[tri[q].l].cnt - tri[tri[p].l].cnt;
    int mid = l + r >> 1;
    if(x<=cnt)return query(tri[p].l,tri[q].l,l,mid,x);
    else return query(tri[p].r,tri[q].r,mid+1,r,x-cnt);
}


int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        nums.push_back(a[i]);
    }
    //离散化
    sort(nums.begin(),nums.end());
    nums.erase(unique(nums.begin(),nums.end()),nums.end());

    root[0] = build(0,nums.size()-1);    
    
    for(int i=1;i<=n;i++)
    {
        root[i] = insert(root[i-1],0,nums.size()-1,find(a[i]));
    }
    int a,b,k;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&a,&b,&k);
        printf("%d\n",nums[query(root[a-1],root[b],0,nums.size()-1,k)]);
    }
    return 0;
}