平衡树学习总结、LCT练习题

Splay：

　　像BST（二叉搜索树）一样插入查询，可以改变树的形状，可以区间翻转，可以实现动态树，不可持久化。

核心代码：

void rotate(int a) // 旋转
{
    int b = fa[a], c = fa[b];
    int k = son[b][1] == a, w = son[a][!k];

    if (no_root(b)) son[c][son[c][1] == b] = a;
    son[a][!k] = b;
    son[b][k] = w;

    if (w) fa[w] = b;
    fa[b] = a;
    fa[a] = c;
    pushup(b);
}

void splay(int x) // 将x移动到splay的根
{
    int y = x, z = 0;
    stk[++z] = y;

    while (no_root(y)) stk[++z] = y = fa[y];
    while (z) pushdown(stk[z--]);

    while (no_root(x))
    {
        y = fa[x]; z = fa[y];
        if (no_root(y)) rotate((son[y][0] == x) ^ (son[z][0] == y) ? x : y);
        rotate(x);
    }
    pushup(x);
}

 

Treap：

 

　　具有堆性质的BST，每个点有两个关键字，一个key为原来BST维护的值，一个fix

值，一个节点新建时，给予它一个随机的fix值，以fix为关键字构成最小根，Treap的期望高度为O(log  n)。

 

【模板】普通平衡树（题目）：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 2000010, INF = 1e9 + 7;

int root;

struct Node
{
    int l, r, val, size, dat, cnt;
    Node() {}
    Node(int l, int r, int val, int size, int cnt) :l(l), r(r), val(val), size(size), cnt(cnt) {}
};

int cnt;
Node tr[N];

int New(int x)
{
    tr[++cnt] = Node(0, 0, x, 1, 1);
    tr[cnt].dat = rand();
    return cnt;
}

void update(int q)
{
    tr[q].size = tr[tr[q].l].size + tr[q].cnt + tr[tr[q].r].size;
}

void build()
{
    New(-INF), New(INF);
    root = 1;
    tr[1].r = 2;
    update(root);
}

void zig(int &q) // 右旋
{
    int p = tr[q].l;
    tr[q].l = tr[p].r;
    tr[p].r = q;
    q = p;

    update(tr[q].r);
    update(q);
}

void zag(int& q)
{
    int p = tr[q].r;
    tr[q].r = tr[p].l;
    tr[p].l = q;
    q = p;

    update(tr[q].l);
    update(q);
}


void insert(int& q, int x)
{
    if (!q)
    {
        q = New(x);
        return;
    }

    if (x == tr[q].val)
    {
        tr[q].cnt++;
        update(q);
        return;
    }

    if (x < tr[q].val)
    {
        insert(tr[q].l, x);
        if (tr[q].dat < tr[tr[q].l].dat) zig(q);
    }
    else
    {
        insert(tr[q].r, x);
        if (tr[q].dat < tr[tr[q].r].dat) zag(q);
    }
    update(q);
}

void Delete(int &q, int x)
{
    if (!q) return;
    if (x == tr[q].val)
    {
        if (tr[q].cnt > 1)
        {
            tr[q].cnt--;
            update(q);
            return;
        }
        if (tr[q].l || tr[q].r)
        {
            if (tr[q].r == 0 || tr[tr[q].l].dat > tr[tr[q].r].dat) zig(q), Delete(tr[q].r, x);
            else zag(q), Delete(tr[q].l, x);
            update(q);
        }
        else q = 0;
        return;
    }

    if (x < tr[q].val) Delete(tr[q].l, x);
    else Delete(tr[q].r, x);
    update(q);
}

int find_rank(int q, int x)
{
    if (!q) return 0;
    if (x == tr[q].val) return tr[tr[q].l].size + 1;
    if (x < tr[q].val) return find_rank(tr[q].l, x);
    else return find_rank(tr[q].r, x) + tr[q].cnt + tr[tr[q].l].size;
}

int find_num(int q, int x)
{
    if (!q) return INF;
    if (x <= tr[tr[q].l].size) return find_num(tr[q].l, x);
    if (x <= tr[tr[q].l].size + tr[q].cnt) return tr[q].val;
    return find_num(tr[q].r, x - tr[tr[q].l].size - tr[q].cnt);
}

int find_befor(int x)
{
    int ans = 1, q = root;
    while (q)
    {
        if (x == tr[q].val)
        {
            if (tr[q].l > 0)
            {
                q = tr[q].l;
                while (tr[q].r > 0) q = tr[q].r;
                ans = q;
            }
            break;
        }
        if (tr[q].val<x && tr[q].val>tr[ans].val) ans = q;
        if (x < tr[q].val) q = tr[q].l;
        else q = tr[q].r;
    }
    return tr[ans].val;
}

int find_nex(int x)
{
    int ans = 2, q = root;
    while (q)
    {
        if (x == tr[q].val)
        {
            if (tr[q].r > 0)
            {
                q = tr[q].r;
                while (tr[q].l > 0) q = tr[q].l;
                ans = q;
            }
            break;
        }
        if (tr[q].val>x && tr[q].val<tr[ans].val) ans = q;
        if (x < tr[q].val) q = tr[q].l;
        else q = tr[q].r;
    }
    return tr[ans].val;
}

int main()
{
    build();

    int q;
    scanf("%d", &q);
    while (q--)
    {
        int op, x;
        scanf("%d%d", &op, &x);
        switch (op) 
        {
        case 1:
        {
            insert(root, x);
            break;
        }
        case 2:
        {
            Delete(root, x);
            break;
        }
        case 3:
        {
            printf("%d\n", find_rank(root, x) - 1);
            break;
        }
        case 4:
        {
            printf("%d\n", find_num(root, x + 1));
            break;
        }
        case 5:
        {
            printf("%d\n", find_befor(x));
            break;
        }

        case 6:
        {
            printf("%d\n", find_nex(x));
            break;
        }
        }
    }
}

 

【模板】文艺平衡树（题目）：

#include<cstdio>
#include<cstring>
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 2000010;

int n;
int w[N];
int lazy[N];
int root;

vector<int> ans;

struct Node
{
    int son[2], fa, val, size;
    Node() {}
};

Node tr[N];

void update(int q)
{
    tr[q].size = tr[tr[q].son[0]].size + tr[tr[q].son[1]].size + 1;
}

int build(int l, int r, int f)
{
    int q = (l + r) >> 1;
    tr[q].fa = f;
    tr[q].val = w[q];

    if (l < q) tr[q].son[0] = build(l, q - 1, q);
    if (r > q) tr[q].son[1] = build(q + 1, r, q);
    update(q);
    return q;
}

void pushdown(int x)
{
    if (!lazy[x]) return;

    lazy[tr[x].son[0]] ^= 1;
    lazy[tr[x].son[1]] ^= 1;
    swap(tr[x].son[0], tr[x].son[1]);
    lazy[x] = 0;
}

int find1(int x)
{
    int q = root;
    while (true)
    {
        pushdown(q);
        if (tr[q].son[0] && tr[tr[q].son[0]].size >= x) q = tr[q].son[0];
        else
        {
            int rank = (tr[q].son[0] ? tr[tr[q].son[0]].size : 0) + 1;
            if (x <= rank) return q;
            x -= rank;
            q = tr[q].son[1];
        }
    }
}

void rotate(int x)
{
    int y = tr[x].fa, z = tr[y].fa, k = tr[y].son[1] == x, w = tr[x].son[!k];

    if (z) tr[z].son[tr[z].son[1] == y] = x;
    else root = x;
    tr[y].son[k] = w;
    tr[x].son[!k] = y;

    if (w) tr[w].fa = y;
    tr[x].fa = z;
    tr[y].fa = x;
    update(y);
    update(x);
}

void splay(int x, int f)
{
    while (tr[x].fa != f)
    {
        int y = tr[x].fa, z = tr[y].fa;
        if (z != f) rotate(((tr[y].son[1] == x) ^ (tr[z].son[1] == y)) ? x : y);
        rotate(x);
    }
}

void print(int x)
{
    pushdown(x);
    if (tr[x].son[0]) print(tr[x].son[0]);
    ans.push_back(tr[x].val);
    if (tr[x].son[1]) print(tr[x].son[1]);
}

int main()
{
    int q;
    scanf("%d%d", &n,&q);

    for (int i = 1; i <= n + 2; i++) w[i] = i - 1;

    root = build(1, n + 2, 0);

    while (q--)
    {
        int l, r;
        scanf("%d%d", &l, &r);
        l = find1(l), r = find1(r + 2);
        splay(l, 0), splay(r, l);
        lazy[tr[tr[root].son[1]].son[0]] ^= 1;
    }

    print(root);
    for (int i = 0; i < n; i++) printf("%d ", ans[i + 1]);
}

 

【模板】二逼平衡树（题目）：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 2000010, INF = 2147483647;

int n;
int a[N];

struct Treap
{
    struct Node
    {
        int l, r, val, size, dat, cnt;
        Node() {}
        Node(int l, int r, int val, int size, int cnt) :l(l), r(r), val(val), size(size), cnt(cnt) {}
    };

    int cnt;
    Node tr[N];

    int New(int x)
    {
        tr[++cnt] = Node(0, 0, x, 1, 1);
        tr[cnt].dat = rand();
        return cnt;
    }

    void update(int q)
    {
        tr[q].size = tr[tr[q].l].size + tr[q].cnt + tr[tr[q].r].size;
    }

    void zig(int& q) // 右旋
    {
        int p = tr[q].l;
        tr[q].l = tr[p].r;
        tr[p].r = q;
        q = p;

        update(tr[q].r);
        update(q);
    }

    void zag(int& q)
    {
        int p = tr[q].r;
        tr[q].r = tr[p].l;
        tr[p].l = q;
        q = p;

        update(tr[q].l);
        update(q);
    }

    void insert(int& q, int x)
    {
        if (!q)
        {
            q = New(x);
            update(q);
            return;
        }

        if (x == tr[q].val)
        {
            tr[q].cnt++;
            update(q);
            return;
        }

        if (x < tr[q].val)
        {
            insert(tr[q].l, x);
            if (tr[q].dat < tr[tr[q].l].dat) zig(q);
        }
        else
        {
            insert(tr[q].r, x);
            if (tr[q].dat < tr[tr[q].r].dat) zag(q);
        }
        update(q);
    }

    void Delete(int& q, int x)
    {
        if (!q) return;
        if (x == tr[q].val)
        {
            if (tr[q].cnt > 1)
            {
                tr[q].cnt--;
                update(q);
                return;
            }
            if (tr[q].l || tr[q].r)
            {
                if (tr[q].r == 0 || tr[tr[q].l].dat > tr[tr[q].r].dat) zig(q), Delete(tr[q].r, x);
                else zag(q), Delete(tr[q].l, x);
                update(q);
            }
            else q = 0;
            return;
        }
        else if (x < tr[q].val) Delete(tr[q].l, x);
        else Delete(tr[q].r, x);
        
        if(q) update(q);
    }

    int find_rank(int q, int x)
    {
        if (!q) return 0;
        if (x == tr[q].val) return tr[tr[q].l].size;
        else if (x < tr[q].val) return find_rank(tr[q].l, x);
        else return find_rank(tr[q].r, x) + tr[q].cnt + tr[tr[q].l].size;
    }

    int find_num(int q, int x)
    {
        if (!q) return INF;
        if (x <= tr[tr[q].l].size) return find_num(tr[q].l, x);
        else if (x <= tr[tr[q].l].size + 1) return tr[q].val;
        return find_num(tr[q].r, x - tr[tr[q].l].size - tr[q].cnt);
    }

    int find_pre(int p, int k)
    {
        if (!p) return -INF;
        if (tr[p].val >= k) return find_pre(tr[p].l, k);
        else return max(tr[p].val, find_pre(tr[p].r, k));
    }

    int find_next(int p, int k)
    {
        if (!p) return INF;
        if (tr[p].val <= k) return find_next(tr[p].r, k);
        else return min(tr[p].val, find_next(tr[p].l, k));
    }
};

Treap treap;

struct SEG
{
    int root[N];

    void build(int q, int l, int r)
    {
        for (int i = l; i <= r; i++)
        {
            treap.insert(root[q], a[i]);
        }

        if (l == r) return;
        int mid = (l + r) >> 1;
        build(q << 1, l, mid);
        build(q << 1 | 1, mid + 1, r);
    }

    int find_rank(int q, int l, int r, int L, int R, int x)
    {
        if (L > r || R < l) return 0;
        if (L <= l && r <= R) return treap.find_rank(root[q], x);

        int mid = (l + r) >> 1;
        return  find_rank(q << 1, l, mid, L, R, x) + find_rank(q << 1 | 1, mid + 1, r, L, R, x);
    }

    int find_num(int L, int R, int k)
    {
        int l = 0, r = 1e8;
        while (l < r)
        {
            int mid = (l + r + 1) >> 1;
            if (find_rank(1, 1, n, L, R, mid) < k) l = mid;
            else r = mid - 1;
        }
        return r;
    }

    void modify(int q, int l, int r, int x, int k)
    {
        treap.Delete(root[q], a[x]);
        treap.insert(root[q], k);

        if (l == r) return;

        int mid = (l + r) >> 1;
        if (x <= mid) modify(q << 1, l, mid, x, k);
        else modify(q << 1 | 1, mid + 1, r, x, k);
    }

    int find_pre(int q, int l, int r, int L, int R, int x)
    {
        if (L > r || l > R) return -INF;
        int mid = (l + r) >> 1;
        if (L <= l && r <= R) return treap.find_pre(root[q], x);
        else return max(find_pre(q << 1, l, mid, L, R, x), find_pre(q << 1 | 1, mid + 1, r, L, R, x));
    }

    int find_next(int q, int l, int r, int L, int R, int x)
    {
        if (L > r || l > R) return INF;
        int mid = (l + r) >> 1;
        if (L <= l && r <= R) return treap.find_next(root[q], x);
        else return min(find_next(q << 1, l, mid, L, R, x), find_next(q << 1 | 1, mid + 1, r, L, R, x));
    }
};

SEG seg;

int main()
{
    int m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);

    seg.build(1, 1, n);

    while (m--)
    {
        int op;
        scanf("%d", &op);
        if (op == 1)
        {
            int l, r, k;
            scanf("%d%d%d", &l, &r, &k);
            printf("%d\n", seg.find_rank(1, 1, n, l, r, k) + 1);
        }
        if (op == 2)
        {
            int l, r, k;
            scanf("%d%d%d", &l, &r, &k);
            printf("%d\n", seg.find_num(l, r, k));
        }
        if (op == 3)
        {
            int pos, k;
            scanf("%d%d", &pos, &k);
            seg.modify(1, 1, n, pos, k);
            a[pos] = k;
        }
        if (op == 4)
        {
            int l, r, k;
            scanf("%d%d%d", &l, &r, &k);
            printf("%d\n", seg.find_pre(1, 1, n, l, r, k));
        }
        if (op == 5)
        {
            int l, r, k;
            scanf("%d%d%d", &l, &r, &k);
            printf("%d\n", seg.find_next(1, 1, n, l, r, k));
        }
    }
}

这题目就离谱

 

【BZOJ1251】序列终结者（题目）：

　　类似于线段树一样传翻转标记与相加标记

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 200010;

int n, m;
int root, cnt;
int num[N];
int fa[N], son[N][2];
int size1[N], v[N], mx[N];
int add[N], rev[N];

void pushup(int q)
{
    size1[q] = size1[son[q][0]] + size1[son[q][1]] + 1;
    mx[q] = max(v[q], max(mx[son[q][0]], mx[son[q][1]]));
}

void pushdown(int q)
{
    if (rev[q])
    {
        swap(son[q][0], son[q][1]);
        rev[son[q][0]] ^= 1;
        rev[son[q][1]] ^= 1;
        rev[q] = 0;
    }

    if (add[q])
    {
        if (son[q][0]) add[son[q][0]] += add[q], v[son[q][0]] += add[q], mx[son[q][0]] += add[q];
        if (son[q][1]) add[son[q][1]] += add[q], v[son[q][1]] += add[q], mx[son[q][1]] += add[q];
        add[q] = 0;
    }
}

int build(int l, int r, int pa)
{
    if (l > r) return 0;
    int q = ++cnt;
    int mid = (l + r) >> 1;

    fa[q] = pa;
    v[q] = mx[q] = num[mid];
    son[q][0] = build(l, mid - 1, q);
    son[q][1] = build(mid + 1, r, q);
    pushup(q);
    return q;
}

int find(int x)
{
    int q = root;
    while (q)
    {
        pushdown(q);
        if (x <= size1[son[q][0]]) q = son[q][0];
        else
        {
            x -= size1[son[q][0]] + 1;
            if (!x) return q;
            q = son[q][1];
        }
    }
    return 0;
}

void rotate(int x)
{
    int y = fa[x], z = fa[y], k = son[y][1] == x, w = son[x][!k];

    pushdown(x);
    pushdown(y);

    if (z) son[z][son[z][1] == y] = x;
    son[y][k] = w;
    son[x][!k] = y;

    if (w) fa[w] = y;
    fa[y] = x;
    fa[x] = z;

    pushup(x);
    pushup(y);
}

void splay(int x, int pa)
{
    while (fa[x] != pa)
    {
        int y = fa[x], z = fa[y];
        if (z != pa) rotate((son[y][1] == x) ^ (son[z][1] == y) ? x : y);
        rotate(x);
    }
    if (!pa) root = x;
}

void split(int l, int r)
{
    l = find(l), r = find(r + 2);
    splay(l, 0), splay(r, l);
}

int main() 
{
    scanf("%d%d", &n, &m);

    mx[0] = num[1] = num[n + 2] = -2e9;
    root = build(1, n + 2, 0);

    while (m--)
    {
        int k, l, r, s;
        scanf("%d%d%d", &k, &l, &r);
        split(l, r);
        if (k == 1)
        {
            scanf("%d", &s);
            add[son[son[root][1]][0]] += s;
            v[son[son[root][1]][0]] += s;
            mx[son[son[root][1]][0]] += s;
        }
        else if (k == 2) rev[son[son[root][1]][0]] ^= 1;
        else if (k == 3) printf("%d\n", mx[son[son[root][1]][0]]);
    }
}

 

【BZOJ3262】陌上花开（题目）：

　　三维偏序模板，树状数组套平衡树，以b为关键字建树状数组，每个树状数组节点以c为关键字建平衡树，以a为关键字从小到大枚举进行插入操作（a一样大的要同时插入），在树状数组中插入b，每次插入再在当前节点的平衡树中插入c。

　　完成当前a的插入操作后立即进行询问，这样能保证已经插入的所有元素的a都小于等于当期元素，询问时查询树状数组中小于b的节点所代表的平衡树中小于c的节点一共有多少，得出的便是答案。

　　这不是CDQ模板么

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 2000010;

int n, k;

struct SPLAY
{
    struct tree
    {
        int val, fa, cnt, size, son[2];
        tree() {}
        tree(int val, int fa, int cnt, int size) :val(val), fa(fa), cnt(cnt), size(size) {}
    };

    int cnt = 0;
    tree tr[N];

    int New(int c)
    {
        cnt++;
        tr[cnt] = tree(c, 0, 1, 1);
        tr[cnt].son[0] = tr[cnt].son[1] = 0;
        return cnt;
    }

    void pushup(int q)
    {
        tr[q].size = tr[q].cnt;
        int ls = tr[q].son[0], rs = tr[q].son[1];
        if (ls) tr[q].size += tr[ls].size;
        if (rs) tr[q].size += tr[rs].size;
    }

    void rotate(int x)
    {
        int y = tr[x].fa, z = tr[y].fa, d = tr[y].son[1] == x, w = tr[x].son[!d];

        if (z) tr[z].son[tr[z].son[1] == y] = x;
        tr[y].son[d] = w;
        tr[x].son[!d] = y;

        if (w) tr[w].fa = y;
        tr[y].fa = x;
        tr[x].fa = z;

        pushup(y);
        pushup(x);
    }

    void splay(int x, int &rt)
    {
        if (x == rt) return;
        int pa = tr[rt].fa;
        while (tr[x].fa != pa)
        {
            int y = tr[x].fa, z = tr[y].fa;
            if (tr[y].fa != pa) rotate((tr[y].son[1] == x) ^ (tr[z].son[1] == y) ? x : y);
            rotate(x);
        }
        rt = x;
    }

    void insert(int& rt, int c)
    {
        if (!rt)
        {
            rt = New(c);
            return;
        }

        int q = rt;
        while (true)
        {
            tr[q].size++;
            if (tr[q].val == c)
            {
                tr[q].cnt++;
                return;
            }
            int d = c > tr[q].val;
            if (tr[q].son[d]) q = tr[q].son[d];
            else
            {
                tr[q].son[d] = New(c);
                tr[tr[q].son[d]].fa = q;
                splay(tr[q].son[d], rt);
                return;
            }
        }
    }

    int query(int q, int c)
    {
        if (!q) return 0;
        if (tr[q].val == c) return (tr[q].son[0] ? tr[tr[q].son[0]].size : 0) + tr[q].cnt;
        else if (tr[q].val > c) return query(tr[q].son[0], c);
        else return (tr[q].son[0] ? tr[tr[q].son[0]].size : 0) + tr[q].cnt + query(tr[q].son[1], c);
    }
};
SPLAY Splay;

struct TREE
{
    int root[N];

    int lowbit(int x)
    {
        return x & -x;
    }

    void insert(int x, int y)
    {
        for (; x <= k; x += lowbit(x))
        {
            Splay.insert(root[x], y);
        }
    }

    int query(int x, int y)
    {
        int res = 0;
        for (; x; x -= lowbit(x))
        {
            res += Splay.query(root[x], y);
        }
        return res;
    }
};
TREE Tree;

struct Node
{
    int a, b, c;
    Node() {}
};

Node fl[N];

bool cmp(Node a, Node b)
{
    return a.a < b.a;
}

int f[N], g[N];
bool st[N];

int main()
{
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d%d", &fl[i].a, &fl[i].b, &fl[i].c);
    }

    sort(fl + 1, fl + 1 + n, cmp);

    for (int i = 1; i <= n; i++)
    {
        if (!st[i])
        {
            for (int j = i; fl[j].a == fl[i].a && j <= n; j++)
            {
                Tree.insert(fl[j].b, fl[j].c);
                st[j] = true;
            }
        }
        f[i] = Tree.query(fl[i].b, fl[i].c);
    }

    for (int i = 1; i <= n; i++) g[f[i]]++;
    for (int i = 1; i <= n; i++) printf("%d\n", g[i]);
}

 

【HNOI2012】永无乡（题目）：

　　并查集维护联通，Splay启发式合并（暴力合并）。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

#define MAX 500000

struct Node
{
    int ch[2];
    int val, ff, size;
}t[MAX];

int f[MAX];
int root[MAX], tot;
int hh[MAX];
int N, M;

int getf(int x)
{
    return x == f[x] ? x : f[x] = getf(f[x]);
}

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

inline void rotate(int x)
{
    int y = t[x].ff;
    int z = t[y].ff;
    int k = t[y].ch[1] == x;
    t[z].ch[t[z].ch[1] == y] = x; t[x].ff = z;
    t[y].ch[k] = t[x].ch[k ^ 1]; t[t[x].ch[k ^ 1]].ff = y;
    t[x].ch[k ^ 1] = y; t[y].ff = x;
    pushup(y); pushup(x);
}

inline void splay(int x, int goal)
{
    while (t[x].ff != goal)
    {
        int y = t[x].ff, z = t[y].ff;
        if (z != goal)
            (t[z].ch[0] == y) ^ (t[y].ch[0] == x) ? rotate(x) : rotate(y);
        rotate(x);
    }
    if (goal <= N)root[goal] = x;
}

inline void insert(int x, int bh)
{
    int u = root[bh], ff = bh;
    while (u && t[u].val != x)
        ff = u, u = t[u].ch[x > t[u].val];
    u = ++tot;
    t[u].size = 1;
    t[u].ff = ff;
    if (ff > N)
        t[ff].ch[x > t[ff].val] = u;
    t[u].val = x; t[u].ch[0] = t[u].ch[1] = 0;
    splay(u, bh);
}

void DFS(int u, int kk)
{
    if (t[u].ch[0])DFS(t[u].ch[0], kk);
    if (t[u].ch[1])DFS(t[u].ch[1], kk);
    insert(t[u].val, kk);
}

inline void Merge(int a, int b)
{
    int x = getf(a), y = getf(b);
    if (x == y)return;
    if (t[root[x]].size > t[root[y]].size)swap(x, y);
    f[x] = y;
    DFS(root[x], y);
}

int kth(int bh, int k)
{
    int u = root[bh];
    if (t[u].size < k)return -1;
    while (233)
    {
        if (t[t[u].ch[0]].size + 1 < k)
        {
            k -= t[t[u].ch[0]].size + 1;
            u = t[u].ch[1];
        }
        else
            if (t[t[u].ch[0]].size >= k)
                u = t[u].ch[0];
            else
                return t[u].val;
    }
}

int main()
{
    scanf("%d%d", &N, &M);
    for (int i = 1; i <= N; ++i)root[i] = i + N, f[i] = i;
    tot = N + N;
    for (int i = 1; i <= N; ++i)
    {
        int x;
        scanf("%d", &x);
        hh[x] = i;
        t[i + N].val = x; t[i + N].size = 1; t[i + N].ff = i;
    }
    for (int i = 1; i <= M; ++i)
    {
        int x, y;
        scanf("%d%d", &x, &y);
        Merge(x, y);
    }
    int Q;
    scanf("%d", &Q);
    while (Q--)
    {
        char ch[3]; int a, b;
        scanf("%s%d%d", ch, &a, &b);
        if (ch[0] == 'B')
        {
            Merge(a, b);
        }
        else
        {
            int ans = kth(getf(a), b);
            printf("%d\n", ans == -1 ? ans : hh[ans]);
        }
    }
    return 0;
}

 

【CF414E】Mashmokh's Designed Problem（题目）

不会

【BZOJ3600】没有人的算术（题目）

　　用一个实数来代表pair值，SGT来插入，线段树查询，具体看代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

typedef long long LL;

LL read()
{
    LL x = 0, f = 0;
    char ch = getchar();
    while (!isdigit(ch)) f = ch == '-', ch = getchar();
    while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
    return f ? -x : x;
}

const int N = 500010;

int n, m;
int root, R, top;
int mx[N], pos[N], id[N];
double a[N];
char ch[5];

struct Node 
{
    int l, r;
    Node() {}
    Node(int l, int r) :l(l), r(r) {}

    friend bool operator > (Node x, Node y)
    {
        if (a[x.l] > a[y.l])return 1;
        if (a[x.l] == a[y.l] && a[x.r] > a[y.r])return 1;
        return 0;
    }

    friend bool operator == (Node x, Node y)
    {
        if (x.l != y.l || x.r != y.r)return 0;
        return 1;
    }
};

struct SGTree
{
    int cnt;
    Node v[N];
    int siz[N], ls[N], rs[N];

    void dfs(int k)
    {
        if (!k)return;
        dfs(ls[k]);
        id[++top] = k;
        dfs(rs[k]);
    }

    void pushup(int q)
    {
        siz[q] = siz[ls[q]] + siz[rs[q]] + 1;
    }

    void build(int& q, int l, int r, double L, double R) // 建树
    {
        if (l > r) 
        {
            q = 0; 
            return; 
        }

        double vmid = (L + R) / 2.0;
        int mid = (l + r) / 2;

        q = id[mid];
        a[q] = vmid;
        build(ls[q], l, mid - 1, L, vmid);
        build(rs[q], mid + 1, r, vmid, R);
        pushup(q);
    }

    void rebuild(int& q, double l, double r) // 重构
    {
        top = 0;
        dfs(q);
        build(q, 1, top, l, r);
    }

    int insert(int& q, double l, double r, Node val) 
    {
        double mv = (l + r) / 2.0;
        if (!q)
        {
            q = ++cnt; 
            a[q] = mv;
            v[q] = val; 
            siz[q] = 1;
            return q;
        }

        int p;
        if (val == v[q]) return q;
        else
        {
            siz[q]++;
            if (val > v[q]) p = insert(rs[q], mv, r, val);
            else p = insert(ls[q], l, mv, val);
        }
        if (siz[q] * 0.75 > max(siz[ls[q]], siz[rs[q]]))
        {
            if (R)
            {
                if (ls[q] == R) rebuild(ls[q], l, mv);
                else rebuild(rs[q], mv, r);
                R = 0;
            }
        }
        else R = q;
        return p;
    }
}SGT;

void modify(int k, int l, int r, int v)
{
    if (l == r)
    {
        mx[k] = l;
        return; 
    }

    int mid = (l + r) >> 1;
    if (v <= mid) modify(k << 1, l, mid, v);
    else modify(k << 1 | 1, mid + 1, r, v);

    int x = mx[k << 1], y = mx[k << 1 | 1];
    if (a[pos[x]] >= a[pos[y]]) mx[k] = x;
    else mx[k] = y;
}

int query(int k, int l, int r, int x, int y)
{
    if (l == x && y == r) return mx[k];
    int t = 0, p = 0;
    int mid = (l + r) >> 1;
    if (x <= mid)
    {
        p = query(k << 1, l, mid, x, min(mid, y));
        if (a[pos[p]] > a[pos[t]])t = p;
    }
    if (y > mid)
    {
        p = query(k << 1 | 1, mid + 1, r, max(x, mid + 1), y);
        if (a[pos[p]] > a[pos[t]])t = p;
    }
    return t;
}

int main()
{
    n = read(), m = read();
    a[0] = -1;
    SGT.insert(root, 0, 1, Node(0, 0));

    for (int i = 1; i <= n; i++) pos[i] = 1;
    for (int i = 1; i <= n; i++) modify(1, 1, n, i);

    for (int i = 1; i <= m; i++)
    {
        scanf("%s", ch + 1);
        int l = read(), r = read();
        if (ch[1] == 'C')
        {
            int K = read();
            pos[K] = SGT.insert(root, 0, 1, Node(pos[l], pos[r]));
            if (R) SGT.rebuild(root, 0, 1); R = 0;
            modify(1, 1, n, K);
        }
        else printf("%d\n", query(1, 1, n, l, r));
    }
}

 

LCT：

　　概念看

【BZOJ2049】

模板

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 10010;
const int inf = 1e9;

inline int read()
{
    int x = 0, f = 1; char ch = getchar();
    while (ch < '0' || ch>'9') { if (ch == '-') f = -1; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
    return x * f;
}

int n, m;
int fa[N], c[N][2], st[N];
bool rev[N];

inline bool isroot(int x)
{
    return c[fa[x]][0] != x && c[fa[x]][1] != x;
}

void pushdown(int k)
{
    int l = c[k][0], r = c[k][1];
    if (rev[k])
    {
        rev[k] ^= 1; rev[l] ^= 1; rev[r] ^= 1;
        swap(c[k][0], c[k][1]);
    }
}

void rotate(int x)
{
    int y = fa[x], z = fa[y], l, r;
    if (c[y][0] == x)l = 0; else l = 1; r = l ^ 1;
    if (!isroot(y))
    {
        if (c[z][0] == y)c[z][0] = x; else c[z][1] = x;
    }
    fa[x] = z; fa[y] = x; fa[c[x][r]] = y;
    c[y][l] = c[x][r]; c[x][r] = y;
}

void splay(int x)
{
    int top = 0; st[++top] = x;
    for (int i = x; !isroot(i); i = fa[i])
    {
        st[++top] = fa[i];
    }
    for (int i = top; i; i--)pushdown(st[i]);
    while (!isroot(x))
    {
        int y = fa[x], z = fa[y];
        if (!isroot(y))
        {
            if (c[y][0] == x ^ c[z][0] == y)rotate(x);
            else rotate(y);
        }
        rotate(x);
    }
}

void access(int x)
{
    int t = 0;
    while (x)
    {
        splay(x);
        c[x][1] = t;
        t = x; x = fa[x];
    }
}

void rever(int x)
{
    access(x); splay(x); rev[x] ^= 1;
}

void link(int x, int y)
{
    rever(x); fa[x] = y; splay(x);
}

void cut(int x, int y)
{
    rever(x); access(y); splay(y); c[y][0] = fa[x] = 0;
}

int find(int x)
{
    access(x); splay(x);
    int y = x;
    while (c[y][0])y = c[y][0];
    return y;
}

int main()
{
    char ch[10];
    int x, y;
    n = read(); m = read();
    for (int i = 1; i <= m; i++)
    {
        scanf("%s", ch);
        x = read(); y = read();
        if (ch[0] == 'C')link(x, y);
        else if (ch[0] == 'D')cut(x, y);
        else
        {
            if (find(x) == find(y))printf("Yes\n");
            else printf("No\n");
        }
    }
    return 0;
}

 

【BZOJ2631】

模板

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

typedef unsigned int UIT;

int read()
{
    int x = 0, f = 1; char ch = getchar();
    while (ch < '0' || ch>'9') { if (ch == '-')f = -1; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
    return x * f;
}

const int N = 100010;
const int mod = 51061;

int n, m, top, cnt;
int c[N][2], fa[N];
int siz[N], q[N];
bool rev[N];
UIT sum[N], val[N], at[N], mt[N];

void cal(int x, int m, int a)
{
    if (!x)return;
    val[x] = (val[x] * m + a) % mod;
    sum[x] = (sum[x] * m + a * siz[x]) % mod;
    at[x] = (at[x] * m + a) % mod;
    mt[x] = (mt[x] * m) % mod;
}

bool isroot(int x)
{
    return c[fa[x]][0] != x && c[fa[x]][1] != x;
}

void update(int x)
{
    int l = c[x][0], r = c[x][1];
    sum[x] = (sum[l] + sum[r] + val[x]) % mod;
    siz[x] = (siz[l] + siz[r] + 1) % mod;
}

void pushdown(int x)
{
    int l = c[x][0], r = c[x][1];
    if (rev[x])
    {
        rev[x] ^= 1; rev[l] ^= 1; rev[r] ^= 1;
        swap(c[x][0], c[x][1]);
    }
    int m = mt[x], a = at[x];
    mt[x] = 1; 
    at[x] = 0;
    if (m != 1 || a != 0)
    {
        cal(l, m, a); cal(r, m, a);
    }
}

void rotate(int x)
{
    int y = fa[x], z = fa[y], l, r;
    l = (c[y][1] == x); 
    r = l ^ 1;

    if (!isroot(y)) c[z][c[z][1] == y] = x;
    fa[x] = z;
    fa[y] = x; 
    fa[c[x][r]] = y;
    c[y][l] = c[x][r];
    c[x][r] = y;

    update(y);
    update(x);
}

void splay(int x)
{
    q[++top] = x;
    for (int i = x; !isroot(i); i = fa[i]) q[++top] = fa[i];

    while (top) pushdown(q[top--]);
    while (!isroot(x))
    {
        int y = fa[x], z = fa[y];
        if (!isroot(y))
        {
            if (c[y][0] == x ^ c[z][0] == y) rotate(x);
            else rotate(y);
        }
        rotate(x);
    }
}

void access(int x)
{
    for (int t = 0; x; t = x, x = fa[x])
    {
        splay(x);
        c[x][1] = t; 
        update(x);
    }
}

void makeroot(int x)
{
    access(x);
    splay(x);
    rev[x] ^= 1;
}

void split(int x, int y)
{
    makeroot(y); 
    access(x);
    splay(x);
}

void link(int x, int y)
{
    makeroot(x);
    fa[x] = y;
}

void cut(int x, int y)
{
    makeroot(x);
    access(y);
    splay(y);
    c[y][0] = fa[x] = 0;
}

int main()
{
    n = read();
    m = read();

    for (int i = 1; i <= n; i++) val[i] = sum[i] = mt[i] = siz[i] = 1;

    for (int i = 1; i < n; i++)
    {
        int u = read(), v = read();
        link(u, v);
    }

    char ch[5];
    while (m--)
    {
        scanf("%s", ch);
        int u = read(), v = read();
        if (ch[0] == '+')
        {
            int x = read();
            split(u, v); cal(u, 1, x);
        }
        if (ch[0] == '-')
        {
            cut(u, v);
            u = read(); v = read(); link(u, v);
        }
        if (ch[0] == '*')
        {
            int x = read();
            split(u, v); cal(u, x, 0);
        }
        if (ch[0] == '/')
        {
            split(u, v);
            printf("%d\n", sum[u]);
        }
    }
}

 

【BZOJ4389】

模板

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 200010;

typedef long long LL;

int n, m;

int f[N], son[N][2], tmp[N], c[N]; 
bool rev[N];
LL v[N], s[N], mx[N], tc[N], ta[N];
LL st[N], sa[N], as[N];

inline void read(int& a)
{ 
    char c;
    while (!(((c = getchar()) >= '0') && (c <= '9')));
    a = c - '0';
    while (((c = getchar()) >= '0') && (c <= '9'))(a *= 10) += c - '0'; 
}

inline bool isroot(int x)
{ 
    return !f[x] || son[f[x]][0] != x && son[f[x]][1] != x;
}

inline void rev1(int x) 
{ 
    if (!x)return; 
    swap(son[x][0], son[x][1]);
    rev[x] ^= 1; 
}

inline void col1(int x, LL y)
{
    if (!x)return;
    v[x] = mx[x] = tc[x] = y;
    s[x] = y * c[x];
    ta[x] = 0;
    sa[x] = s[x] + st[x];
}

inline void add1(int x, LL y) 
{
    if (!x)return;
    v[x] += y;
    s[x] += y * c[x];
    mx[x] += y;
    if (tc[x])tc[x] += y; else ta[x] += y;
    sa[x] = s[x] + st[x];
}

inline void pb(int x) 
{
    if (rev[x]) rev1(son[x][0]), rev1(son[x][1]), rev[x] = 0;
    if (tc[x]) col1(son[x][0], tc[x]), col1(son[x][1], tc[x]), tc[x] = 0;
    if (ta[x]) add1(son[x][0], ta[x]), add1(son[x][1], ta[x]), ta[x] = 0;
}

inline void up(int x) 
{
    s[x] = mx[x] = v[x]; c[x] = 1;
    st[x] = as[x];
    for (int i = 0; i < 2; i++)
    {
        int y = son[x][i];
        if (y) {
            c[x] += c[y];
            s[x] += s[y];
            mx[x] = max(mx[x], mx[y]);
            st[x] += st[y];
        }
    }
    sa[x] = s[x] + st[x];
}

inline void rotate(int x) 
{
    int y = f[x], w = son[y][1] == x;
    son[y][w] = son[x][w ^ 1];
    if (son[x][w ^ 1]) f[son[x][w ^ 1]] = y;
    if (f[y])
    {
        int z = f[y];
        if (son[z][0] == y) son[z][0] = x; 
        else if (son[z][1] == y) son[z][1] = x;
    }
    f[x] = f[y];
    f[y] = x; 
    son[x][w ^ 1] = y;
    up(y);
}

inline void splay(int x) 
{
    int s = 1, i = x, y; 
    tmp[1] = i;
    while (!isroot(i)) tmp[++s] = i = f[i];
    while (s) pb(tmp[s--]);
    while (!isroot(x))
    {
        y = f[x];
        if (!isroot(y)) { if ((son[f[y]][0] == y) ^ (son[y][0] == x))rotate(x); else rotate(y); }
        rotate(x);
    }
    up(x);
}

inline void access(int x)
{
    for (int y = 0; x; y = x, x = f[x]) 
    {
        splay(x);
        if (son[x][1]) as[x] += sa[son[x][1]];
        if (son[x][1] = y) as[x] -= sa[y];
        up(x);
    }
}

inline void makeroot(int x) 
{ 
    access(x);
    splay(x);
    rev1(x); 
}

inline void link(int x, int y)
{
    makeroot(x);
    makeroot(y);
    as[y] += sa[x];
    f[x] = y;
    access(x);
}

inline void cutf(int x)
{ 
    access(x); 
    splay(x); 
    f[son[x][0]] = 0; 
    son[x][0] = 0; 
    up(x);
}

inline void cut(int x, int y) 
{ 
    makeroot(x); 
    cutf(y); 
}

inline void col(int x, int y, int z)
{
    makeroot(x);
    access(y); 
    splay(y); 
    col1(y, z); 
}

inline void add(int x, int y, int z) 
{ 
    makeroot(x); 
    access(y); 
    splay(y);
    add1(y, z);
}

inline LL chainsum(int x, int y) 
{ 
    makeroot(x);
    access(y);
    splay(y);
    return s[y]; 
}

inline LL chainmax(int x, int y) 
{ 
    makeroot(x); 
    access(y); 
    splay(y);
    return mx[y]; 
}

inline LL subtreesum(int x, int y) 
{ 
    makeroot(x); 
    access(y); 
    splay(y);
    return as[y] + v[y]; 
}

int main() 
{
    read(n);
    for (int i = 1; i <= n; i++)
    {
        int x;
        read(x);
        v[i] = s[i] = mx[i] = sa[i] = x, c[i] = 1;
    }
    for (int i = 2; i <= n; i++)
    {
        int x;
        read(x);
        link(x, i);
    }
    read(m);
    while (m--) 
    {
        int op, x, y, z;
        read(op), read(x), read(y);
        if (op == 1) read(z), add(x, y, z);
        if (op == 2) read(z), col(x, y, z);
        if (op == 3) printf("%lld\n", subtreesum(x, y));
        if (op == 4) printf("%lld\n", chainmax(x, y));
        if (op == 5) printf("%lld\n", chainsum(x, y));
        if (op == 6) link(x, y);
        if (op == 7) cut(x, y);
    }
}