acwing算法基础课-第二章 数据结构
数据结构
- 单链表
-
- 思想
- 模板
- AcWing 826 单链表（模板题）
- 双链表
-
- 思想
- 模板
- AcWing 837 双链表（模板题）
- 栈
-
- 模板
- AcWing 828 模拟栈（模板题）
- 队列
- 模板
- AcWing 829 模拟队列（模板题）
- 单调栈
-
- 模板
- AcWing 830 单调栈（模板题）
- 单调队列
-
- 模板
- AcWing 154 滑动窗口（模板题）
- KMP
- 思想
- 模板
- AcWing 831 KMP 字符串（模板题）
- Trie
-
- 模板
- AcWing 835 Tire 字符串统计（模板题）
- AcWing 836 最大异或对
- 并查集
-
- 思想
- 模板
- AcWing 836 合并集合(模板题)
- AcWing 837 连通块中点的数量（模板题）
- AcWing 240 食物链（模板题）
- 堆
-
- 思想
- 模板
- AcWing 838 堆排序（模板题）
- AcWing 839 模拟堆（模板题）
- 哈希表
-
- 思想
- 模板
- AcWing 840 模拟散列表（模板题）
- AcWing 841 字符串哈希（模板题）
- c++ STL 简介
单链表
思想
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
用链式存储的话，新建一个结点 new操作 非常慢，数据量比较大时 容易超时，所以在笔试，竞赛中，一般用静态链表,用数组来模拟链表。
优点：这种存储结构，仍需要预先分配一个较大的空间，但在作为线性表的插入和删除操作时不需移动元素，仅需修改指针，故仍具有链式存储结构的主要优点。
缺点：没有解决连续存储分配带来的表长难以确定的问题，需要维护一个空闲链表，而且失去了顺序表随机存取的特性。
对于笔试，竞赛中，数据基本都有范围，所以静态链表的表长范围一般就不会有问题了
模板
// head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点
int head, e[N], ne[N], idx;
// 初始化
void init()
{
head = -1;
idx = 0;
}
// 在链表头插入一个数a
void insert(int a)
{
e[idx] = a, ne[idx] = head, head = idx ++ ;
}
// 将头结点删除，需要保证头结点存在
void remove()
{
head = ne[head];
}
AcWing 826 单链表（模板题）
#include双链表
思想
即在单链表的基础上，在每个结点上多加一个指向左结点的指针域
模板
双链表 —— 模板题 AcWing 827. 双链表
// 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];
}
AcWing 837 双链表（模板题）
#include栈
先进后出
模板
// tt表示栈顶
int stk[N], tt = 0;
// 向栈顶插入一个数
stk[ ++ tt] = x;
// 从栈顶弹出一个数
tt -- ;
// 栈顶的值
stk[tt];
// 判断栈是否为空
if (tt > 0)
{
}
AcWing 828 模拟栈（模板题）
#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)
{
}
AcWing 829 模拟队列（模板题）
#include单调栈
单调递增或单调减的栈，跟单调队列差不多，但是只用到它的一端，利用它可以用来解决一些ACM/ICPC和OI的题目，如RQNOJ 的诺诺的队列等。
模板
常见模型：找出每个数左边离它最近的比它大/小的数
常见模型：找出每个数左边离它最近的比它大/小的数
int tt = 0;
for (int i = 1; i <= n; i ++ )
{
while (tt && check(stk[tt], i)) tt -- ;
stk[ ++ tt] = i;
}
AcWing 830 单调栈（模板题）
#include单调队列
单调队列，即单调递减或单调递增的队列。使用频率不高，但在有些程序中会有非同寻常的作用。
模板
常见模型：找出滑动窗口中的最大值/最小值
常见模型：找出滑动窗口中的最大值/最小值
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;
}
AcWing 154 滑动窗口（模板题）
#includeKMP
思想
KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是通过一个next()函数实现，函数本身包含了模式串的局部匹配信息。KMP算法的时间复杂度O(m+n)
真前缀：一个串除该串自身外的其他前缀。
真后缀：一个串除该串自身外的其他后缀。
模板
求Next数组：
// s[]是模式串，p[]是模板串, n是s的长度，m是p的长度
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];
// 匹配成功后的逻辑
}
}
AcWing 831 KMP 字符串（模板题）
#includeTrie
一般用于存储和查找字符串
模板
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 Tire 字符串统计（模板题）
#includeAcWing 836 最大异或对
查找 i 能匹配出的最大异或数的元素时，每次找与 i 当前位置二进制表示相反数，没有就只能与 i 当前位置二进制表示一样了，查找返回后的数就是能与 i 匹配出的最大异或数的元素。
将整数转换为31位二进制数，从高位到低位。for(i = 30; i >= 0; i-- )每次插入到该二进制当前位置 或者 查找能符合该二进制当前位置要求的二进制表示
#include并查集
思想
并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这一类问题近几年来反复出现在信息学的国际国内赛题中。其特点是看似并不复杂，但数据量极大，若用正常的数据结构来描述的话，往往在空间上过大，计算机无法承受；即使在空间上勉强通过，运行的时间复杂度也极高，根本就不可能在比赛规定的运行时间（1～3秒）内计算出试题需要的结果，只能用并查集来描述。
并查集是一种树型的数据结构，用于处理一些不相交集合（disjoint sets）的合并及查询问题。常常在使用中以森林来表示。
主要操作：
1.初始化：把每个点所在集合初始化为其自身。
通常来说，这个步骤在每次使用该数据结构时只需要执行一次，无论何种实现方式，时间复杂度均为O（n）。
2.查找:查找元素所在的集合，即根节点。
3.合并:将两个元素所在的集合合并为一个集合。
通常来说，合并之前，应先判断两个元素是否属于同一集合，这可用上面的“查找”操作实现。
模板
(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所在的两个集合：
p[find(a)] = find(b);
size[b] += size[a];
(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 合并集合(模板题)
#includeAcWing 837 连通块中点的数量（模板题）
#includeAcWing 240 食物链（模板题）
我们用距离表示动物之间的关系
与根节点的距离%3 = 0 表示与根节点是同类 ，例 a
与根节点的距离%3 = 1 表示吃根节点 ，例b
与根节点的距离%3 = 2 表示被根节点吃 ，例c
则 a 吃 b ， b 吃 c , c 吃 a
#include堆
思想
释义
堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质：
堆中某个结点的值总是不大于或不小于其父结点的值；
堆总是一棵完全二叉树。
将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。
堆是非线性数据结构，相当于一维数组，有两个直接后继。
堆的定义如下：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。
(且)或者(), ()
若将和此次序列对应的一维数组（即以一维数组作此序列的存储结构）看成是一个完全二叉树，则堆的含义表明，完全二叉树中所有非终端结点的值均不大于（或不小于）其左、右孩子结点的值。由此，若序列{k1,k2,…,kn}是堆，则堆顶元素（或完全二叉树的根）必为序列中n个元素的最小值（或最大值）。
算法思想
不必将值一个个地插入堆中，通过交换形成堆。假设一个小根堆的左、右子树都已是堆，并且根的元素名为 ，其左右子结点为 和 ，这种情况下，有两种可能：
（1） 并且 ，此时堆已完成；
（2） 或者 ，此时 应与两个子女中值较小的一个交换，结果得到一个堆，除非 仍然大于其新子女的一个或全部的两个。这种情况下，我们只需简单地继续这种将 “拉下来”的过程，直至到达某一个层使它小于它的子女，或者它成了叶结点。
模板
注意
不能将上溯操作中的while (x / 2 && h[x] < h[x / 2])改成while (x / 2 && h[x] <= h[x/2] )，见acwing 839 模拟堆解析
在堆排序中，不能将上溯操作中的while (x / 2 && h[x] < h[x / 2])改成while (x / 2 && h[x] <= h[x/2] )，那么是否不能将下溯操作中的 h[u * 2] < h[t]改成h[u * 2] <= h[t]呢？
chatgpt 3.4 解答：
在堆排序中，不能将 while (x / 2 && h[x] < h[x / 2]) 改成 while (x / 2 && h[x] <= h[x / 2]) 是因为上面的代码是执行的交换操作，将小的节点往上提，而把等于放上面则会导致重复元素顺序变化。这样就可能不满足大/小顶堆的性质，从而破坏了排序的正确性。
而对于下溯操作中的 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; 进行类似的改动，即将 < 改成<=，不会造成重复元素顺序变化的问题，不会破坏排序的正确性。因为每次下沉操作选择的都是左右子节点中值最小的那个，而等号不会影响这个选择，只会影响交换的次数。
所以，在堆排序中，不能将while (x / 2 && h[x] < h[x / 2])改成while (x / 2 && h[x] <= h[x / 2])，但是可以将 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 * 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; 以优化代码。
我的看法：不能将上溯操作中的while (x / 2 && h[x] < h[x / 2])改成while (x / 2 && h[x] <= h[x/2] )，验证了。
至于下溯操作，本人暂且没有发现问题。
所以我个人推荐上溯下溯都用 < ,不用 <=. 养成习惯。
堆 —— 模板题 AcWing 838. 堆排序, AcWing 839. 模拟堆
// 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;
}
}
AcWing 838 堆排序（模板题）
#includeAcWing 839 模拟堆（模板题）
对于下溯操作的h[x] < h[x / 2]不能改成h[x] <= h[x / 2]
这是因为堆的性质要求子节点必须小于等于其父节点，即 h[x] >= h[x / 2]。将 h[x] < h[x / 2] 改成 h[x / 2] >= h[x] 后，破坏了这个堆的性质，可能导致堆排序算法无法正确执行，或者优先队列中的元素顺序不再按照优先级排序。
我们模拟了一下该题示例，知道这样会造成错误即可。
模拟样例数据：
先展示正确的操作：
输入第二个 I -10 后
h[1] = -10, ph[1] = 1, hp[1] = 1;
h[2] = -10, ph[2] = 2, hp[2] = 2;
输入 D 1 后
h[1] = -10, ph[1] = 2, hp[1] = 2;
h[2] = -10, ph[2] = 1, hp[2] = 1;
输入 C 2 8 后
h[1] = 8
输入 I 6 后
h[1] = 6, ph[3] = 1, hp[1] = 3;
h[2] = 8, ph[2] = 2. hp[2] = 2;
输入 PM ，即 h[1] = 6,正确。
好，现在我们将 h[x] < h[x / 2] 改成 h[x] <= h[x / 2]，第二个输出是 -10，不是 6
输入第二个 I -10 后，交换（正确操作是不会交换的）
h[1] = -10, ph[1] = 2, hp[1] = 2;
h[2] = -10, ph[2] = 1, hp[2] = 1
输入 D 1 时
会交换head_swap(2, 2) ,没什么用,再 size–;
虽然size–，此时为1， 但up()依旧会交换 下标为 1 和 2 的，即
h[1] = -10, ph[1] = 1, hp[1] = 1;
h[2] = -10, ph[2] = 2, hp[2] = 2;
输入 C 2 8 后，
h[2] = 8， 是不是感觉不对了呢,此时h[1] 等于 -10 哦
输入 I 6
h[2] = 6, ph[3] = 2, ph[2] = 3
h[2] < h[1] ,不会交换
输入 PM h[1] = -10
该答案与正确答案不符，因为下溯操作 < 换成 <= 改变了堆的性质。
所以我个人还是推荐上溯下溯都用 < ,不用 <=. 养成习惯。
#include哈希表
思想
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希（Hash）表，函数f(key)为哈希(Hash) 函数。
模板
一般哈希 —— 模板题 AcWing 840. 模拟散列表
(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;
}
字符串哈希 —— 模板题 AcWing 841. 字符串哈希
核心思想：将字符串看成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];
}
AcWing 840 模拟散列表（模板题）
#includeAcWing 841 字符串哈希（模板题）
#includec++ 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, 优先队列，默认是大根堆
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位取反