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

#include <algorithm>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#define R register

typedef long long ll;
typedef double db;

const int MAXN = 200010;
int N, M, a[MAXN], b[MAXN];

struct PTree{
    //主席树第i棵树存的是a[i]-a[0]的树(前缀和) 
    //l表示该节点的左儿子,r表示该节点的右儿子,
    //id表示当前树的根节点编号,sum表示当前区间所包含的数的个数
    int l, r, id, sum;
}pt[MAXN*10];
int cnt;

inline int read() {
    int num = 0, f = 1; char ch = getchar();
    while (!isdigit(ch)) { if (ch == ‘-‘) f = -1; ch = getchar(); }
    while (isdigit(ch)) { num = num * 10 + ch - ‘0‘; ch = getchar(); }
    return num * f; 
}

void Build (int &now, int l ,int r) {
    //当前节点没有在前面出现过时,用普通的建树方法
    //now在这里代指当前节点编号
    //类似与线段树的建树方法，但是主席树不满足线段树的节点与左儿子右儿子的关系
    //每次加入只是单纯的按计数器分配给当前节点一个值。
    now = ++ cnt;
    pt[now].sum = 0;
    if (l == r) return ;
    int mid = (l + r) >> 1;
    Build(pt[now].l, l, mid);
    Build(pt[now].r, mid + 1, r);
}

void update(int &now, int l, int r, int last, int x) {
    //为了防止MLE,若当前节点在之前出现过,直接从之前节点那里继承过来
    //update是主席树实现可持久化的函数
    //last是上个节点的编号
    now = ++ cnt;
    //继承前面节点的儿子
    pt[now].l = pt[last].l;
    pt[now].r = pt[last].r;
    //继承前面节点的sum并将当前的数加入,相当于sum+1
    pt[now].sum = pt[last].sum + 1;
    if (l == r) return ;
    int mid = (l + r) >> 1;
    //如果x<=mid,可知待处理元素在左子树中,右子树可以完全共用,可以直接由祖先节点访问到
    //只需要处理左子树即可。反之亦然
    if (x <= mid) update(pt[now].l, l, mid, pt[now].l, x);
    else update(pt[now].r, mid + 1, r, pt[now].r, x);
}

int query(int s, int t, int l, int r, int x) {
    //实际上是一个递归二分过程
    //pt[i]表示处理完前i个数之后形成的线段树
    if (l == r) return l;
    int mid = (l + r) >> 1;
    //若当前查询值小于左子树中存的个数,直接继续查询左子树中第x小的数
    int cnt = pt[pt[t].l].sum - pt[pt[s].l].sum;
    if (x <= cnt) return query(pt[s].l, pt[t].l, l, mid, x);
    //不然就向右子树中查询,显然问题变成在右子树中找x-cnt大的数
    else return query(pt[s].r, pt[t].r, mid + 1, r, x - cnt);
}

int main() {
    N = read(), M = read();
    for (R int i = 1; i <= N; ++ i) a[i] = read(), b[i] = a[i];
    //b[i]是a[i]的副本,下面是类似于离散化的东西,确定一共有多少不同的数出现过,确定树的大小
    std::sort(b + 1, b + N + 1);
    int Siz = std::unique(b + 1, b + N + 1) - b - 1;
    //先将原始的主席树建立出来
    Build(pt[0].id, 1, Siz);
    //用每个元素在b中的坐标重置a数组(离散化)
    for (R int i = 1; i <= N; ++ i) 
        a[i] = std::lower_bound(b + 1, b + Siz + 1, a[i]) - b;
    //可持久化操作,对于每个a[i]都往主席树中update
    for (R int i = 1; i <= N; ++ i) 
        update(pt[i].id, 1, Siz, pt[i - 1].id, a[i]);
    int x, y, z;
    while (M -- ) {
        x = read(), y = read(), z = read();
        //其实和一维前缀和很类似(pt[].sum就是前缀和)
        printf("%d\n", b[query(pt[x - 1].id, pt[y].id, 1, Siz, z)]);
    }
    return 0;
}