[数据结构]可持久化权值线段树

https://www.luogu.com.cn/problem/P3834
解决静态区间第k小的问题。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int tot, n, m;
int sum[maxn << 5], rt[maxn], ls[maxn << 5], rs[maxn << 5];
int a[maxn], ind[maxn], len;
inline int getid(const int &val)
{
    return lower_bound(ind + 1, ind + len + 1, val) - ind;
}
int build(int l, int r)
{
    int root = ++tot;
    if (l == r) return root;
    int mid = l + r >> 1;
    ls[root] = build(l, mid);
    rs[root] = build(mid + 1, r);
    return root;
}
int update(int k, int l, int r, int root)
{
    int dir = ++tot;
    ls[dir] = ls[root], rs[dir] = rs[root], sum[dir] = sum[root] + 1;
    if (l == r) return dir;
    int mid = l + r >> 1;
    if (k <= mid) ls[dir] = update(k, l, mid, ls[dir]);
    else rs[dir] = update(k, mid + 1, r, rs[dir]);
    return dir;
}
int query(int u, int v, int l, int r, int k)
{
    if (l == r) return l;
    int mid = l + r >> 1, x = sum[ls[v]] - sum[ls[u]];
    if (k <= x) return query(ls[u], ls[v], l, mid, k);
    else return query(rs[u], rs[v], mid + 1, r, k - x);
}
inline void init()
{
    memcpy(ind, a, sizeof(a));
    sort(ind + 1, ind + n + 1);
    len = unique(ind + 1, ind + n + 1) - ind - 1;
    rt[0] = build(1, len);
}
int main()
{
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= n; ++i) scanf("%d", a + i);
    init();
    for (int i = 1; i <= n; ++i) rt[i] = update(getid(a[i]), 1, len, rt[i - 1]);

    int l, r, k;
    while (m--) {
        scanf("%d %d %d", &l, &r, &k);
        printf("%d\n", ind[query(rt[l - 1], rt[r], 1, len, k)]);
    }
    return 0;
}

My Style

#include<bits/stdc++.h>
using namespace std;
//可持久化权值线段树
const int maxn = 2e5 + 5;
struct e{
    int l, r, sum = 0;
}tree[20 * maxn];//tree存的是所有叶子节点
//现在的树不再是2*i左子树2*i+1右子树了，所有子树都要保存左右节点在tree里的编号
struct dis{
    int v, id;
}a[maxn];

int tot, root[maxn], rk[maxn];//cnt代表开了多少叶子节点
//那么root代表啥？因为每次插入的时候会从根节点开始新加一条链
//那么就相当于多个root节点了，root[i]存的是第i次插入分裂出来的根在tree里的下标
bool cmp(const dis &x, const dis &y){return x.v < y.v;}
//返回根节点
int update(int l, int r, int rt, int k)//rt代表需要复制的节点下标
{
    int dir = ++tot;//新开节点的下标
    tree[dir] = tree[rt];//复制前一个根节点
    ++tree[dir].sum;//数量+1
    if (l == r) return dir;//返回当前根节点
    int m = (l + r) >> 1;
    //如果在左边，那么左边分裂
    if (k <= m) tree[dir].l = update(l, m, tree[rt].l, k);
    //否则右边分裂
    else tree[dir].r = update(m + 1, r, tree[rt].r, k);
    return dir;
}
//返回的是那个点的位置
int query(int l, int r, int x, int y, int k)
{
    if (l == r) return l;
    int num = tree[tree[y].l].sum - tree[tree[x].l].sum;
    int m = (l + r) >> 1;
    if (k <= num) return query(l, m, tree[x].l, tree[y].l, k);
    else return query(m + 1, r, tree[x].r, tree[y].r, k - num);
}
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= n; ++i) scanf("%d", &a[i].v), a[i].id = i;
    sort(a + 1, a + 1 + n, cmp);
    for (int i = 1; i <= n; ++i) rk[a[i].id] = i;//每个点的值是全部值第几小的

    for (int i = 1; i <= n; ++i){
        root[i] = update(1, n, root[i - 1], rk[i]);
    }

    int l, r, k;
    while (m--){
        scanf("%d %d %d", &l, &r, &k);
        printf("%d\n", a[query(1, n, root[l - 1], root[r], k)].v);
    }
    return 0;
}