并查集 与 手写堆

并查集

路径优化：在找寻根节点得过程中，等找到根节点，将路径上的所有节点指向根节点，以方便下次直接快速定位

//初始化
int p[N];
//令每个节点指向自己，即最开始有n个集合（根节点），
for(int i = 1; i <= n; i++)	p[i] = i;
------------------------------------------------
//（核心） ---------> 返回x的祖宗节点 + 路径压缩
int find(int x) {	//-->核心
    //若不等于父节点，则指向祖宗节点
    if(p[x] != x)	p[x] = find(p[x]); 
    return p[x];
}
-----------------------------------------------
// function1 -----> 合并两个集合
p[find(a)] = find(b);	//令a的祖宗节点的父节点等于b的祖宗节点
-------------------------------------------------
// function2 -----> 判断 a 和 b 是否在同一个集合中
   return find(a) == find(b)?

例题

连通块中点的数量

相当于在上方基础模板的基础上加了一步统计节点个数，维护数组，每次合并集合前，将节点个数累加到要合并的位置去

代码

#include <iostream>
using namespace std;
const int N = 100010;
int p[N], s[N];//定义s[N]存储每个集合节点用
int n, m;
int find(int x) {
    if(p[x] != x)   p[x] = find(p[x]);
    return p[x];
}
int main() {
    cin >> n >> m;
    for(int i =1; i <= n; i++)  p[i] = i, s[i] = 1;
    while(m --) {
        char op[3];
        int a, b, r;
        scanf("%s", op);
        if(op[0] == 'C') {
            scanf("%d%d", &a, &b);
            if(find(a) == find(b))  continue;
            
            //更新节点个数-- >注意下面两行的顺序不能乱
            s[find(b)] += s[find(a)];
            p[find(a)] = find(b);
        } else if(op[1] == '1') {
            scanf("%d%d", &a, &b);
            if(find(a) == find(b))  printf("Yes\n");
            else printf("No\n");
        } else  {
            scanf("%d", &r);
            printf("%d\n", s[find(r)]);
        }
    }
    return 0;
}

堆

---

堆的基本操作

堆的结构类似于一个完全二叉树，即上层的值填满，最后一层从左到右依次排列

STL里的堆 == 优先队列（priority_queue）

操作

1. heap[++size] = x; up(size);
2. heap[1]
3. heap[1] = heap[size]; size–; down(1);//用最后一个元素覆盖第一个元素，然后将最后一个元素向下对位
4. heap[k] = heap[size]; size–; down(k); up(k);//这里有三种情况，向上调位，向下，或者不变，索性我们直接都调用下，总会执行一个
5. heap[k] = x; down(k); up(k);

在初步思路确定后，初始化时， 我们可以直接

for(int i = n / 2; i; i--) down(i) ； //这里由二叉树的性质可知n/2即为倒数第二层，从此处

堆排序代码

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 100010;

int a[N];//保存数组
int n, m;//n个点，求前m小
int r ;//堆得右边界
void down(int u)//调整函数
{
    //t记录最小点的编号
    int t = u;

    //有左儿子，并且左儿子比t节点的值小，更新t
    if(2 * u <= r && a[2 * u] < a[u]) t = 2 * u;

    //有右儿子，并且右儿子比t节点的值小，更新t
    if(2 * u + 1 <= r && a[2 * u + 1] < a[t]) t = 2 * u + 1;

    //如果待调整点不是最小的
    if(u != t)
    {
        //和最小的交换
        swap(a[u], a[t]);

        //递归处理
        down(t);
    }
}

int main()
{
    cin >> n >> m;
    r = n;//开始时，右边界是数组边界

    //读入数据
    for (int i = 1; i <= n; i ++ )
    {
        cin >> a[i];
    }
    
    //从第一个非叶节点开始，从右到左，从下到上处理每个节点
   for(int i = n /2 ; i >= 1; i--)
   {
       down(i);
   }

    //输出m个最小值
    while (m -- )
    {
        //堆顶保存的最小值，输出堆顶
        cout << a[1] << " ";

        //将堆顶和右边界交换
        swap(a[1], a[r]);

        //右边界左移
        r--;

        //从新处理堆顶
        down(1);
    }
}