[luogu3834]静态区间第k小

传送门：https://www.luogu.org/problemnew/show/P3834

题目描述

如题，给定N个整数构成的序列，将对于指定的闭区间查询其区间内的第K小值。

分析

很多人都说是用主席树来维护，一开始蒟蒻chh做这道题的时候还以为是分块乱搞，但是发现常数非常的大，就转用主席树了。这道题我们维护的主席树是一个权值线段树，意思就是维护一个桶，那么我们手动模拟主席树的建树过程，可以发现如果我们要查询区间\([l,r]\)，那么发现编号为l-1的主席树和编号为r的主席树上对应的链上的差值就是我们区间上有多少个数是这样的。参照二叉搜索树的查找第k大的方法，我们就只需要每一次比较两个链上数值的差值和我们需要k大小，选择路径查询就可以做出来了。
注一句：这道题目因为维护的是权值线段树，那么题目中给出的1e9实在是太大了，那么我们就离散化一下，还是非常简单的。

ac代码

#include <bits/stdc++.h>
#define ll long long
#define ms(a, b) memset(a, b, sizeof(a))
#define inf 0x3f3f3f3f
#define N 200005
using namespace std;
template <typename T>
inline void read(T &x) {
    x = 0; T fl = 1;
    char ch = 0;
    while (ch < '0' || ch > '9') {
        if (ch == '-') fl = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    x *= fl;
}
struct Last_segment_tree {
    #define mid ((l + r)>> 1)
    int tot;
    int rt[N];
    struct node {
        int lc, rc, s;
        node() {
            lc = rc = s = 0;
        }
    }tr[N * 35];
    Last_segment_tree() {
        tot = 0;
    }
    void build(int &nod, int l, int r) {
        nod = ++ tot;
        if (l == r) return;
        build(tr[nod].lc, l, mid);
        build(tr[nod].rc, mid + 1, r);
    }
    void update(int &nod, int pre, int l, int r, int k) {
        nod = ++ tot;
        tr[nod] = tr[pre]; tr[nod].s ++;
        if (l == r) return;
        if (k <= mid) update(tr[nod].lc, tr[pre].lc, l, mid, k);
        else update(tr[nod].rc, tr[pre].rc, mid + 1, r, k);
    }
    int query(int x, int y, int l, int r, int k) {
        if (l == r) return l;
        int a = tr[tr[y].lc].s - tr[tr[x].lc].s;
        if (a >= k) return query(tr[x].lc, tr[y].lc, l, mid, k);
        else return query(tr[x].rc, tr[y].rc, mid + 1, r, k - a);
    }
    int kth(int l, int r, int ql, int qr, int k) {
        return query(rt[ql - 1], rt[qr], l, r, k);
    }
}lstr;
int n, m;
int a[N], disc[N];
int main() {
    read(n); read(m);
    for (int i = 1; i <= n; i ++) {
        read(a[i]);
        disc[i] = a[i];
    }
    sort(disc + 1, disc + 1 + n);
    int d = unique(disc + 1, disc + 1 + n) - disc - 1;
    lstr.build(lstr.rt[0], 1, d);
    for (int i = 1; i <= n; i ++) {
        a[i] = lower_bound(disc + 1, disc + 1 + d, a[i]) - disc;
        lstr.update(lstr.rt[i], lstr.rt[i - 1], 1 , d, a[i]);
    }
    while (m --) {
        int x, y, z;
        read(x); read(y); read(z);
        int p = lstr.kth(1, d, x, y, z);
        printf("%d\n", disc[p]);
    }
    return 0;
}