数据结构（二）——Trie、并查集、堆

前言

重学算法第5天，希望能坚持打卡不间断，从基础课开始直到学完提高课。

预计时长三个月内，明天再来！肝就完了
2月17日,day05 打卡

今日已学完y总的
算法基础课-2.3-第二章 数据结构（二）

共5题，知识点如下
Trie（单词查找树）：Trie字符串统计
并查集：合并集合、连通块中点的数量
堆：堆排序、模拟堆

Trie(单词查找树)

Trie的存储

把所有结尾都标记一下，表示以当前这个位置结尾的是有一个单词的

查找

d上没标记，所以不存在以d结尾该单词。abcd 查找失败

模板

int son[N][26], cnt[N], idx;
// 0号点既是根节点，又是空节点
// son[][]存储树中每个节点的子节点
// cnt[]存储以每个节点结尾的单词数量

// 插入一个字符串
void insert(char *str)
{
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!son[p][u]) son[p][u] = ++ idx;
        p = son[p][u];
    }
    cnt[p] ++ ;
}

// 查询字符串出现的次数
int query(char *str)
{
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!son[p][u]) return 0;
        p = son[p][u];
    }
    return cnt[p];
}

AcWing 835. Trie字符串统计

思路：先将插入和查询操作写出再处理输入输出

#include <iostream>

using namespace std;

const int N = 100010;

// son：每个节点的子节点, cnt：以当前点结尾的有多少个，idx：当前用到的下标
int son[N][26], cnt[N],idx; // 下标是0的点,既是根节点,又是空节点(如果一个点没有子节点,让其指向0)
char str[N];

void insert(char str[]) {
    int p = 0;
    for (int i = 0; str[i]; i++) { //从前往后遍历,C++中字符串结尾是'\0',str[i]到结尾处,值为0,就结束了
        int u = str[i] - 'a'; // 将当前字母对应的子节点编号找出来(a-z映射成0-25)
        if (!son[p][u]) son[p][u] = ++ idx; // 如果当前点(p)不存在这个字母(u),就创建出来
        p = son[p][u]; // 走到下一个点
    }
    // 结束时p对应的点就是最后一个点
    cnt[p] ++; // 以该点结尾的单词多了一个
}

// 查询操作,返回字符串出现多少次
int query(char str[]) {
        int p = 0;
    for (int i = 0; str[i]; i++) { 
        int u = str[i] - 'a'; 
        if (!son[p][u]) return 0; //如果不存在该子节点,说明不存在该单词
        p = son[p][u]; 
    }
    return cnt[p]; //返回以p结尾的单词数量
}

int main() {
    int n;
    scanf("%d", &n);
    while (n--) {
        char op[2];
        scanf("%s%s", op, str);
        if (op[0] == 'I') insert(str);
        else printf("%d\n", query(str));
    }
    return 0;
}

下标是x的点
son[x][0]：son[x]的第0个儿子 (从0开始数)
son[x][1]：son[x]的第1个儿子
cnt(x)：存的是以x结尾的单词数量是多少个

并查集

笔试面试常考算法

特点：思维性较强，代码较短

并查集的作用：
可以快速的
1.将两个集合合并
2.询问两个元素是否在一个集合当中
并查集能在近乎O(1)时间内完成1和2的操作；

普通暴力做法
belong[x]= a
if (belong[x]== belong[y]) O(1)

但合并操作用时很长
如x有一千个字符，y有两千个
则最少要一千次

并查集

并查集最本质的其实只要记住find()函数即可
基本原理：

优化：路径压缩
将所有搜过的点，都指向根节点

过程：一路找父节点的祖宗节点
回溯时将x及上面的都指向祖宗节点

模板

(1)朴素并查集：

    int p[N]; //存储每个点的祖宗节点

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ ) p[i] = i;

    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);


(2)维护size的并查集：

    int p[N], size[N];
    //p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        size[i] = 1;
    }

    // 合并a和b所在的两个集合：
    size[find(b)] += size[find(a)];
    p[find(a)] = find(b);


(3)维护到祖宗节点距离的并查集：

    int p[N], d[N];
    //p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x)
        {
            int u = find(p[x]);
            d[x] += d[p[x]];
            p[x] = u;
        }
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        d[i] = 0;
    }

    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);
    d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量

AcWing 836. 合并集合

#include <iostream>

using namespace std;

const int N = 100010;

int n, m; 
// 初始时每个集合只有一个点,让p[x]等于x, x就是树根
int p[N];// 存的是每个元素的父节点是谁

int find(int x) { //返回x的祖宗结点 + 路径压缩
    // 如果x不是根节点,就让他指向他父亲的祖宗结点
    // 会往上一直找，直到到了根节点，然后回溯的时候，将从x开始每个点都指向祖宗节点
    if(p[x] != x) p[x] = find(p[x]); 
    return p[x]; // 返回父节点
}

int main() {
    scanf("%d%d", &n, &m);
    // 初始化,将所有结点的p值赋给自己
    for (int i = 1; i <= n; i++) p[i] = i;
    while (m --) {
        char op[2]; //用op[2]的原因: scanf读字符串(%s)会自动忽略空格和回车,
        int a, b;   //如果用字符,则scanf读字符(%c)可能会读空格回车等字符,太麻烦了
        scanf("%s%d%d", op, &a, &b); // 因此建议用scanf读一个字母依然用字符串(%s)的形式
        if (op[0] == 'M') p[find(a)] = find(b); // 将a的祖宗结点的父节点指向b的祖宗结点,即将A插到B的根节点上
        else {
            if (find(a) == find(b)) puts("Yes"); // a和b的祖宗结点相等,即都在同一个集合中
            else puts("No");
        }
    }
    return 0;
}

AcWing 837. 连通块中点的数量

合并的时候，想要动态的知道，每个集合当前的元素个数

连通块：如果能从A走到B，也能从B走到A，就说AB是连通的

样例：建议画个图

在两个连通块连一条边，其实就是把两个集合合并

所以前两个操作与上题一样，多了一个额外操作
统计一下每个集合里，点的数量

维护点数量其实很简单，在初始化的时将每个集合的元素个数赋成1
然后在合并的时候
在新的根节点上 加上 当前这棵树里面数的个数即可

#include <iostream>

using namespace std;

const int N = 100010;

int n, m; 
//error: reference to 'size' is ambiguous 修改sizes
int p[N], sizes[N]; // size：每个集合里面点的数量 (只看根节点的size：将一棵树的根节点插到另一颗的根节点上)

int find(int x) { 
    if(p[x] != x) p[x] = find(p[x]); 
    return p[x]; 
}

int main() {
    scanf("%d%d", &n, &m);
 
    for (int i = 1; i <= n; i++) {
        p[i] = i;
        sizes[i] = 1; // 最开始每个集合里只有1个点
    }
    while (m --) {
        char op[2]; 
        int a, b;   
        scanf("%s", op); 
        if (op[0] == 'C') {
            scanf("%d%d", &a, &b);
            if (find(a) == find(b)) continue; // 如果a和b已经在一个集合里了，后面操作就不进行了
            sizes[find(b)] += sizes[find(a)];
            p[find(a)] = find(b);
        }
        else if (op[1] == '1') // Q1
        {   
            scanf("%d%d", &a, &b);
            if (find(a) == find(b)) puts("Yes"); 
            else puts("No");
        } 
        else{ // Q2 询问点 a 所在连通块中点的数量
            scanf("%d", &a);
            printf("%d\n",sizes[find(a)]); // 先找到a的根节点，然后返回size
        }
    }
    return 0;
}

堆

4和5stl里的堆无法直接实现

堆是一颗完全二叉树

除了最后一层，上面节点都是非空的
最后一层是从左往右依次排布的

小根堆

每个点都==小于等于(<=) ==左右儿子
根节点即是最小值

存储是用一维数组存

down(x)：下移

将1换成6

换到不能交换后整个堆就又成小跟堆了

down(x)对应的就是，如果把某个值变大了，就要把它往下移（小根堆），越大的数越往下压，因此变大了就往下移

up(x)：上移

把5换成2

比父节点小就交换，直到不能换为止

up(x) 如果把某个值变小了，就要把它往上移

用up和down实现上面5个操作

1. 在整个堆的最后一个位置插入x，然后不断将x上移
2. 根节点
3. 将最后一个节点的值赋给根节点，删掉最后一个点，再对根节点执行down操作

原因：数组删掉第一个点很麻烦，但是很容易删掉最后一个点

4. 跟3类似，最后看换上去的值的大小决定指向down还是up

可以都写上，只会走一个

5. 跟4一样的，只是将值变成x

下标从1开始，防止0的左右儿子还是0
如0的左耳子，是2倍0，结果还是0，不太方便
从1开始更好用

down和up操作都与树的高度有关，时间复杂度为log(N)
求最小值是O(1)
插入和删除都是O(logN)

模板

// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
// ph[k]存储第k个插入的点在堆中的位置
// hp[k]存储堆中下标是k的点是第几个插入的
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(h[a], h[b]);
}

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

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

// O(n)建堆
for (int i = n / 2; i; i -- ) down(i);

AcWing 838. 堆排序

时间复杂度O(N)的建堆方式

从n/2开始down()
即从倒数第二层(n/2)开始，需要down() 1次，
倒数第三层(n/4)需要down() 2次，·······,每次操作都加起来

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int n, m;
 //  error: reference to 'size' is ambiguous：依然是将size改为sizes
int h[N], sizes; //h：heap，size：heap中有多少元素

void down(int u) {
    int t = u;
    // 用t表示三个点中的最小值
    if (u * 2 <= sizes && h[u * 2] < h[t]) t= u * 2; // 如果左儿子存在且他的值比h(t)小,t等于左儿子
    if (u * 2 + 1 <= sizes && h[u * 2 + 1] < h[t]) t= u * 2 + 1; // 如果右儿子存在且他的值比h(t)小,t等于右儿子
    // 最后t中存的就是三个点中最小值的编号
    if (u != t) { // 根节点不是最小值就交换一下
        swap(h[u], h[t]);
        down(t);
    }
}

void up(int u) {
    while (u / 2 && h[u / 2] > h[u]) { // 父节点存在且它的值比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]);
    sizes = n;
    
    for (int i = n / 2; i; i--) down(i); //O(N)操作建堆
    
    while (m --) {
        printf("%d ", h[1]); // 输出堆顶后需要删掉
        h[1] = h[sizes];
        sizes--;
        down(1);
    }
    
    return 0;
}

AcWing 839. 模拟堆

交换后需要更换互换指向，一一对应

下图中

原本是蓝色线对蓝色线 ,堆中的点a和b交换–> swap(h[a],h[b])

ph[i] 和 ph[j] 也要交换指向才会指向正确的点
i 的值是hp[a]，j的值是hp[b]
==> swap(ph[hp[a]], ph[hp[b]]);

堆中的点a和b的指回来的(hp)，也要改 ==>swap(hp[a],hp[b]);

#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;

const int N = 100010;

int n, m;
 
int h[N], sizes; 
// ph[k]存的是第k个插入的数下标是多少
// hp[k]堆里的某个点是第几个插入点
// 既要从第几个插入点找堆内到元素，又要堆里的元素找回来，所以要一一对应
int ph[N], hp[N];

// 存储映射，不常用
void heap_swap(int a, int b) {
    // 需要把所有指向都交换，继续一一对应
    swap(ph[hp[a]], ph[hp[b]]);  // ph：从下标映射到堆
    swap(hp[a],hp[b]);  //hp：从堆里映射回下标
    swap(h[a],h[b]);     //交换堆内元素
}

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

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

int main() {
    int n, m = 0;
    scanf("%d", &n);
    while (n --) {
        char op[10];
        int k, x;
        scanf("%s",op);
        if (!strcmp(op, "I")) { // 插入一个数 x；
            scanf("%d", &x);
            sizes++; //堆里要多一个元素
            m++; // m表示第几个插入的数
            
            ph[m] = sizes; // 第m个插入的数在堆中的sizes位置
            hp[sizes] = m; // 堆里面sizes这个数对应的是m
            
            h[sizes] = x;
            up(sizes); // 插入到堆尾，需要向上走
        }
        // strcmp(str1,str2),若str1=str2，则返回零；若str1>str2，则返回正, <返回负数
        else if (!strcmp(op, "PM")) printf("%d\n", h[1]);//输出当前集合中的最小值
        else if (!strcmp(op, "DM")) {
            heap_swap(1, sizes); // 将最后一个的值与最小值交换
            sizes--; // 删除最后一个
            down(1); // 下沉
        }
        else if (!strcmp(op, "D")) { //删除第 k 个插入的数；
            scanf("%d", &k);
            k = ph[k]; // 找到k在堆里的位置
            heap_swap(k, sizes);
            sizes--;
            down(k), up(k); // 最多只会执行一个
        } else { // 修改第 k 个插入的数，将其变为 x；
            scanf("%d%d", &k, &x);
            k = ph[k]; // 先找个第k个插入的数 在堆里的位置
            h[k] = x;  // 直接修改成x
            down(k), up(k);
        }
    } 
    
    return 0;
}