第45届ICPC沈阳站J：Descent of Dragons——可持久化线段树

传送门

本文CSDN

本文juejin

作者：hans774882968以及hans774882968

题意

一个长n <= 5e5数组，初值为全0，有q <= 5e5个操作：

1. 输入l,r,x (x <= 5e5)，区间[l,r]等于x的数加1。
2. 输入[l,r]，求区间[l,r]最大值。

思路

网上缺乏一篇通俗易懂的题解，所以我尽力去贡献一篇！

设数组a[i] = (a[i] >= x)表示输入参数x，数组元素大于等于x的为1，小于的为0，由它建立一棵权值线段树，于是可以快速查询一个区间大于等于x的数的个数。设rt[x]表示参数x对应的上述权值线段树，则需要管理q个权值线段树。

一个区间涉及的线段树节点log个，采用可持久化线段树即可。属性l,r是指向左右孩子的指针。tsz加1表示创建新节点。

int tsz, rt[N];
struct Node {
    int s, l, r;
} nd[N * 40];

void create_nd()
inline void pushup()
void build()
void copy_tree()
int qry()

建树

用create_nd函数创建新节点，依赖build函数确定rt[0]和节点左右孩子。

void create_nd (int &y) {
    nd[++tsz].s = nd[y].s;
    nd[tsz].l = nd[y].l;
    nd[tsz].r = nd[y].r;
    y = tsz;
}

inline void pushup (int x) {
    nd[x].s = nd[nd[x].l].s + nd[nd[x].r].s;
}

void build (int &x, int l, int r) {
    create_nd (x);
    if (l == r) {
        nd[x].s = 1;
        return;
    }
    int mid = (l + r) >> 1;
    build (nd[x].l, l, mid);
    build (nd[x].r, mid + 1, r);
    pushup (x);
}

修改

• rt[x+1]一定会变化，依赖copy_tree函数确定，因此copy_tree用参数y表示待修改的节点指针。
• rt[x+1]初次建立。创建[l,r]所涉及的线段树新节点（此时create_nd是纯粹的开辟新节点），通过copy_tree递归调用确定左右孩子。nd[t]的某个孩子不是[l,r]相关节点，即没有该孩子，用nd[t].l = 0或nd[t].r = 0表示。用pushup重新确定区间和。
• 已有rt[x+1]。创建[l,r]所涉及的线段树新节点（可能产生一定的浪费，不用管），通过copy_tree递归调用确定要变化的孩子指针的新指向，不变化的孩子指针沿用原有rt[x+1]线段树节点的指针（通过create_nd实现）。用pushup重新确定区间和。
• 叶节点：直接沿用rt[x]的相关节点，因此赋值y = x。

void copy_tree (int x, int &y, int ql, int qr, int l = 1, int r = n) {
    if (!x) return;
    if (ql <= l && r <= qr) {
        y = x;
        return;
    }
    create_nd (y);
    int mid = (l + r) >> 1;
    if (ql <= mid) copy_tree (nd[x].l, nd[y].l, ql, qr, l, mid);
    if (qr > mid) copy_tree (nd[x].r, nd[y].r, ql, qr, mid + 1, r);
    pushup (y);
}

查询

和普通线段树的查询操作区别不大。找到最大的v，rt[v]线段树的区间和大于0，则v为区间max。有单调性，所以二分答案。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

const int N = 5e5 + 5;

int n, q, tsz, rt[N];

void dbg() {
    puts ("");
}
template<typename T, typename... R>void dbg (const T &f, const R &... r) {
    cout << f << " ";
    dbg (r...);
}
template<typename Type>inline void read (Type &xx) {
    Type f = 1;
    char ch;
    xx = 0;
    for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar() ) if (ch == '-') f = -1;
    for (; ch >= '0' && ch <= '9'; ch = getchar() ) xx = xx * 10 + ch - '0';
    xx *= f;
}
void read() {}
template<typename T, typename ...R>void read (T &x, R &...r) {
    read (x);
    read (r...);
}

struct Node {
    int s, l, r;
} nd[N * 40];

void create_nd (int &y) {
    nd[++tsz].s = nd[y].s;
    nd[tsz].l = nd[y].l;
    nd[tsz].r = nd[y].r;
    y = tsz;
}

inline void pushup (int x) {
    nd[x].s = nd[nd[x].l].s + nd[nd[x].r].s;
}

void build (int &x, int l, int r) {
    create_nd (x);
    if (l == r) {
        nd[x].s = 1;
        return;
    }
    int mid = (l + r) >> 1;
    build (nd[x].l, l, mid);
    build (nd[x].r, mid + 1, r);
    pushup (x);
}

void copy_tree (int x, int &y, int ql, int qr, int l = 1, int r = n) {
    if (!x) return;
    if (ql <= l && r <= qr) {
        y = x;
        return;
    }
    create_nd (y);
    int mid = (l + r) >> 1;
    if (ql <= mid) copy_tree (nd[x].l, nd[y].l, ql, qr, l, mid);
    if (qr > mid) copy_tree (nd[x].r, nd[y].r, ql, qr, mid + 1, r);
    pushup (y);
}

int qry (int x, int ql, int qr, int l = 1, int r = n) {
    if (!x) return 0;
    if (ql <= l && r <= qr) return nd[x].s;
    int mid = (l + r) >> 1, ans = 0;
    if (ql <= mid) ans += qry (nd[x].l, ql, qr, l, mid);
    if (qr > mid) ans += qry (nd[x].r, ql, qr, mid + 1, r);
    return ans;
}

void show_tree (int x, int l = 1, int r = n) {
    dbg (x, nd[x].s, nd[x].l, nd[x].r);
    if (l == r) return;
    int mid = (l + r) >> 1;
    show_tree (nd[x].l, l, mid);
    show_tree (nd[x].r, mid + 1, r);
}

int main() {
    read (n, q);
    tsz = 0;
    build (rt[0], 1, n);
    rep (i, 1, q) {
        int op, L, R, v;
        read (op);
        if (op == 1) {
            read (L, R, v);
            copy_tree (rt[v], rt[v + 1], L, R);
        } else {
            read (L, R);
            int l = 0, r = i;
            while (l < r) {
                int mid = (l + r + 1) >> 1;
                if (qry (rt[mid], L, R) ) l = mid;
                else r = mid - 1;
            }
            printf ("%d\n", l);
        }
    }
    // rep (i, 0, 3) show_tree (rt[i]);
    return 0;
}