前言

重学算法第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~nfor (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~nfor (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~nfor (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个操作

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

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

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

可以都写上，只会走一个

跟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这个数对应的是mh[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;  // 直接修改成xdown(k), up(k);}} return 0;
}

数据结构（二）——Trie、并查集、堆相关推荐

2372: 连通块(blocks) 个人认为二维并查集为什么TLE？
题目链接:http://acm.upc.edu.cn/problem.php?id=2372 2372: 连通块(blocks) Time Limit: 1 Sec Memory Limit: 64 ...
数据结构与算法（十二）并查集(Union Find)及时间复杂度分析
本文主要包括以下内容: 并查集的概念并查集的操作并查集的实现和优化 Quick Find Quick Union 基于size的优化基于rank的优化路径压缩优化并查集的时间复杂度并查集的 ...
[学习笔记]可持久化数据结构——数组、并查集、平衡树、Trie树
可持久化:支持查询历史版本和在历史版本上修改可持久化数组主席树做即可. [模板]可持久化数组(可持久化线段树/平衡树) 可持久化并查集可持久化并查集主席树做即可. 要按秩合并.(路径压缩每次建 ...
数据结构与算法——并查集(不相交集合)
文章目录认识并查集并查集解析基本思想如何查看a,b是否在一个集合? a,b合并,究竟是a的祖先合并在b的祖先上,还是b的祖先合并在a上? 其他路径压缩? 代码实现结语认识并查集对于并查集 ...
vb6实现union数据结构_数据结构与算法——并查集(不相交集合)
首发公众号:bigsai 认识并查集对于并查集(不相交集合),很多人会感到很陌生,没听过或者不是特别了解.实际上并查集是一种挺高效的数据结构.实现简单,只是所有元素统一遵从一个规律所以让办事情的效率 ...
高级数据结构与算法 | 并查集(Union-Find)
文章目录并查集的原理并查集的实现例题并查集的原理在一些应用问题中,需要将n个不同的元素划分成一些不相交的集合.开始时,每个元素自成一个单元素集合,然后按一定的规律将归于同一组元素的集合合并 ...
C/C++数据结构——虚虚实实（并查集欧拉路）
题目描述震为雷,临危不乱,亨通畅达:巽为风,柔顺伸展,厚载万物. 震卦:洊雷,震,君子以恐惧修省.一口金钟在淤泥,人人拿着当玩石,忽然一日钟悬起,响亮一声天下知. 巽卦:随风,巽,君子以申命行事.一 ...
数据结构进阶之并查集
1.初探并查集例题1:AcWing 237.程序自动分析这题的思路其实比较好想,只要先考虑所有等于的情况并合并,然后再看不等于的情况,看是否出现矛盾即可.但是这题显然是需要离散化的,但是离散化也很 ...
数据结构——不相交集（并查集）
目的:解决等价问题. 表示方法:森林,底层实现用数组主要操作:find().union() 优化手段: ①find()时路径压缩 ②union()时按规模合并.按树高合并(依据情况而定) Java实 ...
基础数据结构(二):字典树、并查集、堆、哈希表、字符串的哈希方式、STL的常见容器及其接口
文章目录一.字典树Trie 1 原理 2 Trie字符串统计 3 [LeetCode 208. 实现 Trie (前缀树)](https://leetcode-cn.com/problems/imp ...

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

前言