AcWing算法基础课笔记——堆

AcWing算法基础课中堆部分的笔记。
欢迎访问我的个人主页：https://hjh645.github.io/
(>w<)~

堆

如何手写堆？

1. 插入一个数

   heap[++size] = x;   //将x插入末尾
   up(size)；  //往上移
   
   

2. 求集合中的最小值 heap[1];

3. 删除最小值

   //将堆的最后一个元素覆盖根结点，然后再把顶点往下down
   heap[1] = heap[size];  //覆盖根节点
   size -- ;
   down(1); //将根节点往下移
   

4. 删除任意一个元素（STL中无法直接实现）

   heap[k] = heap[size];
   size -- ;
   down(k); //实际down up只会执行一个
   up(k); 
   

5. 修改任意一个元素（STL中无法直接实现）

   heap[k] = x;
   down(k);
   up(k);
   

堆是一棵完全二叉树，除了最后一行节点外，其他节点都是满的，最后一行节点从左到右排列。

根节点是最小值，每个节点小于它的两个儿子。

使用一维数组来存储。

根节点：1。x的左儿子：2x，右儿子：2x+1

堆的两个基本操作：

1. down(x)：把节点往下移
2. up(x)：把节点往上移

变小了 -> 和父节点比，比父节点小就和父节点交换；

变大了 -> 和两个子节点比，和子节点中最小的那个交换。

插入删除都是logn

模板题1 堆排序

题目

题目内容

输入一个长度为n的整数数列，从小到大输出前m小的数。

输入格式

第一行包含整数n和m。

第二行包含n个整数，表示整数数列。

输出格式

共一行，包含m个整数，表示整数数列中前m小的数。

数据范围

1≤m≤n≤105 ， 1≤数列中元素≤109

输入样例：

5 3
4 5 1 3 2

输出样例：

1 2 3

模板

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

const int N = 1e5 + 10;

int n, m;
int h[N], size;

void down(int u) {
    int t = u;
    // 经过以下两步，t变为u, 2u, 2u+1 中最小的节点的编号
    if(2 * u <= size && h[t] > h[2 * u]) t = u * 2;
    if(2 * u + 1 <= size && h[t] > h[2 * u + 1]) t = u * 2 + 1;
    
    // 如果u不是最小的，则和最小的值交换，然后递归处理
    if(t != u) {
        swap(h[u], h[t]);
        down(t);
    }
}

void up(int u) {
    while (u / 2 && h[u / 2] > h[u]) {
        swap(h[u / 2], h[u]);
        u /= 2;
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i ++ ) scanf("%d", &h[i]);
    size = n;
    
    // 创建堆，复杂度为O(n)
    for(int i = n / 2; i; i -- ) down(i);
    
    while (m --) {
        print("%d ", h[1]);
        h[1] = h[size];
        size --;
        down(1);
    }
    
    return 0;
}

模板题2 模拟堆

题目

维护一个集合，初始为空，支持如下操作：
（1）“I x”，插入一个数x xx；
（2）“PM”，输出当前集合中的最小值；
（3）“DM”，删除当前集合中的最小值（数据保证此时的最小值唯一）；
（4）“D k”，删除第k kk个插入的数；
（5）“C k x”，修改第k kk个插入的数，将其变为x xx；
现在要进行N NN次操作，对于所有第2 22个操作，输出当前集合的最小值。

输入格式：
第一行包含整数$N$。接下来$N$行，每行包含一个操作指令，操作指令为”I x”，”PM”，”DM”，”D k”或”C k x”中的一种。

输出格式：
对于每个输出指令“PM”，输出一个结果，表示当前集合中的最小值。每个结果占一行。

数据范围：

$1\le N\le 10^5$

$-10^9\le x\le 10^9$

模板

#include <iostream>
#include <algorithm>
#include <string.h>

using namespace std;

int h[N], ph[N], hp[N], size;

void heap_swap(int a, int b) {
    swap(ph[hp[a]], ph[hp(b)]);
    swap(hp[a], hp[b]);
    swap(a, b);
}

void down(int u) {
    int t = u;
    if(2 * u <= size && h[t] > h[2 * u]) t = 2 * u;
    if(2 * u + 1 <= size && h[t] > h[2 * u + 1]) t = 2 * u + 1;
    
    if(t != u) {
        heap_swap(h[t], h[u]);
        down(t);
    }
}

void up(int u) {
    while(u / 2 && h[u / 2] > h[u]) {
        heap_swap(u / 2, u);
        u /= 2;
    }
}

void main() {
    int n , m = 0;
    scanf("%d", &n);
    while(n --) {
        char op[10];
        int k, x;
        
        scanf("%s", op);
        if(!strcmp(op, "I")) {
            scanf("%d", &x);
            size ++;
            m ++;
            ph[m] = size, hp[size] = m;
            h[size] = x;
            up(size);
        }
        else if(!strcmp(op, "PM")) printf("%d\n", h[1]);
        else if(!strcmp(op, "DM")) {
            heap_swap(1, size);
            size --;
            down(1);
        }
        else if(!strcmp(op, "D")) {
            scanf("%d", &k);
            k = ph[k];
            heap_swap(k, size);
            size --;
            down(k), up(k);
        }else {
            scanf("%d%d", &k, &x);
            k = ph[k];
            h[k] = x;
            down(k), up(k);
        }
    }
    
    return 0;
}