学习笔记：左偏树

左偏树是一种能够在支持在 $O(logn)$ 的时间复杂度内进行合并的满足堆性质的树，因此别名“可并堆”，具有可合并与复杂度稳定的优势。

模板题

基本概念与定义

1. 外结点：至少有一个儿子是空节点的节点。
2. $dist_x$ 表示以 $x$ 为根的子树内到 $x$ 距离最小的外结点的距离。特别的，对于空结点，其 $dist=-1$ 

左偏树的性质

1. 左偏树满足小根堆性质（大根堆貌似也可以），即对于结点 $x$，总有 $v_x\leq v_{lc}$ 且 $v_x\leq v_{rc}$。

2. 左偏树满足左偏的性质，即对于任意节点均有：$dist_{lc}\geq dist_{rc}$。

显然的结论

1. $dist_x=dist_{rc}+1$。
2. 一棵有 $n$ 个结点的左偏树其根节点的 $dist$ 是 $O(logn)$ 的。（可以保证合并的复杂度的稳定性）

 合并操作

显然我们对于两个堆我们会一个一个比较合并，复杂度与树高正相关。显然，如果退化成链，复杂度将为 $O(n)$。这时我们左偏树的优势就体现出来了，由上面的结论 2，一次合并的复杂度稳定为 $O(logn)$。由左偏的性质，每次合并时，我们选择 $dist$ 的更小的右儿子去合并，这个过程可以递归实现，在过程中利用 $swap$ 维护堆性质，并在合并后回溯时维护左偏的性质即可。

 

int merge(int x,int y)
{
    if(not x or not y) return x + y;
    if(val[y] < val[x]) swap(x,y);
    rc[x] = merge(rc[x],y);
    if(dist[lc[x]] < dist[rc[x]]) swap(lc[x],rc[x]);
    dist[x] = dist[rc[x]] + 1;
    return x;
}

 

删除所在堆顶元素操作

这里我们需要对于每个结点维护一个 $root_x$ 表示该节点所在的堆顶元素（即所在的左偏树根），那么对于 $root$ 的维护，如果合并后暴力的一个一个跳，复杂度将退化为 $O(n)$。我们联想到并查集，于是使用路径压缩，将复杂度维持在 $O(logn)$。在删除堆顶元素时，只需要将根的左右两棵子树合并即可，由于均满足左偏树性质，所以合并完仍为左偏树。同时记得要将删除节点$x$ 的 $root_x$ 也指向合并后的根，以保证路径压缩的正确性，同时将删除结点的信息清空。

int get_root(int x)
{
    if(x == root[x]) return x;
    else return root[x] = get_root(root[x]);
}
void del(int x)
{
    inl[x] = false;
    root[lc[x]] = root[rc[x]] = root[x] = merge(lc[x],rc[x]);
    lc[x] = rc[x] = 0,dist[x] = -1;
}

完整代码

#include<bits/stdc++.h>
using namespace std;
static inline int read()
{
    char c;
    int flag = 0;
    while(not isdigit(c = getchar())) flag = (c == '-') ? 1 : flag;
    int x = 0;
    while(isdigit(c))
    {
        x = (x << 3) + (x << 1) + c - '0';
        c = getchar();
    }
    return flag ? -x : x;
}
static inline void write(int x)
{
    if(x >= 10) write(x / 10);
    putchar('0' + x % 10);
}
const int N = 100000 + 10;
struct node
{
    int pos,v;
    friend bool operator < (node xx,node yy) { return xx.v == yy.v ? xx.pos < yy.pos : xx.v < yy.v; }
} val[N];
int n,m;
bool inl[N];
int lc[N],rc[N],dist[N],root[N];
int merge(int x,int y)
{
    if(not x or not y) return x + y;
    if(val[y] < val[x]) swap(x,y);
    rc[x] = merge(rc[x],y);
    if(dist[lc[x]] < dist[rc[x]]) swap(lc[x],rc[x]);
    dist[x] = dist[rc[x]] + 1;
    return x;
}
int get_root(int x)
{
    if(x == root[x]) return x;
    else return root[x] = get_root(root[x]);
}
void del(int x)
{
    inl[x] = false;
    root[lc[x]] = root[rc[x]] = root[x] = merge(lc[x],rc[x]);
    lc[x] = rc[x] = 0,dist[x] = -1;
}
signed int main()
{
    dist[0] = -1;
    n = read(),m = read();
    for(int i = 1;i <= n;i++)
    {
        val[i].v = read();
        val[i].pos = i,root[i] = i,inl[i] = true; 
    }
    while(m--)
    {
        int opt = read();
        if(opt == 1)
        {
            int x = read(),y = read();
            if(not inl[x] or not inl[y]) continue;
            x = get_root(x),y = get_root(y);
            if(x == y) continue;
            root[x] = root[y] = merge(x,y);
        }
        else
        {
            int x = read();
            if(not inl[x])  printf("-1\n");
            else
            {
                x = get_root(x);
                write(val[x].v),putchar('\n');
                del(x);
            }
        }
    }
    return 0;
}