AcWing 算法基础课笔记 2.数据结构
AcWing 算法基础课笔记 2.数据结构
- 链表与邻接表：树与图的存储
-
- 链表
-
- 数组模拟单链表
-
- 模拟方法
- 单链表模板
- 数组模拟双链表
-
- 模拟方法
- 双链表模板
- 栈与队列：单调队列、单调栈
-
- 用数组模拟栈
-
- 栈模板
- 用数组模拟队列
-
- 队列模板
- KMP
-
- KMP模板
- Tire 字典树
-
- 基本思想
- Tire 树模板
- 并查集
-
- 基本原理
- 并查集模板
- 并查集例题
- 堆
-
- 基本原理
- 堆模板
- 哈希表
-
- 一般哈希
- 字符串哈希
- 哈希表模板
-
- 一般哈希表
- 字符串哈希
- 常用 C++ STL
链表与邻接表：树与图的存储
链表
使用结构体加指针的方式实现链表非常慢，所以笔试题一般不用，这里使用数组模拟链表的方式。
主要讲以下两点：
数组模拟单链表
模拟方法
单链表在算法题、笔试里用的最多的是邻接表
邻接表最常见的应用就是：存储图和树
模拟方式如下：
使用 e[ ] 存储值 .val，ne[ ] 存储指针指向下一位 .next 。
单链表模板
// head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点
int head, e[N], ne[N], idx;
// 初始化
void init()
{
head = -1;
idx = 0;
}
// 在链表头插入一个数a
void insert_to_head(int a)
{
e[idx] = a, ne[idx] = head, head = idx ++ ;
}
// 将x插到下标是k的点后面
void insert(int k, int x)
{
e[idx] = x, ne[idx] = ne[k], ne[k] = idx ++ ;
}
// 将头结点删除，需要保证头结点存在
head = ne[head];
// 将下标是k的点后面的点删掉
void remove(int k)
{
ne[k] = ne[ne[k]];
}
数组模拟双链表
模拟方法
双链表主要是用来优化某些问题
不设置 head 和 tail ，设置 0 和 1 为 head 和 tail
l [ ] 标志左指针，r [ ] 表示右指针。
双链表模板
// e[]表示节点的值，l[]表示节点的左指针，r[]表示节点的右指针，idx表示当前用到了哪个节点
int e[N], l[N], r[N], idx;
// 初始化
void init()
{
//0是左端点，1是右端点
r[0] = 1, l[1] = 0;
idx = 2;
}
// 在节点a的右边插入一个数x
void insert(int a, int x)
{
e[idx] = x;
l[idx] = a, r[idx] = r[a];
l[r[a]] = idx, r[a] = idx ++ ;
}
// 删除节点a
void remove(int a)
{
l[r[a]] = l[a];
r[l[a]] = r[a];
}
栈与队列：单调队列、单调栈
用数组模拟栈
先进后出，栈本身较简单，不用细讲。
单调栈使用如下例题，可将时间复杂度降至 O(n)：
#include 栈模板
1.普通栈
// tt表示栈顶
int stk[N], tt = 0;
// 向栈顶插入一个数
stk[ ++ tt] = x;
// 从栈顶弹出一个数
tt -- ;
// 栈顶的值
stk[tt];
// 判断栈是否为空
if (tt > 0)
{
}
2.单调栈
常见模型：找出每个数左边离它最近的比它大/小的数
int tt = 0;
for (int i = 1; i <= n; i ++ )
{
while (tt && check(stk[tt], i)) tt -- ;
stk[ ++ tt] = i;
}
用数组模拟队列
先进先出，hh 表示头部，tt 表示尾部，从 hh 弹出，从 tt 插入
单调队列使用如下例题：
#include 队列模板
1.普通队列
// hh 表示队头，tt表示队尾
int q[N], hh = 0, tt = -1;
// 向队尾插入一个数
q[ ++ tt] = x;
// 从队头弹出一个数
hh ++ ;
// 队头的值
q[hh];
// 判断队列是否为空
if (hh <= tt)
{
}
2.循环队列
// hh 表示队头，tt表示队尾的后一个位置
int q[N], hh = 0, tt = 0;
// 向队尾插入一个数
q[tt ++ ] = x;
if (tt == N) tt = 0;
// 从队头弹出一个数
hh ++ ;
if (hh == N) hh = 0;
// 队头的值
q[hh];
// 判断队列是否为空
if (hh != tt)
{
}
3.单调队列
常见模型：找出滑动窗口中的最大值/最小值
int hh = 0, tt = -1;
for (int i = 0; i < n; i ++ )
{
while (hh <= tt && check_out(q[hh])) hh ++ ; // 判断队头是否滑出窗口
while (hh <= tt && check(q[tt], i)) tt -- ;
q[ ++ tt] = i;
}
KMP
移步CSDN站内各种详解。
想写明白太耗时间。
人懒摸鱼了。
KMP模板
// s[]是长文本，p[]是模式串，n是s的长度，m是p的长度
求模式串的Next数组：
for (int i = 2, j = 0; i <= m; i ++ )
{
while (j && p[i] != p[j + 1]) j = ne[j];
if (p[i] == p[j + 1]) j ++ ;
ne[i] = j;
}
// 匹配
for (int i = 1, j = 0; i <= n; i ++ )
{
while (j && s[i] != p[j + 1]) j = ne[j];
if (s[i] == p[j + 1]) j ++ ;
if (j == m)
{
j = ne[j];
// 匹配成功后的逻辑
}
}
Tire 字典树
基本思想
高效地存储和查找字符串
集合的数据结构
Tire 树的存储：
Tire 树的查找：
例如 查找是否存在 abcd
如下图，查到 d 的时候，abcd 虽然都有，但是 d 处并未打标记，所以不存在 abcd 这个字符串
Tire 树模板
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];
}
并查集
基本原理
首先，并查集是用来干嘛的？
并查集可以在近乎 O(1) 的时间内完成以下两个操作
- 将两个集合合并
- 询问两个元素是否在一个集合当中
原理：每个集合用一棵树来表示。树根的编号就是整个集合的编号。每个节点存储它的父节点，p[x] 表示 x 的父节点。
问题1：如何判断树根：if (p[x] == x)
问题2：如何求x的集合编号： while (p[x] != x) x = p[x];
问题3：如何合并两个集合：将一个集合树的根节点插入为另一个集合树根节点的儿子。设 p[x] 是 x 的集合编号，p[y] 是 y 的集合编号。p[x] = y。
优化点：路径压缩
一旦找到某一个 x 的根节点，将该路径上的所有节点都指向根节点。所以只需要搜索一次，下次就不用再搜索了，就可以达到 O(1)。
还有一个按秩合并的优化，但一般用不到。
并查集模板
(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)的偏移量
并查集例题
1.朴素并查集
#include 2.维护 size 的并查集
#include 堆
基本原理
这里是指用于如何手写一个堆，而不是STL中的堆。
实现五个基本使用操作：
- 插入一个数：heap[++size] = x; up(size);
- 求集合当中的最小值：heap[1];
- 删除最小值：heap[1] = heap[size]; size–; down(1);
- 删除任意一个元素：heap[k] = heap[size]; size–; down(k); up(k);
- 修改任意一个元素：heap[k] = heap[size]; down(k); up(k);
除了 2 是 O(1) 的，其他是 O(logn) 的。
堆的存储：
按照小根堆（最小堆）来存储。
使用一维数组存储，下标从 1 开始。
若父亲节点为 x ，则左儿子为 2x，右儿子为 2x+1。
两个基本操作：
down(x)：将一个节点向下移
实现逻辑：与较小的儿子交换
up(x)：将一个节点向上移
实现逻辑：与父节点比较，若小于父节点则交换
在将一个数组建堆的时候，若一个个插入堆，时间复杂度为 O(nlogn)，而使用for (int i= n /2; i; i-- ) down(i); 可实现 O(n) 建堆。
堆模板
// 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);
哈希表
一般哈希
将一个很大的值域映射到 0~N 的空间上，一般 N 为 105 或 106。
一般映射是使用取模的方法，且 mod 的数一般取质数，该质数一般离 2 的整次幂尽可能的远，因为这样取的话，冲突的可能性最小。
这里取 x mod 大于105的质数，第一个为 100003，主要区别在于映射时的冲突如何处理。
一般只有添加和查找两个操作，很少会有删除的操作。
存储结构
1 开放寻址法
只开了一个一维数组没有开链表，一般长度为题目数据范围的 2 ~ 3 倍（经验范围，这样发生冲突的可能性较低）。
处理冲突：h(x) = k，若该位置已有数值，则后移一位，直至移至一个空位存储。
添加：h(x) = k，有数就后移，没数就存储，若有相同数则无需操作。
查找：h(x) = k，当前位有数判断是否为 x ，不是就后移，直至找到或者遇到空位，遇到空位说明不存在 x 。
删除：先查找，找到后将该数据打标记，而不是真的从表中删除。
2 拉链法
开一个一维数组（例如 0 ~ 105 - 1）存储所有的值，数组中的每一位存储 e[ ] 和 ne[ ]，因为把每一位看作一个槽，里面放一个链表，理想的情况下每个槽只有一个数，冲突的时候会需要链表。
对于 mod 后相同结果的值，存放在相同位置的链表中，如下图：
添加和查找：h(x)
删除：使用一个布尔变量，为该数打一个标记。而不是真的从哈希表中删除该数。
字符串哈希
指字符串前缀哈希法。
把每一个前缀的哈希值求出：
求哈希值的方法：
- 将字符串看作是一个 P 进制的数
- 将该 P 进制的数改为 10 进制数
- 模 Q 来将该数字映射到 0 ~ P-1 的区间
注意：
- 一般不能映射成 0 。（原因：可能会将不同的字符串映射为相同的值。如，若 A 为 0 ，映射后为 0 。AA 也为 0 ，映射后同样是 0）
- 一般取 P = 131 或 13331 ，Q = 264，基本不会出现冲突。
使用前缀和计算某一段的 hash 值：
小技巧：使用 unsigned long long 存储哈希值 h[ ] ，溢出后相当于取模，就不用 mod 264。
哈希表模板
一般哈希表
(1) 拉链法
int h[N], e[N], ne[N], idx;
// 向哈希表中插入一个数
void insert(int x)
{
int k = (x % N + N) % N;
e[idx] = x;
ne[idx] = h[k];
h[k] = idx ++ ;
}
// 在哈希表中查询某个数是否存在
bool find(int x)
{
int k = (x % N + N) % N;
for (int i = h[k]; i != -1; i = ne[i])
if (e[i] == x)
return true;
return false;
}
(2) 开放寻址法
int h[N];
// 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
int find(int x)
{
int t = (x % N + N) % N;
while (h[t] != null && h[t] != x)
{
t ++ ;
if (t == N) t = 0;
}
return t;
}
字符串哈希
核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果
typedef unsigned long long ULL;
ULL h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64
// 初始化
p[0] = 1;
for (int i = 1; i <= n; i ++ )
{
h[i] = h[i - 1] * P + str[i];
p[i] = p[i - 1] * P;
}
// 计算子串 str[l ~ r] 的哈希值
ULL get(int l, int r)
{
return h[r] - h[l - 1] * p[r - l + 1];
}
常用 C++ STL
vector, 变长数组，倍增的思想
size() 返回元素个数
empty() 返回是否为空
clear() 清空
front()/back()
push_back()/pop_back()
begin()/end()
[]
支持比较运算，按字典序
pair<int, int>
first, 第一个元素
second, 第二个元素
支持比较运算，以first为第一关键字，以second为第二关键字（字典序）
string，字符串
size()/length() 返回字符串长度
empty()
clear()
substr(起始下标，(子串长度)) 返回子串
c_str() 返回字符串所在字符数组的起始地址
queue, 队列
size()
empty()
push() 向队尾插入一个元素
front() 返回队头元素
back() 返回队尾元素
pop() 弹出队头元素
priority_queue, 优先队列，默认是大根堆
size()
empty()
push() 插入一个元素
top() 返回堆顶元素
pop() 弹出堆顶元素
定义成小根堆的方式：priority_queue<int, vector<int>, greater<int>> q;
stack, 栈
size()
empty()
push() 向栈顶插入一个元素
top() 返回栈顶元素
pop() 弹出栈顶元素
deque, 双端队列
size()
empty()
clear()
front()/back()
push_back()/pop_back()
push_front()/pop_front()
begin()/end()
[]
set, map, multiset, multimap, 基于平衡二叉树（红黑树），动态维护有序序列
size()
empty()
clear()
begin()/end()
++, -- 返回前驱和后继，时间复杂度 O(logn)
set/multiset
insert() 插入一个数
find() 查找一个数
count() 返回某一个数的个数
erase()
(1) 输入是一个数x，删除所有x O(k + logn)
(2) 输入一个迭代器，删除这个迭代器
lower_bound()/upper_bound()
lower_bound(x) 返回大于等于x的最小的数的迭代器
upper_bound(x) 返回大于x的最小的数的迭代器
map/multimap
insert() 插入的数是一个pair
erase() 输入的参数是pair或者迭代器
find()
[] 注意multimap不支持此操作。 时间复杂度是 O(logn)
lower_bound()/upper_bound()
unordered_set, unordered_map, unordered_multiset, unordered_multimap, 哈希表
和上面类似，增删改查的时间复杂度是 O(1)
不支持 lower_bound()/upper_bound()， 迭代器的++，--
bitset, 圧位
bitset<10000> s;
~, &, |, ^
>>, <<
==, !=
[]
count() 返回有多少个1
any() 判断是否至少有一个1
none() 判断是否全为0
set() 把所有位置成1
set(k, v) 将第k位变成v
reset() 把所有位变成0
flip() 等价于~
flip(k) 把第k位取反
附
有些较复杂的懒得写特别细，建议AcWing学一下y总的课效果更好。
以上截图和模板均来源：AcWing
链接：https://www.acwing.com/blog/content/404/