【模板】主席树的学习

Kth number

划分树虽然可以做，但是代码不好记。

看某人blog学习了主席树的简单操作。

引用某大牛的话来解释一下主席树：

所谓主席树呢，就是对原来的数列[1..n]的每一个前缀[1..i]（1≤i≤n）建立一棵线段树，线段树的每一个节点存某个前缀[1..i]中属于区间[L..R]的数一共有多少个（比如根节点是[1..n]，一共i个数，sum[root] = i；根节点的左儿子是[1..(L+R)/2]，若不大于(L+R)/2的数有x个，那么sum[root.left] = x）。若要查找[i..j]中第k大数时，设某结点x，那么x.sum[j] - x.sum[i - 1]就是[i..j]中在结点x内的数字总数。而对每一个前缀都建一棵树，会MLE，观察到每个[1..i]和[1..i-1]只有一条路是不一样的，那么其他的结点只要用回前一棵树的结点即可，时空复杂度为O(nlogn)。

——具体看代码（有详细注释）

#include <cstdio>
#include <algorithm>
#define lc son[now][0], l, mid
#define rc son[now][1], mid + 1, r

using namespace std;

const int N = 100000 + 5;

int T, n, q, tot;
int a[N], b[N], son[20 * N][2], sum[20 * N], rt[20 * N];
//主席树第 i 棵树存的是 a[0] - a[i] 的树（前缀和） 
//主席树一个节点 sum 存的是当前线段所包含的数的个数。。晕。 
//rt 是每一棵树的根节点编号
//a 保存原数组，b 保存排序后的数组 

//注意 & 的使用
inline void build(int &now, int l, int r)
{
    now = ++tot;
    sum[now] = 0;
    if(l == r) return;
    int mid = (l + r) >> 1;
    build(lc);
    build(rc);
}

inline void update(int &now, int l, int r, int last, int x)
{
    now = ++tot;
    //继承上个节点的孩子 
    son[now][0] = son[last][0];
    son[now][1] = son[last][1];
    //继承上一个节点的 sum 并加上当前所加入的数的个数（就是1） 
    sum[now] = sum[last] + 1; 
    if(l == r) return;
    int mid = (l + r) >> 1;
    if(x <= mid) update(lc, son[now][0], x);
    else update(rc, son[now][1], x);
}

//因为每个节点存的是有多少个数在当前区间
//求区间 [1,3] 即求 rt[3] - rt[0] 内的数
//可通过递归二分解决 
inline int query(int s, int t, int l, int r, int x)
{
    if(l == r) return l;
    int mid = (l + r) >> 1, cnt = sum[son[t][0]] - sum[son[s][0]];
    if(x <= cnt) return query(son[s][0], son[t][0], l, mid, x);
    else return query(son[s][1], son[t][1], mid + 1, r, x - cnt);
}

int main()
{
    int i, x, y, z, sz;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d %d", &n, &q);
        for(i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = a[i];
        sort(b + 1, b + n + 1);
        sz = unique(b + 1, b + n + 1) - (b + 1);//求不同的数一共有几个，即区间大小 
        tot = 0;
        build(rt[0], 1, sz);
        //用每个元素在 b 中的坐标重置 a 数组（离散化） 
        for(i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + sz + 1, a[i]) - b;
        for(i = 1; i <= n; i++) update(rt[i], 1, sz, rt[i - 1], a[i]);
        while(q--)
        {
            scanf("%d %d %d", &x, &y, &z);
            printf("%d
", b[query(rt[x - 1], rt[y], 1, sz, z)]);
        }
    }
    return 0;
}

 K-th Number

——代码

#include <cstdio>
#include <algorithm>
#define debug puts("***********");

const int MAXN = 100001;
int n, m, cnt;
int b[MAXN], root[MAXN];
struct node
{
    int a, rank;
}p[MAXN];
struct pst
{
    int sum, ls, rs;
}t[MAXN * 20];

inline bool cmp(node x, node y)
{
    return x.a < y.a;
}

inline void insert(int x, int &now, int l, int r)
{
    t[++cnt] = t[now];
    now = cnt;
    t[now].sum++;
    if(l == r) return;
    int mid = (l + r) >> 1;
    if(x <= mid) insert(x, t[now].ls, l, mid);
    else insert(x, t[now].rs, mid + 1, r);
}

inline int query(int x, int y, int k, int l, int r)
{
    if(l == r) return l;
    int ans = t[t[y].ls].sum - t[t[x].ls].sum, mid = (l + r) >> 1;;
    if(k <= ans) return query(t[x].ls, t[y].ls, k, l, mid);
    else return query(t[x].rs, t[y].rs, k - ans, mid + 1, r);
}

int main()
{
    int i, x, y, z;    
    scanf("%d %d", &n, &m);

    //没有重复元素的离散化 
    for(i = 1; i <= n; i++) scanf("%d", &p[i].a), p[i].rank = i;
    std::sort(p + 1, p + n + 1, cmp);
    for(i = 1; i <= n; i++) b[p[i].rank] = i;
    
    for(i = 1; i <= n; i++)
    {
        root[i] = root[i - 1];
        insert(b[i], root[i], 1, n);
    }
    for(i = 1; i <= m; i++)
    {
        scanf("%d %d %d", &x, &y, &z);
        printf("%d
", p[query(root[x - 1], root[y], z, 1, n)].a);
    }
    return 0;
}