模板

基数排序

const int N = 1e5 + 10;
int n, a[N];

void radix_sort(unsigned int *a, int l, int r)
{
    const unsigned int D = 1 << 16, k = D - 1;
    static unsigned int b[N]; static int cnt[D];
    unsigned int *x = a, *y = b;
    for (int i = 0; i < 32; i += 16)
    {
        for (int j = 0; j < D; ++j) cnt[j] = 0;
        for (int j = l; j < r; ++j) ++cnt[x[j] >> i & k];
        for (int tot = 0, j = 0; j < D; ++j) tot += cnt[j], cnt[j] = tot - cnt[j];
        for (int j = l; j < r; ++j) y[++cnt[x[j] >> i & k]] = x[j];
        swap(x, y);
    }
}

int main()
{
    read(n); for (int i = 1; i <= n; ++i) read(a[i]);
    radix_sort((unsigned int*)a, 1, n + 1); // 左闭右开 a[l,r)
    for (int i = 1; i <= n; ++i) print(a[i]), pc(' ');
    fwrite(pbuf, 1, pp - pbuf, stdout); return 0;
}

哈希表（拉链法）

注：答案不存在时返回 $-1$。

struct node
{
    int _x1, _y1, _x2, _y2;
    node() {}
    node(int a, int b, int c, int d) : _x1(a), _y1(b), _x2(c), _y2(d) {}
    inline bool operator == (const node &x) const
    {
        return _x1 == x._x1 && _y1 == x._y1 && _x2 == x._x2 && _y2 == x._y2;
    }
};

struct hash_table
{
    static const int P = 1e7 + 19;
    const ll b1 = 131, b2 = b1 * b1, b3 = b2 * b1;
    int tot, h[P];
    struct data
    {
        node x; ll val; int nxt;
        data() {}
        data(node _x, ll _val, int _nxt) : x(_x), val(_val), nxt(_nxt) {}
    } e[P << 1];
    
    inline void clear() { tot = 0, memset(h, 0, sizeof(h)); }
    inline int hash(node x) { return (x._x1 * b3 + x._y1 * b2 + x._x2 * b1 + x._y2) % P; }
    
    inline ll& operator [] (node x)
    {
        int pos = hash(x);
        for (int i = h[pos]; i; i = e[i].nxt)
            if (e[i].x == x) return e[i].val;
        e[++tot] = data(x, -1, h[pos]), h[pos] = tot;
        return e[tot].val;
    }
} Map;

树状数组上倍增 CF1354D Multiset

const int N = (1 << 20) + 20;
int n, q, t[N];

inline int lowbit(int x) { return x & -x; }
inline void add(int x, int v)
{
    for (; x < N; x += lowbit(x)) t[x] += v;
}
inline int kth(int k)
{
    int x = 0;
    for (int i = 19; i >= 0; --i)
        if (t[x + (1 << i)] < k) x += 1 << i, k -= t[x];
    return ++x;
}

int main()
{
    read(n, q); int x;
    for (int i = 1; i <= n; ++i) read(x), add(x, 1);
    while (q--) read(x), x > 0 ? add(x, 1) : add(kth(-x), -1);
    int ans = kth(1); print(ans > n ? 0 : ans);
    flush_pbuf(); return 0;
}

动态开点线段树 CF915E Physical Education Lessons

const int N = 3e5 + 10;
int n, q, cnt, rt;
struct node
{
    int ls, rs, sum, tag;
    node(int ls = 0, int rs = 0, int sum = 0, int tag = 0) :
        ls(ls), rs(rs), sum(sum), tag(tag) {}
} t[N * 50];

inline void pushup(int x) { t[x].sum = t[t[x].ls].sum + t[t[x].rs].sum; }

inline void pushdown(int x, int len)
{
    if (!t[x].tag) return;
    if (!t[x].ls) t[x].ls = ++cnt;
    if (!t[x].rs) t[x].rs = ++cnt;
    if (t[x].tag == 1)
    {
        t[t[x].ls].sum = 0, t[t[x].ls].tag = 1;
        t[t[x].rs].sum = 0, t[t[x].rs].tag = 1;
    }
    else
    {
        t[t[x].ls].sum = len - (len >> 1), t[t[x].ls].tag = 2;
        t[t[x].rs].sum = len >> 1, t[t[x].rs].tag = 2;
    }
    t[x].tag = 0;
}

void modify(int &x, int l, int r, int ml, int mr, int k)
{
    if (!x) x = ++cnt;
    if (ml <= l && r <= mr)
        return t[x].sum = k == 1 ? 0 : r - l + 1, t[x].tag = k, void();
    int mid = l + r >> 1;
    pushdown(x, r - l + 1);
    if (ml <= mid) modify(t[x].ls, l, mid, ml, mr, k);
    if (mid < mr) modify(t[x].rs, mid + 1, r, ml, mr, k);
    pushup(x);
}

int main()
{
    read(n, q), modify(rt, 1, n, 1, n, 2); int l, r, k;
    while (q--) read(l, r, k), modify(rt, 1, n, l, r, k), print(t[rt].sum, '\n');
    flush_pbuf(); return 0;
}

Splay 写法 1

这种写法是查询排名（该数不存在时）和前驱后继（该数不为根节点时）都必须先插入再计算后删除，好写但是常数巨大到爆炸。

struct Splay
{
    static const int N = 1.1e6 + 10;
    int rt, tot, fa[N], ch[N][2], sz[N], cnt[N], val[N];
    
    inline void clear(int x) { fa[x] = ch[x][0] = ch[x][1] = sz[x] = cnt[x] = val[x] = 0; }
    inline bool judge(int x) { return x == ch[fa[x]][1]; }
    inline void pushup(int x) { sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + cnt[x]; }
    inline void rotate(int x)
    {
        int y = fa[x], z = fa[y], w = judge(x);
        ch[y][w] = ch[x][!w]; if (ch[x][!w]) fa[ch[x][!w]] = y;
        if (z) ch[z][judge(y)] = x; ch[x][!w] = y, fa[y] = x, fa[x] = z; 
        pushup(y), pushup(x);
    }
    inline void splay(int x)
    {
        for (int f = fa[x]; f; rotate(x), f = fa[x])
            if (fa[f]) rotate(judge(f) == judge(x) ? f : x);
        rt = x;
    }
    
    inline int rk(int x)
    {
        for (int cur = rt, res = 0; ; )
            if (x < val[cur]) cur = ch[cur][0];
            else if (x == val[cur]) { res += sz[ch[cur][0]]; splay(cur); return res + 1; }
            else res += sz[ch[cur][0]] + cnt[cur], cur = ch[cur][1];
    }
    inline int xth(int x)
    {
        for (int cur = rt; ; )
        {
            if (x <= sz[ch[cur][0]]) cur = ch[cur][0];
            else if (x <= sz[ch[cur][0]] + cnt[cur]) { splay(cur); return cur; }
            else x -= sz[ch[cur][0]] + cnt[cur], cur = ch[cur][1];
        }
    }
    inline int pre()
    {
        int cur = ch[rt][0];
        if (!cur) return cur;
        while (ch[cur][1]) cur = ch[cur][1];
        splay(cur); return cur;
    }
    inline int nxt()
    {
        int cur = ch[rt][1];
        if (!cur) return cur;
        while (ch[cur][0]) cur = ch[cur][0];
        splay(cur); return cur;
    }
    inline void ins(int x)
    {
        if (!rt) val[++tot] = x, ++cnt[tot], rt = tot, pushup(rt);
        else for (int cur = rt, f = 0; ; f = cur, cur = ch[cur][val[cur] < x])
            if (val[cur] == x) { ++cnt[cur], pushup(cur), pushup(f), splay(cur); break; }
            else if (!cur)
            {
                val[++tot] = x, ++cnt[tot], fa[tot] = f, ch[f][val[f] < x] = tot;
                pushup(tot), pushup(f), splay(tot); break;
            }
    }
    inline void del(int x)
    {
        rk(x); int tmp = rt;
        if (cnt[rt] > 1) --cnt[rt], pushup(rt);
        else if (!ch[rt][0] && !ch[rt][1]) clear(rt), rt = 0;
        else if (!ch[rt][0]) rt = ch[rt][1], fa[rt] = 0, clear(tmp);
        else if (!ch[rt][1]) rt = ch[rt][0], fa[rt] = 0, clear(tmp);
        else rt = pre(), fa[ch[tmp][1]] = rt, ch[rt][1] = ch[tmp][1], pushup(rt), clear(tmp);
    }
} t;

Splay 写法 2

这种写法需要注意一开始要插入极大极小值。

struct Splay
{
    static const int N = 1.1e6 + 10;
    int rt, tot, fa[N], ch[N][2], sz[N], cnt[N], val[N];
    
    inline void clear(int x) { fa[x] = ch[x][0] = ch[x][1] = sz[x] = cnt[x] = val[x] = 0; }
    inline bool judge(int x) { return x == ch[fa[x]][1]; }
    inline void pushup(int x) { sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + cnt[x]; }
    inline void rotate(int x)
    {
        int y = fa[x], z = fa[y], w = judge(x);
        ch[y][w] = ch[x][!w]; if (ch[x][!w]) fa[ch[x][!w]] = y;
        if (z) ch[z][judge(y)] = x; ch[x][!w] = y, fa[y] = x, fa[x] = z; 
        pushup(y), pushup(x);
    }
    inline void splay(int x)
    {
        for (int f = fa[x]; f; rotate(x), f = fa[x])
            if (fa[f]) rotate(judge(f) == judge(x) ? f : x);
        rt = x;
    }
    
    inline int rk(int x)
    {
        int cur = rt, las = rt, res = 0;
        while (cur)
            if (x < val[cur]) las = cur, cur = ch[cur][0];
            else if (x == val[cur]) { res += sz[ch[cur][0]]; break; }
            else res += sz[ch[cur][0]] + cnt[cur], las = cur, cur = ch[cur][1];
        cur ? splay(cur) : splay(las); return res + 1;
    }
    inline int xth(int x)
    {
        int cur = rt, las = rt;
        while (true)
            if (x <= sz[ch[cur][0]]) las = cur, cur = ch[cur][0];
            else if (x <= sz[ch[cur][0]] + cnt[cur]) break;
            else x -= sz[ch[cur][0]] + cnt[cur], las = cur, cur = ch[cur][1];
        cur ? splay(cur) : splay(las); return cur;
    }
    inline int pre(int x)
    {
        int cur = rt, las = rt, res = 0;
        while (cur)
            if (x <= val[cur]) las = cur, cur = ch[cur][0];
            else res = las = cur, cur = ch[cur][1];
        splay(las); return res;
    }
    inline int nxt(int x)
    {
        int cur = rt, las = rt, res = 0;
        while (cur)
            if (x >= val[cur]) las = cur, cur = ch[cur][1];
            else res = las = cur, cur = ch[cur][0];
        splay(las); return res;
    }
    inline void ins(int x)
    {
        if (!rt) val[++tot] = x, ++cnt[tot], rt = tot, pushup(rt);
        else for (int cur = rt, f = 0; ; f = cur, cur = ch[cur][x > val[cur]])
            if (val[cur] == x) { ++cnt[cur], pushup(cur), pushup(f), splay(cur); break; }
            else if (!cur)
            {
                val[++tot] = x, ++cnt[tot], fa[tot] = f, ch[f][x > val[f]] = tot;
                pushup(tot), pushup(f), splay(tot); break;
            }
    }
    inline void del(int x)
    {
        rk(x); int tmp = rt;
        if (cnt[rt] > 1) --cnt[rt], pushup(rt);
        else if (!ch[rt][0] && !ch[rt][1]) clear(rt), rt = 0;
        else if (!ch[rt][0]) rt = ch[rt][1], fa[rt] = 0, clear(tmp);
        else if (!ch[rt][1]) rt = ch[rt][0], fa[rt] = 0, clear(tmp);
        else rt = pre(x), splay(rt), fa[ch[tmp][1]] = rt, ch[rt][1] = ch[tmp][1], pushup(rt), clear(tmp);
    }
} t;

树剖（重链剖分）

P3384 【模板】轻重链剖分/树链剖分

const int N = 1e5 + 10;
int n, m, rt, tim, a[N];
int sz[N], dep[N], fa[N], son[N], top[N], dfn[N], id[N];
ll P, s[N << 2], tag[N << 2];
vector<int> to[N];

void dfs1(int u)
{
    sz[u] = 1, dep[u] = dep[fa[u]] + 1;
    for (int v : to[u]) if (v != fa[u])
    {
        fa[v] = u, dfs1(v), sz[u] += sz[v];
        if (sz[v] > sz[son[u]]) son[u] = v;
    }
}

void dfs2(int u, int x)
{
    top[u] = x, dfn[u] = ++tim, id[tim] = u;
    if (son[u]) dfs2(son[u], x);
    for (int v : to[u])
        if (v != fa[u] && v != son[u]) dfs2(v, v);
}

inline void addmod(ll &x) { if (x >= P) x -= P; }
inline int ls(int x) { return x << 1; }
inline int rs(int x) { return x << 1 | 1; }
inline void pushup(int x) { s[x] = s[ls(x)] + s[rs(x)], addmod(s[x]); }

inline void pushdown(int x, int len)
{
    s[ls(x)] += tag[x] * (len - (len >> 1)) % P, addmod(s[ls(x)]);
    s[rs(x)] += tag[x] * (len >> 1) % P, addmod(s[rs(x)]);
    tag[ls(x)] += tag[x], addmod(tag[ls(x)]);
    tag[rs(x)] += tag[x], addmod(tag[rs(x)]);
    tag[x] = 0;
}

void build(int x, int l, int r)
{
    if (l == r) { s[x] = a[id[l]]; return; }
    int mid = l + r >> 1;
    if (l <= mid) build(ls(x), l, mid);
    if (mid < r) build(rs(x), mid + 1, r);
    pushup(x);
}

void modify(int x, int l, int r, int ml, int mr, ll v)
{
    if (ml <= l && r <= mr)
    {
        s[x] += v * (r - l + 1) % P, addmod(s[x]);
        tag[x] += v, addmod(tag[x]);
        return;
    }
    pushdown(x, r - l + 1);
    int mid = l + r >> 1;
    if (ml <= mid) modify(ls(x), l, mid, ml, mr, v);
    if (mid < mr) modify(rs(x), mid + 1, r, ml, mr, v);
    pushup(x);
}

ll query(int x, int l, int r, int ql, int qr)
{
    if (ql <= l && r <= qr) return s[x];
    pushdown(x, r - l + 1);
    int mid = l + r >> 1; ll ans = 0;
    if (ql <= mid) ans += query(ls(x), l, mid, ql, qr), addmod(ans);
    if (mid < qr) ans += query(rs(x), mid + 1, r, ql, qr), addmod(ans);
    return ans;
}

inline void modifytree(int x, ll v) { modify(1, 1, n, dfn[x], dfn[x] + sz[x] - 1, v); }
inline ll querytree(int x) { return query(1, 1, n, dfn[x], dfn[x] + sz[x] - 1); }

inline void modifypath(int u, int v, ll w)
{
    while (top[u] != top[v])
    {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        modify(1, 1, n, dfn[top[u]], dfn[u], w);
        u = fa[top[u]];
    }
    if (dep[u] > dep[v]) swap(u, v);
    modify(1, 1, n, dfn[u], dfn[v], w);
}

inline ll querypath(int u, int v)
{
    ll ans = 0;
    while (top[u] != top[v])
    {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        ans += query(1, 1, n, dfn[top[u]], dfn[u]), addmod(ans);
        u = fa[top[u]];
    }
    if (dep[u] > dep[v]) swap(u, v);
    ans += query(1, 1, n, dfn[u], dfn[v]), addmod(ans);
    return ans;
}

int main()
{
    read(n, m, rt, P);
    for (int i = 1; i <= n; ++i) read(a[i]);
    for (int u, v, i = 1; i < n; ++i)
        read(u, v), to[u].emplace_back(v), to[v].emplace_back(u);
    dfs1(rt), dfs2(rt, rt), build(1, 1, n);
    while (m--)
    {
        int op, x, y, z; read(op);
        switch (op)
        {
            case 1:
                read(x, y, z), modifypath(x, y, z); break;
            case 2:
                read(x, y), print(querypath(x, y), '\n'); break;
            case 3:
                read(x, z), modifytree(x, z); break;
            case 4:
                read(x), print(querytree(x), '\n'); break;
        }
    }
    flush_pbuf(); return 0;
}

fhq-treap

P6136 【模板】普通平衡树（数据加强版）

const int N = 1.1e6 + 10;
int n, m, rt, cnt;
struct node
{
    int sz, ls, rs, val, rnd;
    node() {}
    node(int _sz, int _ls, int _rs, int _val, int _rnd) :
        sz(_sz), ls(_ls), rs(_rs), val(_val), rnd(_rnd) {}
} t[N];
mt19937 Rand(time(0));

inline int newnode(int v) { t[++cnt] = node(1, 0, 0, v, Rand()); return cnt; }
inline void pushup(int x) { t[x].sz = t[t[x].ls].sz + t[t[x].rs].sz + 1; }

void split(int x, int k, int &l, int &r)
{
    if (!x) { l = r = 0; return; }
    if (t[x].val <= k) l = x, split(t[x].rs, k, t[x].rs, r);
    else r = x, split(t[x].ls, k, l, t[x].ls);
    pushup(x);
}
int merge(int x, int y)
{
    if (!x || !y) return x | y;
    if (t[x].rnd < t[y].rnd) { t[x].rs = merge(t[x].rs, y), pushup(x); return x; }
    else { t[y].ls = merge(x, t[y].ls), pushup(y); return y; }
}
inline int kth(int x, int k)
{
    while (true)
        if (k <= t[t[x].ls].sz) x = t[x].ls;
        else if (k == t[t[x].ls].sz + 1) return x;
        else k -= t[t[x].ls].sz + 1, x = t[x].rs;
}

inline void ins(int v)
{
    int x, y; split(rt, v, x, y);
    rt = merge(merge(x, newnode(v)), y);
}
inline void del(int v)
{
    int x, y, z; split(rt, v, x, z), split(x, v - 1, x, y);
    y = merge(t[y].ls, t[y].rs), rt = merge(merge(x, y), z);
}
inline int rk(int v)
{
    int x, y, k; split(rt, v - 1, x, y);
    k = t[x].sz + 1, rt = merge(x, y);
    return k;
}
inline int pre(int v)
{
    int x, y, w; split(rt, v - 1, x, y);
    w = t[kth(x, t[x].sz)].val, rt = merge(x, y);
    return w;
}
inline int nxt(int v)
{
    int x, y, w; split(rt, v, x, y);
    w = t[kth(y, 1)].val, rt = merge(x, y);
    return w;
}

int main()
{
    read(n, m); int lastans = 0, ans = 0;
    for (int x, i = 1; i <= n; ++i) read(x), ins(x);
    while (m--)
    {
        int op, x; read(op, x), x ^= lastans;
        switch (op)
        {
            case 1: ins(x); break;
            case 2: del(x); break;
            case 3: lastans = rk(x); break;
            case 4: lastans = t[kth(rt, x)].val; break;
            case 5: lastans = pre(x); break;
            case 6: lastans = nxt(x); break;
        }
        if (op >= 3) ans ^= lastans;
    }
    print(ans);
    flush_pbuf(); return 0;
}

P3391 【模板】文艺平衡树

const int N = 1e5 + 10;
int n, m, rt, cnt;
struct node
{
    int sz, ls, rs, val, rnd, tag;
    node() {}
    node(int _sz, int _ls, int _rs, int _val, int _rnd, int _tag) :
        sz(_sz), ls(_ls), rs(_rs), val(_val), rnd(_rnd), tag(_tag) {}
} t[N];
mt19937 Rand(time(0));

inline int newnode(int v) { t[++cnt] = node(1, 0, 0, v, Rand(), 0); return cnt; }
inline void pushup(int x) { t[x].sz = t[t[x].ls].sz + t[t[x].rs].sz + 1; }
inline void pushdown(int x)
{
    if (!t[x].tag) return;
    if (t[x].ls) t[t[x].ls].tag ^= 1;
    if (t[x].rs) t[t[x].rs].tag ^= 1;
    swap(t[x].ls, t[x].rs), t[x].tag = 0;
}

void split(int x, int k, int &l, int &r)
{
    if (!x) { l = r = 0; return; }
    pushdown(x);
    if (t[t[x].ls].sz < k) l = x, split(t[x].rs, k - t[t[x].ls].sz - 1, t[x].rs, r);
    else r = x, split(t[x].ls, k, l, t[x].ls);
    pushup(x);
}
int merge(int x, int y)
{
    if (!x || !y) return x | y;
    pushdown(x), pushdown(y);
    if (t[x].rnd < t[y].rnd) { t[x].rs = merge(t[x].rs, y), pushup(x); return x; }
    else { t[y].ls = merge(x, t[y].ls), pushup(y); return y; }
}

inline void ins(int v, int k)
{
    int x, y; split(rt, k - 1, x, y);
    rt = merge(merge(x, newnode(v)), y);
}
inline void rev(int l, int r)
{
    int x, y, z; split(rt, l - 1, x, y), split(y, r - l + 1, y, z);
    t[y].tag ^= 1, rt = merge(merge(x, y), z);
}

int main()
{
    read(n, m); int l, r, x, y;
    for (int i = 1; i <= n; ++i) ins(i, i);
    while (m--) read(l, r), rev(l, r); x = rt;
    for (int i = 1; i <= n; ++i)
        split(x, 1, x, y), print(t[x].val, ' '), swap(x, y);
    flush_pbuf(); return 0;
}

P2042 [NOI2005] 维护数列

const int N = 5e5 + 10, inf = 1e9;
int n, m, rt, cnt, top, a[N], b[N];
mt19937 Rand((unsigned)time(0));

struct Res
{
    int sum, lmax, rmax, ans;
    Res(int sum = 0, int lmax = -inf, int rmax = -inf, int ans = -inf) :
        sum(sum), lmax(lmax), rmax(rmax), ans(ans) {}
};
inline Res operator + (const Res &x, const Res &y)
{
    Res z; z.sum = x.sum + y.sum;
    z.lmax = Max(x.lmax, x.sum + y.lmax, -inf);
    z.rmax = Max(y.rmax, y.sum + x.rmax, -inf);
    z.ans = Max(x.ans, y.ans, x.rmax + y.lmax, -inf);
    return z;
}

struct node
{
    int sz, ls, rs, val, rnd, tag, rev; Res res;
    node(int sz = 0, int ls = 0, int rs = 0, int val = 0,
        int rnd = 0, int tag = inf, int rev = 0, Res res = Res(0, -inf, -inf, -inf)) :
        sz(sz), ls(ls), rs(rs), val(val), rnd(rnd), tag(tag), rev(rev), res(res) {}
} t[N];

inline int newnode(int v)
{
    int x = top ? b[top--] : ++cnt;
    t[x] = node(1, 0, 0, v, Rand(), inf, 0, Res(v, v, v, v));
    return x;
}
inline void pushup(int x)
{
    t[x].sz = t[t[x].ls].sz + t[t[x].rs].sz + 1;
    t[x].res = t[t[x].ls].res + Res(t[x].val, t[x].val, t[x].val, t[x].val) + t[t[x].rs].res;
}
inline void Cover(int x, int v)
{
    t[x].tag = t[x].val = v, t[x].rev = 0, t[x].res.sum = t[x].sz * v;
    if (v > 0) t[x].res.lmax = t[x].res.rmax = t[x].res.ans = t[x].res.sum;
    else t[x].res.lmax = t[x].res.rmax = t[x].res.ans = v;
}
inline void Reverse(int x)
{
    t[x].rev ^= 1, swap(t[x].res.lmax, t[x].res.rmax), swap(t[x].ls, t[x].rs);
}
inline void pushdown(int x)
{
    if (t[x].tag != inf)
    {
        if (t[x].ls) Cover(t[x].ls, t[x].tag);
        if (t[x].rs) Cover(t[x].rs, t[x].tag);
        t[x].tag = inf;
    }
    if (t[x].rev)
    {
        if (t[x].ls) Reverse(t[x].ls);
        if (t[x].rs) Reverse(t[x].rs);
        t[x].rev = 0;
    }
}

void split(int x, int k, int &l, int &r)
{
    if (!x) { l = r = 0; return; }
    pushdown(x);
    if (t[t[x].ls].sz < k) l = x, split(t[x].rs, k - t[t[x].ls].sz - 1, t[x].rs, r);
    else r = x, split(t[x].ls, k, l, t[x].ls);
    pushup(x);
}
int merge(int x, int y)
{
    if (!x || !y) return x | y;
    if (t[x].rnd < t[y].rnd) { pushdown(x), t[x].rs = merge(t[x].rs, y), pushup(x); return x; }
    else { pushdown(y), t[y].ls = merge(x, t[y].ls), pushup(y); return y; }
}

void midorder(int x)
{
    if (t[x].ls) midorder(t[x].ls);
    cerr << t[x].val << ' ';
    if (t[x].rs) midorder(t[x].rs);
}
int build(int l, int r)
{
    if (l > r) return 0;
    int mid = l + r >> 1, x = newnode(a[mid]);
    if (l == r) return x;
    t[x].ls = build(l, mid - 1);
    t[x].rs = build(mid + 1, r);
    pushup(x); return x;
}
void recycle(int x)
{
    b[++top] = x;
    if (t[x].ls) recycle(t[x].ls);
    if (t[x].rs) recycle(t[x].rs);
}

inline void ins(int k, int x)
{
    int y, z; split(rt, k, y, z);
    rt = merge(merge(y, x), z);
}
inline void del(int k, int tot)
{
    int x, y, z; split(rt, k - 1, x, y), split(y, tot, y, z);
    rt = merge(x, z), recycle(y);
}
inline void same(int k, int tot, int v)
{
    int x, y, z; split(rt, k - 1, x, y), split(y, tot, y, z);
    Cover(y, v), rt = merge(merge(x, y), z);
}
inline void rev(int k, int tot)
{
    int x, y, z; split(rt, k - 1, x, y), split(y, tot, y, z);
    Reverse(y), rt = merge(merge(x, y), z);
}
inline int getsum(int k, int tot)
{
    int x, y, z, tmp; split(rt, k - 1, x, y), split(y, tot, y, z);
    tmp = t[y].res.sum, rt = merge(merge(x, y), z); return tmp;
}
inline int maxsum() { return t[rt].res.ans; }

int main()
{
    read(n, m);
    for (int i = 1; i <= n; ++i) read(a[i]);
    rt = build(1, n);
    while (m--)
    {
        
        char s[10]; read(s); int x, y, z;
        switch (s[0])
        {
            case 'I':
                read(x, y);
                for (int i = 1; i <= y; ++i) read(a[i]);
                ins(x, build(1, y)); break;
            case 'D':
                read(x, y), del(x, y); break;
            case 'M':
                if (s[2] == 'K') read(x, y, z), same(x, y, z);
                else print(maxsum(), '\n'); break;
            case 'R':
                read(x, y), rev(x, y); break;
            case 'G':
                read(x, y), print(getsum(x, y), '\n'); break;
        }        
//        midorder(rt), cerr << '\n';
    }
    flush_pbuf(); return 0;
}

可持久化数据结构

可持久化下标线段树：P3919 【模板】可持久化线段树 1（可持久化数组）

const int N = 1e6 + 10;
int n, m, top, a[N], rt[N];
struct node
{
    int ls, rs, v;
    node(int ls = 0, int rs = 0, int v = 0) :
        ls(ls), rs(rs), v(v) {}
} t[N * 24];

void build(int &x, int l, int r)
{
    x = ++top;
    if (l == r) { t[x].v = a[l]; return; }
    int mid = l + r >> 1;
    build(t[x].ls, l, mid);
    build(t[x].rs, mid + 1, r);
}

void modify(int &x, int pre, int l, int r, int p, int v)
{
    x = ++top, t[x] = t[pre];
    if (l == r) { t[x].v = v; return; }
    int mid = l + r >> 1;
    if (p <= mid) modify(t[x].ls, t[pre].ls, l, mid, p, v);
    if (mid < p) modify(t[x].rs, t[pre].rs, mid + 1, r, p, v);
}

int query(int &x, int l, int r, int p)
{
    if (l == r) return t[x].v;
    int mid = l + r >> 1;
    if (p <= mid) return query(t[x].ls, l, mid, p);
    else return query(t[x].rs, mid + 1, r, p);
}

int main()
{
    read(n, m);
    for (int i = 1; i <= n; ++i) read(a[i]);
    build(rt[0], 1, n);
    for (int k, op, p, v, i = 1; i <= m; ++i)
    {
        read(k, op, p);
        if (op == 1) read(v), modify(rt[i], rt[k], 1, n, p, v);
        else print(query(rt[i] = rt[k], 1, n, p), '\n');
    }
    flush_pbuf(); return 0;
}

可持久化值域线段树：P3834 【模板】可持久化线段树 2

const int N = 2e5 + 10;
int n, m, top, rt[N];
struct node
{
    int ls, rs, sz;
    inline node(int ls = 0, int rs = 0, int sz = 0) :
        ls(ls), rs(rs), sz(sz) {}
} t[N * 90];

inline void pushup(int x) { t[x].sz = t[t[x].ls].sz + t[t[x].rs].sz; }

void insert(int &x, int pre, int l, int r, int v)
{
    x = ++top, t[x] = t[pre];
    if (l == r) { ++t[x].sz; return; }
    int mid = l + r >> 1;
    if (v <= mid) insert(t[x].ls, t[pre].ls, l, mid, v);
    if (mid < v) insert(t[x].rs, t[pre].rs, mid + 1, r, v);
    pushup(x);
}

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

int main()
{
    read(n, m);
    for (int x, i = 1; i <= n; ++i)
        read(x), insert(rt[i], rt[i - 1], -1e9, 1e9, x);
    while (m--)
    {
        int l, r, k; read(l, r, k);
        print(query(rt[l - 1], rt[r], -1e9, 1e9, k), '\n');
    }
    flush_pbuf(); return 0;
}

可持久化 01 Trie：P4735 最大异或和

const int N = 6e5 + 10, LIM = 23;
int n, m, cnt, sum, rt[N];
struct node
{
    int ch[2], sz;
    inline node(int ls = 0, int rs = 0, int sz = 0) :
        ch{ls, rs}, sz(sz) {}
} t[N * 50];

inline void pushup(int x) { t[x].sz = t[t[x].ch[0]].sz + t[t[x].ch[1]].sz; }

void insert(int &x, int pre, int dep, int v)
{
    x = ++cnt, t[x] = t[pre];
    if (dep < 0) { ++t[x].sz; return; }
    int c = v >> dep & 1;
    insert(t[x].ch[c], t[pre].ch[c], dep - 1, v);
    pushup(x);
}

int query(int x, int y, int dep, int v)
{
    if (dep < 0) return 0;
    int c = v >> dep & 1;
    if (t[t[y].ch[!c]].sz - t[t[x].ch[!c]].sz > 0)
        return (1 << dep) + query(t[x].ch[!c], t[y].ch[!c], dep - 1, v);
    else return query(t[x].ch[c], t[y].ch[c], dep - 1, v);
}

int main()
{
    read(n, m), insert(rt[0], rt[0], LIM, sum);
    for (int x, i = 1; i <= n; ++i)
        read(x), insert(rt[i], rt[i - 1], LIM, sum ^= x);
    while (m--)
    {
        char op[10]; int l, r, x, res; read(op);
        if (op[0] == 'A') read(x), ++n, insert(rt[n], rt[n - 1], LIM, sum ^= x);
        else
        {
            read(l, r, x);
            if (l == 1) print(query(0, rt[r - 1], LIM, sum ^ x), '\n');
            else print(query(rt[l - 2], rt[r - 1], LIM, sum ^ x), '\n');
        }
    }
    flush_pbuf(); return 0;
}

To be continued...