目录

• 左偏树整理
  • 引言

左偏树整理

整理自IOI2005 国家集训队论文 黄源河 的《左 偏 树 的 特 点 及 其 应 用》

引言

ps:优先队列的实现方式是二叉堆(完全二叉树,父亲的值大于左右两个儿子的值)

针对一些优先队列(二叉堆)合并问题的解法.

优先队列(二叉堆)可以支持三种操作

• 查询最大(小)值 (Query-Max(Min))
• 删除最大(小)值(Delete-Max(Min))
• 插入一个元素(Insert)

  如果需要一次合并,想法是直接暴力合并.显然时间复杂度是$O(log n * log k)$

  如果经常合并,并且查询,就会造成时间复杂度无法保证,可以卡到O(n)

  经过只要一次的合并 , 我们可以想到 , 可以平衡一下左右儿子的数量，由此，左偏树就出现了.

  左偏树,二项堆和Fibonacci 堆都是可并堆.可是我只学会了左偏树.

  初窥

  左偏树是一个二叉树

  左偏树有着比优先队列多的一个操作，就是Merge操作,Merge(a,b)代表合并a这个堆和b这个堆.

  显然,插入一个元素这个操作直接用Merge操作即可.

  入门

  下面详细介绍左偏树

  左偏树拥有4个基本属性 , 指向左儿子的指针,指向右儿子的指针,这个点的值,dis

  (由于我不会指针,所以直接用编号代替指针.)

  $dis_i$的意思为编号为i的结点到离他,最近的外结点所经过的边数.

  如果节点 i 本身是外节点，则它的距离为 0；而空节点的距离规定为-1 (dist(NULL) = -1)。

  性质1

  节点的键值小于或等于它的左右子节点的键值.

  性质2

  左偏性质 : 节点的左子节点的距离不小于右子节点的距离.

  左偏树定义:左偏树是具有左偏性质的堆有序二叉树

  下图为左偏树

  

  性质 3

  节点的距离等于它的右子节点的距离加 1.

  性质 4

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

  非常关键的一个性质,决定了左偏树的时间复杂度.

  详细证明 :

  引理: 若左偏树的距离为一定值，则节点数最少的左偏树是完全二叉树。

  由性质2可知,对于每一个结点来说当$dis[lson] == dis[rson]$时,节点数最少.

  那么就成了一个完全二叉树

  定理:若一棵左偏树的距离为k，则这棵左偏树至少有 $2^{k+1}-1$ 个节点。

  根据引理 , 距离为k的话, 那么可定是一个完全二叉树.距离为k的完全二叉树高度也为k

  节点数就是$2^{k +1} -1$

  那么性质四的证明就是

  设一颗左偏树的距离为k,那么结点数$N >= 2^{k+1}-1$

  因此$k ≤ ?log(N+1)? -1$

  具体操作

  下面的话引自租酥雨的https://www.cnblogs.com/zhoushuyu/p/8169074.html

  在我们合并两个堆的时候，我们考虑哪个堆的堆顶元素会作为新堆的堆顶元素。显然是键值较大的那一个。那么我们就把较大的作为堆顶，然后，把另一个堆跟堆顶的右儿子进行合并(这样满足性质2)，合并的过程是递归的，复杂度为$O(logn)$

  Merge代码

int Merge(int A,int B){
    if (!A||!B) return A+B;
    if (key[A]<key[B]) swap(A,B);
    rs[A]=Merge(rs[A],B);
    if (dis[ls[A]]<dis[rs[A]]) swap(ls[A],rs[A]);
    dis[A]=dis[rs[A]]+1;
    return A;
}

删除堆顶元素

int Delete(int A){
    return Merge(ls[A],rs[A]);
}

模板题

luogu3377

https://www.luogu.org/problemnew/show/P3377

用个类似于并查集的东西维护一下父亲即可

#include <iostream>
#include <cstdio>
const int maxN = 100000 + 7;
#define rep(i , x, p) for(register int i = x;i <= p;++ i)
#define sep(i , x, p) for(int i = x;i >= p;-- i)
#define gc getchar()
#define pc putchar
inline int read() {int x = 0,f = 1;char c = gc;while(c < ‘0‘ || c > ‘9‘) {if(c == ‘-‘)f = -1;c = gc;}while(c >= ‘0‘ && c <= ‘9‘) {x = x * 10 + c - ‘0‘;c = gc;}return x * f;}
void print(int x) {if(x < 0) pc(‘-‘) , x = -x;if(x >= 10) print(x / 10);pc(x % 10 + ‘0‘);}

bool vis[maxN];
int key[maxN] , ls[maxN], rs[maxN], fa[maxN] , dis[maxN];

inline int find(int x) {while(fa[x]) x = fa[x];return x;}

inline void swap(int &a,int &b) {int tmp = a;a = b;b = tmp;}

int Merge(int x,int y) {
    if(!x || !y) return x + y;
    if(key[x] > key[y] || key[x] == key[y] && x > y) swap(x , y);
    rs[x] = Merge(rs[x] , y);
    fa[rs[x]] = x;
    if(dis[ls[x]] < dis[rs[x]]) swap(ls[x] , rs[x]);
    dis[x] = dis[rs[x]] + 1;
    return x;
}

inline void Dele(int x) {
    vis[x] = false;
    fa[ls[x]] = fa[rs[x]] = 0;
    Merge(ls[x] , rs[x]);
}

int main() {
    int n = read() , m = read();
    rep(i , 1, n) key[i] = read() , vis[i] = true;
    int type , x , y;
    while(m --) {
        type = read();x = read();
        if(type == 1) {
            y = read();
            int fax = find(x) , fay = find(y);
            if(!vis[x] || !vis[y] || fax == fay) continue;
            Merge(fax , fay);
        }
        else {
            if(!vis[x]) {puts("-1");continue;}
            int fax = find(x);
            printf("%d\n",key[fax]);
            Dele(fax);
        }
    }
    return 0;
}

原文地址：https://www.cnblogs.com/gzygzy/p/10028085.html