【主席树】学习笔记

以处理求区间第 k 小为例.

先把节点离散化. 用法类似权值线段树.

普通线段树每次插入一个元素 x 时, 途径的 $deep[x]$ 个节点都会加 1, 要查询区间第 k 小时, 就要用树的 $Versio{n}_R$ 减去 $Versio{n}_{L-1}$, 得到的就是 l 到 r 区间所有元素的组成的权值线段树, 然后操作就和权值线段树找第 k 小一样了. 可持续化线段树的就用来保存树的不同版本 Version. 本质就是前缀和操作, 每个 pre[i]都是一棵树. 其实如果时间空间允许, 完全可以每插入一个点, 就把原树复制一份, 执行前缀和的pre[i]=pre[i-1]+a[i].

0. 空树(相当于pre[0])
   

1. Version-1(插入数 1 )
   

2. Version-2(插入数 5 )
   

3. Version-3( 插入数 2 )
   

接下来做树的持续化:

注意到每次插入一个节点只有对应路径上的 $deep[x]$ 个元素被改变, 而且根是一定会改变的, 我们就可以对每次更改, 执行如上图的更改, 新建 $deep[x]$ 个节点, 并连上未被更改的节点, 且保存这个新根, 注意到, 访问不同的根就相当于访问了不同版本的树.

这样更改就不能用 rot<<1,rot<<1|1访问左右儿子了, 要动态开点.

//AC https://www.luogu.com.cn/problem/SP3946
const int Maxn = 100010, LOG = 20;
//一般我们用20倍空间来保存（防止溢出）
int tot = 0; // tot就是时间戳（每个节点的编号）
int ver[Maxn]; // 保存每个版本的根节点编号
struct node {
    int val, lson, rson;
} tr[Maxn * LOG];

//建空树
int build(int l, int r) {
    int rt = ++ tot;
    int mid = l + r >> 1;
    if (l < r) {
        tr[rt].lson = build(l, mid);
        tr[rt].rson = build(mid + 1, r);
    }
    return rt;
}

//更新
int update(int pre/*前一个版本节点*/, int l, int r, int id) {
    int rt = ++ tot;
    tr[rt].val = tr[pre].val + 1; // 新开的链, 链上每个val都加一
    if (l < r) {
        int mid = l + r >> 1;
        if (id <= mid) {
            tr[rt].lson = update(tr[pre].lson, l, mid, id);
            tr[rt].rson = tr[pre].rson;
        }
        else {
            tr[rt].rson = update(tr[pre].rson, mid + 1, r, id);
            tr[rt].lson = tr[pre].lson;
        }
        //左右儿子断开其中一个形成新的链
    }
    return rt;
}

// 查询操作
int query(int u, int v, int l, int r, int k) {
    if (l == r) return l;
    int LsonVal = tr[tr[v].lson].val - tr[tr[u].lson].val;
    //两个历史版本的树相减, LsonVal就是左子树的大小
    int mid = l + r >> 1;
    if (LsonVal >= k) return query(tr[u].lson, tr[v].lson, l, mid, k);
    else return query(tr[u].rson, tr[v].rson, mid + 1, r, k - LsonVal);
}

signed main() {
    tot = 0;
    //多组输入初始化
    // memset(ver, 0, sizeof ver);
    // memset(sum, 0, sizeof sum);
    // memset(L, 0, sizeof L);
    // memset(R, 0, sizeof R);
    int n, q;
    cin >> n >> q;
    vector<int>a(n), b(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        b[i] = a[i];
    }

    // 离散化 a[i]
    sort(b.begin(), b.end());
    int MaxR = unique(b.begin(), b.end()) - b.begin();
    for (int i = 0; i < n; ++i) {
        a[i] = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
    }


    ver[0] = build(0, MaxR); // 初始的空树, 相当于 pre[0], 不能缺
    for (int i = 0; i < n; i++) {
        ver[i + 1] = update(ver[i], 0, MaxR, a[i]);
        //ver[i] 不同历史版本
    }
    while (q --) {
        int l, r, x;
        cin >> l >> r >> x;
        int id = query(ver[l - 1], ver[r], 0, MaxR, x);
        cout << b[id] << endl;
    }
}

eg: 图片来自链接和 oi wiki