可持久化线段树模板

区间第k小：

const int N = 100000 + 10, INF = 0x3f3f3f3f;

int lson[N*20], rson[N*20], sum[N*20];
int root[N];
int tot;
int a[N], b[N];
void build(int l, int r, int &x)
{
    x = ++tot;
    sum[x] = 0;
    if(l == r) return;
    int mid = (l + r) >> 1;
    build(l, mid, lson[x]);
    build(mid + 1, r, rson[x]);
}
void update(int l, int r, int val, int pre, int &x)
{
    x = ++tot;
    lson[x] = lson[pre], rson[x] = rson[pre], sum[x] = sum[pre] + 1;
    if(l == r) return;
    int mid = (l + r) >> 1;
    if(val <= mid) update(l, mid, val, lson[pre], lson[x]);
    else update(mid + 1, r, val, rson[pre], rson[x]);
}
int query_rank(int l, int r, int val, int st, int en)//区间第k小用不到这个函数
{//查询val在[st+1,en]是第几小，若有多个相等的val，则返回最后一个val的rank，
    if(l == r) return sum[en] - sum[st];//此处只需要修改为return 0;则返回第一个val的rank
    int mid = (l + r) >> 1;
    if(val <= mid) return query_rank(l, mid, val, lson[st], lson[en]);
    else return sum[lson[en]] - sum[lson[st]] + query_rank(mid + 1, r, val, rson[st], rson[en]);
}
int query(int l, int r, int k, int st, int en)//查询[st+1,en]区间内的第k小值
{
    if(l == r) return l;
    int mid = (l + r) >> 1;
    int tmp = sum[lson[en]] - sum[lson[st]];
    if(tmp >= k) return query(l, mid, k, lson[st], lson[en]);
    else return query(mid + 1, r, k - tmp, rson[st], rson[en]);
}
int main()
{
    int n, m;
    while(~ scanf("%d%d", &n, &m))
    {
        for(int i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = a[i];
        sort(b + 1, b + 1 + n);
        int len = unique(b + 1, b + 1 + n) - b - 1;
        tot = 0;//用来分配节点，一定记得初始化
        build(1, len, root[0]);
        for(int i = 1; i <= n; i++)
        {
            a[i] = lower_bound(b + 1, b + 1 + len, a[i]) - b;
            update(1, len, a[i], root[i-1], root[i]);
        }
        int l, r, k;
        for(int i = 1; i <= m; i++)
        {//[l,r]内的第k小
            scanf("%d%d%d", &l, &r, &k);
            int ans = b[query(1, len, k, root[l-1], root[r])];
            printf("%d\n", ans);
        }
    }
    return 0;
}

另一份不太一样的模板，update和query没有递归

const int N = 100000 + 10, INF = 0x3f3f3f3f;

int lson[N*20], rson[N*20], sum[N*20];
int root[N];
int tot;
int a[N], b[N];
int build(int l, int r)
{
    int x = ++tot;
    sum[x] = 0;
    if(l != r)
    {
        int mid = (l + r) >> 1;
        lson[x] = build(l, mid);
        rson[x] = build(mid + 1, r);
    }
    return x;
}
int update(int l, int r, int val, int pre)
{
    int x = ++tot, tmp = x;
    sum[x] = sum[pre] + 1;
    while(l < r)
    {
        int mid = (l + r) >> 1;
        if(val <= mid)
        {
            lson[x] = tot++; rson[x] = rson[pre];
            x = lson[x], pre = lson[pre];
            r = mid;
        }
        else
        {
            rson[x] = tot++; lson[x] = lson[pre];
            x = rson[x], pre = rson[pre];
            l = mid + 1;
        }
        sum[x] = sum[pre] + 1;
    }
    return tmp;
}
int query(int l, int r, int k, int st, int en)
{
    while(l < r)
    {
        int mid = (l + r) >> 1;
        int tmp = sum[lson[en]] - sum[lson[st]];
        if(tmp >= k)
        {
            st = lson[st], en = lson[en];
            r = mid;
        }
        else
        {
            k -= tmp;
            st = rson[st], en = rson[en];
            l = mid + 1;
        }
    }
    return l;
}
int main()
{
    int n, m;
    while(~ scanf("%d%d", &n, &m))
    {
        for(int i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = a[i];
        sort(b + 1, b + 1 + n);
        int len = unique(b + 1, b + 1 + n) - b - 1;
        tot = 0;
        root[0] = build(1, len);
        for(int i = 1; i <= n; i++)
        {
            a[i] = lower_bound(b + 1, b + 1 + len, a[i]) - b;
            root[i] = update(1, len, a[i], root[i-1]);
        }
        int l, r, k;
        for(int i = 1; i <= m; i++)
        {
            scanf("%d%d%d", &l, &r, &k);
            int ans = b[query(1, len, k, root[l-1], root[r])];
            printf("%d\n", ans);
        }
    }
    return 0;
}

区间内不同元素的个数：

const int N = 30000 + 10, INF = 0x3f3f3f3f;

int lson[N*20], rson[N*20], sum[N*20];
int tot;
int root[N];
int a[N], b[N], vis[N];
void update(int l, int r, int val, int inc, int pre, int &x)
{
    x = ++tot;
    lson[x] = lson[pre], rson[x] = rson[pre], sum[x] = sum[pre] + inc;
    if(l == r) return;
    int mid = (l + r) >> 1;
    if(val <= mid) update(l, mid, val, inc, lson[pre], lson[x]);
    else update(mid + 1, r, val, inc, rson[pre], rson[x]);
}
int query(int l, int r, int val, int x)
{
    if(val == l) return sum[x];
    int mid = (l + r) >> 1;
    if(val <= mid) return sum[rson[x]] + query(l, mid, val, lson[x]);
    else return query(mid + 1, r, val, rson[x]);
}
int main()
{
    int n, m;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = a[i];
    sort(b + 1, b + 1 + n);
    int len = unique(b + 1, b + 1 + n) - b - 1;
    memset(vis, -1, sizeof vis);
    tot = 0;
    for(int i = 1; i <= n; i++)
    {//注意线段树的管辖区间是[1,n],这点不同于求第k小
        a[i] = lower_bound(b + 1, b + 1 + len, a[i]) - b;
        if(vis[a[i]] == -1) update(1, n, i, 1, root[i-1], root[i]);//直接插入树中
        else
        {//以新建节点的方式删除之前插入的当前元素，再插入
            int tmp;
            update(1, n, vis[a[i]], -1, root[i-1], tmp);
            update(1, n, i, 1, tmp, root[i]);
        }
        vis[a[i]] = i;
    }
    scanf("%d", &m);
    int l, r;
    for(int i = 1; i <= m; i++)
    {
        scanf("%d%d", &l, &r);
        int ans = query(1, n, l, root[r]);
        printf("%d\n", ans);
    }
    return 0;
}

树上区间第k小

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N = 100010;
struct edge
{
    int to, next;
}g[N*2];
int n, m, tot;
int cnt, head[N];
int len, root[N], lson[N*20], rson[N*20], val[N*20];
int num, dep[N*2], ver[N*2], fir[N], dp[20][N*2], fat[N];
bool vis[N];
int a[N], b[N];

void add_edge(int v, int u)
{
    g[cnt].to = u, g[cnt].next = head[v], head[v] = cnt++;
}
void build(int l, int r, int &rt)
{
    rt = ++tot;
    val[rt] = 0;
    if(l == r) return;
    int mid = (l + r) >> 1;
    build(l, mid, lson[rt]);
    build(mid + 1, r, rson[rt]);
}
void update(int pre, int &rt, int l, int r, int v)
{
    rt = ++tot;
    lson[rt] = lson[pre], rson[rt] = rson[pre], val[rt] = val[pre] + 1;
    if(l == r) return;
    int mid = (l + r) >> 1;
    if(v <= mid) update(lson[pre], lson[rt], l, mid, v);
    else update(rson[pre], rson[rt], mid + 1, r, v);
}
void dfs(int v, int fa, int d)
{
    vis[v] = true, ver[++num] = v, dep[num] = d, fir[v] = num, fat[v] = fa;
    update(root[fa], root[v], 1, len, a[v]);//在父节点的基础上新建一棵树
    for(int i = head[v]; i != -1; i = g[i].next)
    {
        int u = g[i].to;
        if(! vis[u])
        {
            dfs(u, v, d + 1);
            ver[++num] = v, dep[num] = d;
        }
    }
}
void ST(int n)
{
    for(int i = 1; i <= n; i++) dp[0][i] = i;
    for(int i = 1; (1<<i) <= n; i++)
        for(int j = 1; j <= n - (1<<i) + 1; j++)
            dp[i][j] = dep[dp[i-1][j]] < dep[dp[i-1][j+(1<<(i-1))]] ? dp[i-1][j] : dp[i-1][j+(1<<(i-1))];
}
int RMQ(int l, int r)
{
    int k = log(r - l + 1) / log(2);
    return dep[dp[k][l]] < dep[dp[k][r-(1<<k)+1]] ? dp[k][l] : dp[k][r-(1<<k)+1];
}
int LCA(int v, int u)
{
    v = fir[v], u = fir[u];
    if(v > u) swap(v, u);
    int res = RMQ(v, u);
    return ver[res];
}
int query(int ss, int tt, int lca, int lca_fa, int l, int r, int k)
{
    if(l == r) return l;
    int mid = (l + r) >> 1;
    int tmp = val[lson[ss]] + val[lson[tt]] - val[lson[lca]] - val[lson[lca_fa]];
    if(k <= tmp) return query(lson[ss], lson[tt], lson[lca], lson[lca_fa], l, mid, k);
    else return query(rson[ss], rson[tt], rson[lca], rson[lca_fa], mid + 1, r, k - tmp);
}
int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = a[i];
    sort(b+1, b+1+n);
    len = unique(b+1, b+1+n) - b - 1;
    for(int i = 1; i <= n; i++) a[i] = lower_bound(b+1, b+1+len, a[i]) - b;
    cnt = 0;
    memset(head, -1, sizeof head);
    for(int i = 1; i <= n - 1; i++)
    {
        int v, u;
        scanf("%d%d", &v, &u);
        add_edge(v, u), add_edge(u, v);
    }
    tot = 0;
    build(1, len, root[0]);
    num = 0;
    memset(vis, 0, sizeof vis);
    dfs(1, 0, 1);
    ST(2 * n - 1);
    for(int i = 1; i <= m; i++)
    {
        int v, u, k;
        scanf("%d%d%d", &v, &u, &k);
        int lca = LCA(v, u);
        printf("%d\n", b[query(root[v], root[u], root[lca], root[fat[lca]], 1, len , k)]);
    }
    return 0;
}