主席树(可持久化线段树)学习笔记

因为是可持久化线段树,要能够保存历史版本,所以要借助线段树历史版本之间

各个节点的关系来优化内存.如果线段树每次只修改某一个叶子节点,那么整个

线段树改变的节点也就是这个叶子节点到根节点的路径上的点.所以当需要保存

版本i的线段树的时候可,如果某一个孩子没有改变,就可以让这个孩子指向前一个

版本的线段树的这个位置.

静态区间第k小:

HDU  2665:点击打开链接

用到了权值线段树,也就是叶子节点i保存的是i数字出现的次数.要知道区间[l,r]中

的第k小只需要知道[l,n]中除去[r+1,n]中元素的第k小.所以搞两个指针,沿着这

两个版本的线段树往下走.

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
#define maxn 111111

struct node {
    int l, r;
    int num;
}tree[maxn<<6];
int T[maxn];
int cnt;//总结点数
int n, q, a[maxn];
vector <int> num;
int p[maxn];
map <int , int> gg;

void init () {
    sort (num.begin (), num.end ());
    int cnt = 0;
    for (int i = 0; i < num.size (); i++) {
        if (!i || num[i] != num[i-1]) {
            gg[num[i]] = ++cnt;
            p[cnt] = num[i];
        }
    }
}

int build_tree (int l, int r) {
    int root = cnt++;
    tree[root].num = 0;
    if (l == r)
        return root;
    int mid = (l+r)>>1;
    tree[root].l = build_tree (l, mid);
    tree[root].r = build_tree (mid+1, r);
    return root;
}

int update (int root, int pos, int val) {
    int new_root = cnt++;
    int tmp = new_root;
    tree[new_root].num = tree[root].num+val;
    int l = 1, r = n;
    while (l < r) {
        int mid = (l+r)>>1;
        if (pos <= mid) {
            tree[new_root].l = cnt++;
            tree[new_root].r = tree[root].r;
            new_root = tree[new_root].l;
            root = tree[root].l;
            r = mid;
        }
        else {
            tree[new_root].l = tree[root].l;
            tree[new_root].r = cnt++;
            new_root = tree[new_root].r;
            root = tree[root].r;
            l = mid+1;
        }
        tree[new_root].num = tree[root].num + val;
    }
    return tmp;
}

int query (int l_root, int r_root, int k) {
    int l = 1, r = n;
    while (l < r) {
        int mid = (l+r)>>1;
        if (tree[tree[l_root].l].num - tree[tree[r_root].l].num >= k) {
            r = mid;
            l_root = tree[l_root].l;
            r_root = tree[r_root].l;
        }
        else {
            l = mid+1;
            k -= (tree[tree[l_root].l].num - tree[tree[r_root].l].num);
            l_root = tree[l_root].r;
            r_root = tree[r_root].r;
        }
    }
    return l;
}

int main () {
    //freopen ("in.txt", "r", stdin);
    int t;
    scanf ("%d", &t);
    while (t--) {
            scanf ("%d%d", &n, &q);
        num.clear ();
        gg.clear ();
        for (int i = 1; i <= n; i++) {
            scanf ("%d", &a[i]);
            num.push_back (a[i]);
        }
        init ();
        cnt = 0;
        T[n+1] = build_tree (1, n);
        for (int i = n; i >= 1; i--) {
            int pos = gg[a[i]];
            T[i] = update (T[i+1], pos, 1);
        }
        while (q--) {
            int l, r, k;
            scanf ("%d%d%d", &l, &r, &k); 
            printf ("%d\n", p[query (T[l], T[r+1], k)]);
        }
    }
    return 0;
}