左偏树模板

概要：左偏树是具有左偏性质的堆有序二叉树，它相比于优先队列，能够实现合并堆的功能。

先orz国家集训队论文https://wenku.baidu.com/view/515f76e90975f46527d3e1d5.html

左偏树的几个基本性质如下：

1. 节点的键值小于等于它的左右子节点的键值
2. 节点的左子节点的距离不小于右子节点的距离
3. 节点的距离等于右子节点的距离加一，由此可推出一个引理和一个定理：
   1. 　　若左子树的距离为一定值，则节点数最少的左偏树是完全二叉树
   2. 若一棵左偏树的距离为k，则这颗左偏树至少有2^k+1-1个节点

　　4.一棵N个节点的左偏树的距离最多为[log(N+1)]-1

左偏树的节点定义：

struct node {
    int val, lc, rc, dis, par;
} t[maxn];

初始化操作：

void init(int x) {
    for (int i = 1; i <= x; i++) {
        t[i].lc = t[i].rc = t[i].dis = 0;
        t[i].par = i;
    }
}

基本的查询双亲，是否属于同个集合：

int find(int x) {
    if (t[x].par == x) return x;
    else return t[x].par = find(t[x].par);
}

bool same(int x, int y) {
    return find(x) == find(y);
}

  

左偏树的基本操作

1. 合并操作（事实上操作时始终把B插入A中）

　　　　函数返回的是合并后的树的根节点

　　　　首先特判是否存在空树

　　　　然后注意到左偏树我们需要保证根节点键值不大于两个子节点的键值，此处我们需要特判A、B的键值，决定swap函数的调用与否（维护性质1）

　　　　接着判断A的左右子树的距离，决定是否调用swap（维护性质2）

　　　　最后根据A右子树的距离生成A的距离（维护性质3）

int unite(int x, int y) {
    if (x == 0)
        return y;
    if (y == 0)
        return x;
    if (t[x].val < t[y].val)
        swap(x, y);
    t[x].rc = unite(t[x].rc, y);
    t[t[x].rc].par = x;
    if (t[t[x].lc].dis < t[t[x].rc].dis)
        swap(t[x].lc, t[x].rc);
    if (t[x].rc == 0)
        t[x].dis = 0;
    else
        t[x].dis = t[t[x].rc].dis + 1;
    return x;
}

　　2.插入节点

　　　　将B节点视为一棵左偏树，合并A、B即可

　　3.删除最小（大）节点

　　　　等同于合并根节点的左右子树（可能会涉及修改左右子树的父亲为自身）

int pop(int x) {
    int l = t[x].lc, r = t[x].rc;
    t[x].lc = t[x].rc = t[x].dis = 0;
    t[l].par = l, t[r].par = r;
    return unite(l, r);
}

　　

HDU-1512

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#define INF 0x3f3f3f3f
#define mod 1000000007
typedef long long LL;
using namespace std;
const int maxn = 1e5 + 10;

int n, m;

struct node {
    int val, lc, rc, dis, par;
} t[maxn];

void init(int x) {
    for (int i = 1; i <= x; i++) {
        t[i].lc = t[i].rc = t[i].dis = 0;
        t[i].par = i;
    }
}

int find(int x) {
    if (t[x].par == x) return x;
    else return t[x].par = find(t[x].par);
}

bool same(int x, int y) {
    return find(x) == find(y);
}

int unite(int x, int y) {
    if (x == 0)
        return y;
    if (y == 0)
        return x;
    if (t[x].val < t[y].val)
        swap(x, y);
    t[x].rc = unite(t[x].rc, y);
    t[t[x].rc].par = x;
    if (t[t[x].lc].dis < t[t[x].rc].dis)
        swap(t[x].lc, t[x].rc);
    if (t[x].rc == 0)
        t[x].dis = 0;
    else
        t[x].dis = t[t[x].rc].dis + 1;
    return x;
}
//
int pop(int x) {
    int l = t[x].lc, r = t[x].rc;
    t[x].lc = t[x].rc = t[x].dis = 0;
    t[l].par = l, t[r].par = r;
    return unite(l, r);
}

void solve(int x, int y) {
    x = find(x), y = find(y);
    t[x].val /= 2, t[y].val /= 2;
    int xx = pop(x), yy = pop(y);
    xx = unite(xx, x), yy = unite(yy, y);
    xx = unite(xx, yy);
    printf("%d
", t[xx].val);
}

int main(int argc, const char * argv[]) {
    while (~scanf("%d", &n)) {
        init(n);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &t[i].val);
        }
        scanf("%d", &m);
        while (m--) {
            int x, y;
            scanf("%d%d", &x, &y);
            if (same(x, y)) {
                printf("-1
");
            } else {
                solve(x, y);
            }
        }
    }
    return 0;
}