AcWing第二章算法模板总结——数据结构
一、链表与邻接表
二、栈与队列
三、KMP
四、Trie树
五、并查集
六、堆
七、哈希
八、C++ STL简介
一、链表与邻接表
前提注明：这里均使用数组实现，因为占用空间小，且访问快。实际面试场合要是用结构体，动态实现。
（一）单链表
（1）邻接表作用：存储图和树
核心实现部分：
1、设置单链表必要元素head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点
2、初始化函数init()，其中head = -1，idx = 0
3、编写插入函数，插入分为头插和随机插
头插：将新节点插入到头结点后面。首先将新结点的数据存进e中，e[idx]=new。第二步将新点的ne指向原来head指向的下一个结点位置。第三步head指回到新的头结点。最后idx自增。
随机插：将新节点插入到索引为k的点的后面。首先将新结点的数据存进e中，e[idx]=new;然后将新结点的下一个指向改为k节点的下一个指向，ne[idx] = ne[k];第三步将k结点的ne指向新结点；最后idx自增。
4、编写删除函数
分两种情况，一种是删除索引为k的节点，一种是删除头结点。前者直接将该结点k的ne指向厚厚一个，即ne[k]=ne[ne[k]]；后者将头结点删除，直接就是head=ne[head]即可。
代码实现：
// 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];
}
（二）双链表
实现和单链表类似，只是多了一个指向左边的数组l[]，逻辑基本不变，只变了少部分。
核心实现部分：
1、所需元素e[]表示节点的值，l[]表示节点的左指针，r[]表示节点的右指针，idx表示当前用到了哪个节点
搭建步骤：
1、init初始化
2、编写插入函数（那边插入都可以，需要注意实现插入的时候，必须严格检查是否链接完全。不可丢失指针）
3、编写删除函数
代码：
// 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];
}
二、栈与队列
（一）普通栈
特点：先进后出，可以想象成一个装羽毛球的容器
这里使用数组模拟。
代码：
// tt表示栈顶
int stk[N], tt = 0;
// 向栈顶插入一个数
stk[ ++ tt] = x;
// 从栈顶弹出一个数
tt -- ;
// 栈顶的值
stk[tt];
// 判断栈是否为空，如果 tt > 0，则表示不为空
if (tt > 0)
{
}
（二）普通队列
特点：先进先出，可以想象成排队过安检
1、普通队列
// hh 表示队头，tt表示队尾
int q[N], hh = 0, tt = -1;
// 向队尾插入一个数
q[ ++ tt] = x;
// 从队头弹出一个数
hh ++ ;
// 队头的值
q[hh];
// 判断队列是否为空，如果 hh <= tt，则表示不为空
if (hh <= tt)
{
}
（三）循环队列
模板代码：
// 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];
// 判断队列是否为空，如果hh != tt，则表示不为空
if (hh != tt)
{
}
（四）单调栈
1、题型：给一个序列，找出每个元素的左边（右边）离他最近的，且数值大小比它小（大）的数在什么地方（索引位置），
适用条件：找出每个数左边离它最近且比它数值小(大)的数
2、暴力做法：
默认序列长度为n，直接两层循环，第一层i从0取到n，第二层j从i-1取到0。遍历找出每一趟趟最小（大）元素。时间复杂度为O（n²）。
3、优化做法：
找到暴力做法和我们寻找的结果之间有什么可以减少运算或者遍历的点，然后通过减少遍历次数来减小时间复杂度，以这道题为例，我们观察到如果一个元素a在当前元素b的左边且数值比当前元素b小，则此时a永远不会被输出，所以直接将a出栈，用此操作循环处理当前栈，可以保持栈中始终是递增的。而且栈顶元素就是符合要求的在我左边且比我小的元素。
首先明确我们输出的是每一个元素对应的离它左侧最近的且数值比它小的元素，所以我们这个单调栈定义就是。当前状态下栈顶存储的就是符合离我左侧最近的且数值比我小的元素的索引号。其中tt代表栈顶，stk[N]就是这个单调栈。
至于如何维护这个单调栈：首先每读入一个新元素x的时候，先使用while判断栈是否为空，以及栈顶元素是否大于等于这个新元素x,如果不为空且栈顶元素大于x，此时将栈顶元素出栈。直到栈空或者找到第一个小于x的栈顶元素，如果栈空了，则没有符合要求的索引，否则栈顶就是对应我们寻找的离这个新元素x左侧最近的且数值比新元素x小的元素，最后将该元素入栈
最核心的地方：单调栈和单调队列，其实就是先用暴力做法写出，然后思考暴力做法中栈和队列那些元素是没有用的，然后把这些没有用的元素全部删掉，再看看有没有单调性
模拟（这里使用数组模拟栈）：
代码：
#include（4）scanf和cin的联系：单纯的cin,cout要比scanf慢十倍左右，如果输入输出很多且数据范围很大的的话，建议使用scanf
//以下两行代码都可以加速代码运行速度
cin.tie(0);
ios::sync_with_stdio(false);
单调栈模板代码：
常见模型：找出每个数左边离它最近的比它大/小的数
核心：什么时候应该让数据出栈。维护单调栈的性质
int tt = 0;
for (int i = 1; i <= n; i ++ )
{
while (tt && check(stk[tt], i)) tt -- ;
stk[ ++ tt] = i;
}
（五）单调队列
154.滑动窗口最大最小值
题目描述
在一串长度为n序列中，使用大小为k的滑动窗口在序列上滑动，输出滑动窗口每一时刻下的最大元素和最小元素。以下先以寻找最小元素为例子。
输入格式
第一行包含两个整数n和k。n是数的个数，k是滑动窗口大小。
下面输入n个数据。
输出格式
输出窗口中最大值和最小值
输入样式：
7 3
1 3 -1 -3 5 3 6 7
输出样式：
-1 -3 -3 -3 3 6
1、分析暴力做法，每一个状态下使用循环遍历整个窗口，找出最大最小值，时间复杂度为O（n*k）
2、优化做法：使用单调队列，其定义就是在当前状态下，这个单调队列存放的是当前元素之前出现过的元素对应的索引，且大小关系必须是队尾的元素大于队头的元素，即保持队列从队头到队尾递增！所以此时队列头就是最小的元素。
如何维护这个单调队列：如果队列尾元素和待加入的新元素无法保持递增，则会破坏队列单调增的性质，将破坏平衡的元素（队列尾元素)出队列，即tt–。此操作可以理解成，如果队列不为空，且当前这个新元素x一定小于队列尾元素，且x这个元素生命周期比队列尾这个元素长，也意味着只要新元素x不出队列，此时的队列尾元素永无出头之日（不会被输出)，然后将队列尾元素出队列。最后将当前元素x入队列。此时队列仍然保持递增。（因为不递增的已经被出队列了，当前窗口的最小元素就是队列头元素！
最核心的地方：单调栈和单调队列，其实就是先用暴力做法写出，然后思考暴力做法中栈和队列那些元素是没有用的，然后把这些没有用的元素全部删掉，再看看有没有单调性。
核心：
1、队列q中只存放滑动窗口内的元素的索引号
2、队列头hh什么时候往后移动。如果滑动窗口的左边缘(i - k + 1)在队列头(q[hh])的右侧，hh ++
3、队列尾tt什么时候前移。如果待加入元素a[i]和队列头元素a[q[hh]]存在什么关系的时候，才让tt –
模拟（这里使用数组模拟队列）：
题目代码：
#include模板代码：
常见模型：找出滑动窗口中的最大值/最小值
核心：1、队列q中只存放滑动窗口内的元素的索引号
2、队列头hh什么时候往后移动。如果滑动窗口的左边缘(i - k + 1)在队列头(q[hh])的右侧，hh ++
3、队列尾tt什么时候前移。如果待加入元素a[i]和队列头元素a[q[hh]]存在什么关系的时候，才让tt --
int a[N], q[N]; //a[N]存放数据，q[N]是单调队列，存放的是索引
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
831.KMP字符串
题目描述
给定一个模式串S，以及一个模板串P，所有字符串中只包含大小写英艾字母以及阿拉伯数字。模板串P在模式串S中多次作为子串出现。
求出模板串P在模式串S中所有出现的位置的起始下标。
输入格式
第一行输入整数N，表示字符串P的长度。
第二行输入字符串P。
第三行输入整数M，表示字符串S的长度。
第四行输入字符串M。
输出格式
共一行，输出所有出现位置的起始下标(下标从0开始计数)，整数之间用空格隔开。
数据范围
1 ≦ N ≦ 10^4
1 ≦ M ≦ 10^5
输入样式：
3
aba
5
ababa
输出样式：
0 2
（一）定义
P串是模式串，S串是长串，用模式串去匹配长串。
（二）暴力算法
动态模拟：
暴力算法
S[N],P[M]
for(int i=1; i<n; i++) //从1开始从0开始个人习惯
{
bool flag = true;
for(int j = 1; j <= m; j++)
if(S[i] != P[j])
{
flag = false;
break;
}
}
（三）优化方法
tips：
1、P和S这里都从1开始计算。
2、在P匹配S数据的时候，为了保证不出错，都是统一用P[j+1]和S[i]进行匹配，因此扫描的时候，P数组是从0开始扫描，这样P[j+1]才是有值的，S数组是从1开始扫描，因为S数组从1开始存数据。
3、i 代表扫描长串的索引，j 代表扫描模式串的索引
我们首先分析暴力算法的弊端，如果长串和模式串在匹配的过程中在某一个索引位置不相同的时候，按照暴力算法则会将i后移一位，再重新开始从头比较，会进行多次重复比较。比如长串P为abababab，模式串S为abababc(索引从0开始)，当我们从头开始比较的时候（i等于0），等比较到abababab这个红色之后第一个字符a和模式串中同位置的字符c的时候，发生了不一致，暴力算法会将i从1作为起点重头开始和模式串比对，但是我们发现这里红色部分拥有相同的前缀和后缀（定义在下方肉色字体中，具体表示在下方图片紫色直线标出的位置）abab，则只需要前移j到后缀的起点也就是j = 4的位置，然后继续比较S[ i ]和P[ j+1 ]即可，这里有人会问，为什么可以这么将j前移呢？首先因为绿色竖线之前的已经全部是相同的，此时模式串从头到当前绿色竖线位置这个区间内，两个紫色直线标注的是相同的前缀后缀字符串，这个前缀的串和在长串中橙色框出来的部分完全相同，所以可以直接将j前移到前缀的最后一个元素位置处（4的位置）。此时就可以继续比较S[ i ]和P[ j+1 ]。这里是整个KMP算法的核心原理。
这里前移的位置k，就是当S[i]比对P[j+1]结果不一致的时候，对应next[j]数组中的数值。即k = next[j]。j就是当前模式串比较出错的前一个位置；
对模板串P[N]需要进行一个预处理，找出其以一个点的后缀与该点前缀相同的位置；这样子模板串去匹配长串的时候，如果匹配到长串的某一个位置失败了，那么就知道可以移动的最大长度了，因为我们找出了模板串中某个点后缀与该点前缀相同的位置。
这个就是KMP中next数组的含义，next[ k ]表示的是从开头到 k 这一段的字符串中前缀与后缀相同的最大长度,(不能包括自身)，换成P数组中的含义就是P[ 1~j ] = P[ i-j+1, i ]（前j个等于后j个）。
"前缀"指除了最后一个字符以外，一个字符串的全部头部组合；
"后缀"指除了第一个字符以外，一个字符串的全部尾部组合。
求next数组方法：
i是在主串上从左到右走到头的，而j是在模式串上，先前进然后通过next数组在回退，在和i去比较。等j到模式串的尽头的时候，这时候就匹配成功了。
（四）模板代码
#include四、Trie树 （字典树）
（一）基本作用
高效地存储和查找字符串集合的数据结构。
（二）存储方式
字典形式
（三）使用条件
用Trie树存储字符串的时候，字符串一般都是全小写或者是全大写并且字母的个数不会很多即限制只有26个或52个
（四）每个变量含义
Son[p][u]存放的是父节点是p的，且是父节点p第u个儿子(代表某一个字符)的这一个节点的idx（也就是唯一的key或者叫id）。cnt[p]存放的是“以id为p的节点为终点，以root为起点的唯一一条字符串路径的所代表的字符串，出现的次数”。idx是代表当前每一个陌生节点的编号id，只有在发现陌生节点的时候才会使用。而无论在insert还是query的时候，p都是代表当前这个节点从哪里来(即父亲节点是谁？)
N代表字符串最多的个数，以及长度。
模板代码：
int son[N][26], cnt[N], idx;
// N是字符串最大长度，26是因为每行元素只会是26个英文字母中的某一个（取决于字符串构成），cnt存放的是以当前这个点结尾的单词有多少个，idx是当前用到的那个下标
// 0号点既是根节点，又是空节点
// Son[p][u]存放的是父节点是p的，且是父节点p第u个儿子(代表某一个字符)的这一个节点的idx（索引号）
// cnt[p]存储以id为p的节点为终点，以root为起点的唯一一条字符串路径的所代表的字符串，出现的次数
// 插入一个字符串
void insert(char *str)
{
int p = 0;
for (int i = 0; str[i]; i ++ )
{
int u = str[i] - 'a'; // 将a-z映射成0-25，u就已经代表了当前是哪个字符
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'; // 将a-z映射成0-25，u就已经代表了当前是哪个字符
if (!son[p][u]) return 0;
p = son[p][u];
}
return cnt[p];
}
手动模拟（方便理解）：
五、并查集
思维强，短小代码，最核心的就是find(x)函数
（一）用途
并查集可以快速的处理如下问题：
(1) 将两个集合合并
(2) 询问两个元素是否在一个集合当中
可以用近乎O(1)的时间复杂度维护以上两个操作
（二）实现
用树的形式维护这个集合。树根的编号就是整个集合的编号。每个节点存储它的父亲节点，使用p[x]表示x的父节点
（三）解决的问题
(1) 如何判断树根：if( p[x] == x ），这说明x
(2) 如何求x的集合的编号：while( p[x] != x ) x = p[x] 即x不是树根，那么就一直往上走，直到找到了树根
(3) 如何合并两个集合——加一条边就行，即把一个集合插到另外一个集合就行：假设px是x的集合编号，py是y的集合编号。p[x]=y。此时的优化操作为路径压缩（在代码里面find(x)函数就是路径压缩）：即找x的根节点的时候，一直往上走的时候，同时把父节点改成根节点。
(4)路径压缩：（在代码里面find(x)函数就是路径压缩）：即找x的根节点的时候，一直往上走的时候，同时把x的父亲节点p[x]的值改成根节点。
（四）模板及其变形代码
1、朴素并查集：
int p[N]; // p[]存储每个点的祖宗节点,在find函数中使用路径压缩就会维护p的值
// 返回x的祖宗节点 + 路径压缩
int find(int x)
{
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
// 初始化，假定节点编号是1~n，只有p[i] = i才代表是祖宗节点
void init(int n)
{
for (int i = 1; i <= n; i ++ ) p[i] = i;
}
// 合并a和b所在的两个集合： 将a的祖宗节点的父节点赋值成b的祖宗节点
void merge(int a, int b)
{
p[find(a)] = find(b);
}
2、维护size的并查集：
扩展：在更新路径的时候如何维护额外的信息之统计每一个集合内的点的数量，还可以维护节点到根节点的距离
维护一个数组size记录每个集合的节点个数，且这个数组只需要保证根节点的size有效即可
合并a和b所在的两个集合：（需要将a节点祖宗节点的父亲节点变成b节点的祖宗节点，然后需要同时维护b节点的size大小），需要注意的是如果合并的两个集合已经在同一集合了，就不能在直接给size[find(b)] += size[find(a)];了。
int p[N], size[N];
// p[]存储每个点的祖宗节点,在find函数中使用路径压缩就会维护p的值
// size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量
// 返回x的祖宗节点 + 路径压缩
int find(int x)
{
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
// 初始化，假定节点编号是1~n
void init(int n)
{
for (int i = 1; i <= n; i ++ )
{
p[i] = i;
size[i] = 1; // 每个集合最开始只有一个点，所以size是1
}
}
// 合并a和b所在的两个集合：（需要将a节点祖宗节点的父亲节点变成b节点的祖宗节点，然后需要同时维护b节点的size大小）
void merge(int a, int b)
{
size[find(b)] += size[find(a)];
p[find(a)] = find(b);
}
3、维护到祖宗节点距离的并查集：
int p[N], d[N];
// p[]存储每个点的祖宗节点,在find函数中使用路径压缩就会维护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
void init(int n)
{
for (int i = 1; i <= n; i ++ )
{
p[i] = i;
d[i] = 0;
}
}
// 合并a和b所在的两个集合：
void merge(int a, int b)
{
p[find(a)] = find(b);
d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量
}
六、堆（手写——用一维数组实现）
（一）基本操作
1、插入一个数
2、求集合当中的最小值
3、删除最小值
4、删除任意一个元素（STL无法直接实现）
5、修改任意一个元素（STL无法直接实现）
（二）基本结构
是一棵完全二叉树，即除了最后一层之外，其它层的节点都是满的，最后一层是从左到右依此排布的。
小顶堆：根节点小于等于左右两个子节点
大顶堆：根节点大于等于左右两个子节点
建立小顶堆：
（三）存储
用一个一维数组来存根节点和左右节点的下标表示：并且下标要从1开始标
（四）操作
1、down(x)：往下调整，把节点往下移动。即如果在小根堆里面有一个值变大了，那么就要往下调整，此时要和子两个节点一起比较
2、up(x)：向上调整，把节点往上移动。即如果在大根堆里面有一个值变小了，就要往上调整，只需要和父节点进行比较就可以
3、tips：使用down(x)和up(x)可以实现堆的基本操作
（1）插入一个数
heap[++size];
up[size];
即在末尾加入一个数，然后往上调整，直到插入到它应该在的位置
（2）求集合当中的最小值
小根堆里面就是heap[1]
（3）删除最小值
利用一个技巧：就是让最后一个点覆盖掉第一个点，然后size–,因为删除最后一个点是比较容易的
heap[1]=heap[size]; size–;
然后再维护down(1),就是让根节点往下调整，调整到它应该在的位置
（4）删除任意一个元素
heap[k]=heap[size];
size–;
然后更新维护：down(x)或者up(x)
可以一起写，但只会执行一个
（5）修改任意一个元素
heap[size]=k;
down(x);
（五）堆排序实现
1、建堆操作——将数组变成堆
再介绍下建堆的操作：for(int i = n / 2;i;i--) down(i);//O（n）建堆，由于堆是完全二叉树，n / 2的节点必然位于倒数第二层。下滤操作最多执行一次，n/4的节点位于倒数第三层，下滤操作最多执行两次…故一共会执行n / 4 * 1 + n / 8 * 2 + n / 16 * 3+…次。
int h[n];
for(int i = 1; i <= n; i++) scanf("%d",&h[i]);
for(int i = n / 2; i; i--) down(i); // O(n)实现数组变成堆
2、down操作
因为某些原因，导致u这个节点不在保持小顶堆的性质，对u节点进行down操作。
void down(int u)
{
int t = u; // t表示当前节点和其子女节点的最小值
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) // u不等于t说明调整了
{
swap(h[u],h[t]);
down(t); // 递归down下面的孩子节点
}
}
3、up操作（节点上移）
void up(int u)
{
while (u / 2 && h[u] < h[u / 2]) // 当父节点存在且当前节点比父节点小，则交换
{
heap_swap(u, u / 2);
u >>= 1;
}
}
4、swap操作
这个heap_swap()不常用，但是可以了解下
// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
// ph[k]存储第k个插入的点在堆中的位置，p代表下标，h代表堆，所以ph就是下标在堆中的位置
// hp[k]存储堆中下标是k的点是第几个插入的，p代表下标，h代表堆，所以hp就是堆中下标p是第几个插入的
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]);
}
5、新增的操作（维护堆）
if(插入)
{
scanf("%d", &x);
size ++;
m ++; // m记录第几个插入
ph[m] = size;
hp[size] = m;
h[size] = x;
up(size);
}
838.堆排序
题目描述
输入一个长度为n的整数数列，从小到大输出前m小的数。
输入格式
第一行包含整数n和m。
第二行包含n个整数，表示整数数列。
输出格式
共—行，包含m个整数，表示整数数列中前m小的数。
数据范围
1 ≦ m ≦ n ≦ 10^5
1 ≦ 数列中元素 ≦ 10^9
输入样式：
5 3
4 5 1 3 2
输出样式：
1 2 3
代码：
#include 七、哈希
把一个庞大的值域映射到小一点的空间。
采用键值对（key-value）的形式存储数据，有点类似java中的map。
步骤：
1、首先先用hash函数将数据映射到哈希表中。hash函数的选择比如满足简单、均匀、存储空间利用效率高。一般是X mod 一个质数
2、处理冲突的方式，如果不同的关键字对应到了同一个存储位置，这样就造成了冲突，如何处理这个冲突也是将hash分成了两种方式，一种是开放寻址法，一种是拉链法。
（一）开放寻址法
核心：
1、先用hash函数找到一个插入的位置
2、如果这个位置已经被占用了，则后移一位去查看下一个位置，直到找到的位置可以插入即可
在上述的2中，是一个叫做线性探测在散列的解决冲突方式，还有其他的方式比如二次探测在散列，读者可以自行查阅
注意这道题不能把 h 数组赋值为全 0 ，因为 0可能在数据集里面，应该全部赋值为一个永远用不到的数，比如null = 0x3f3f3f3f;通过memset函数初始化数组h
int h[N]; // 我们的N（坑位）开的是数据量的两倍，所以肯定是不存在占满的情况
memset(h, 0x3f, sizeof h); // 通过memset函数初始化数组h
// 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
int find(int x)
{
int k = (x % N + N) % N;
while (h[k] != null && h[k] != x)
{
k ++ ;
if (k == N) k = 0; // 如果询问到最后一个位置了，则询问的下一个位置是0
}
return k;
}
插入模拟：
（二）拉链法
AC核心代码：要记得把h数组全部赋值为-1。这里N为大于100000的第一个质数，用质数来说相对比较好，能最大限度减少冲突
int h[N] = {-1}, e[N], ne[N], idx; // h[]是头结点数组，ne[i]存放i的下一个节点的序号。idx是当前正在操作数的序号
// 向哈希表中插入一个数
void insert(int x)
{
int k = (x % N + N) % N; // 使用hash函数获取散列位置
e[idx] = x; // 存储新插入元素至e[idx] ——idx代表当前操作元素的索引编号
ne[idx] = h[k]; // 将idx这个元素的下一个指向置为 h[k]（h[k]代表以k为头结点的指向下一个元素的索引是什么）
h[k] = idx ++ ; // 代表以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;
}
插入模拟：
（三）字符串哈希
1、hash，其实就是将一个东西映射成另一个东西，类似Map，key对应value。
2、那么字符串Hash，其实就是：构造一个数字使之唯一代表一个字符串。但是为了将映射关系进行一一对应，也就是，一个字符串对应一个数字，那么一个数字也对应一个字符串。
3、用字符串Hash的目的是，我们如果要比较一个字符串，我们不直接比较字符串，而是比较它对应映射的数字，这样子就知道两个“子串”是否相等。从而达到，子串的Hash值的时间为 O(1)，进而可以利用“空间换时间”来节省时间复杂的。
对于一个字符串str = “ABCABCDEFXCACWING”
h[1] = "A"的哈希值
h[2] = "AB"的哈希值
h[3] = "ABC"的哈希值
h[4] = "ABCA"的哈希值
…
这里的h数组存储的是这个字符串的哈希值,h[i]的含义就是代表从1-i的字符串的哈希值
假设有一个S = s1s2s3s4s5的字符串，根据定义，我们先获取他的hash值，如下：
hash[0] = 0
hash[1] = s1
hash[2] = s1 * Base1 + s2
hash[3] = s1 * Base2 + s2 * Base1 + s3
hash[4] = s1 * Base3 + s2 * Base2 + s3 * Base + s4
hash[5] = s1 * Base4 + s2 * Base3 + s3 * Base2 + s4 * Base1 +s5
现在我们想求子串s3s4的hash值，不难得出为s3 * Base + s4 ，并且在上面观察，不难发现这个值就相当于把hash[2]都乘上了Base2，而4 - 2 = 2（待求子串r - l + 1），这样就不难推导出求这个例题的求解式子了。
hash[4] - hash[2] * Base2
至此，通过对以上的归纳，可以得出如下公式
若已知一个S = s1s2…sn的字符串的hash的值，hash[i]，0 ≦ i ≦ n，其子串sl…sr对应的hash值为：
res = hash[r] - hash[l - 1] * Baser-l+1
PS:
1、不能把字符串映射成0
2、当P=131或者P=13331，Q=2^64，一般99%的情况下不会发生冲突，冲突的概率是几十亿分之一
题目：841.字符串哈希
先预处理p数组：
p[i] = p[i - 1] * P
预处理h哈希数组：
h[i] = h[i - 1] * p + str[i]，其中str不为0就行
得到一个字符串区间是[l, r]的子字符串的哈希值是：
h[r] - h[l - 1] * p[r - l + 1]
模板代码：
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;
top() 访问堆顶元素
empty() 队列是否为空
size() 返回队列内元素个数
push() 插入元素到队尾 (并排序)
emplace() 原地构造一个元素并插入队列
pop() 弹出堆顶元素
swap() 交换内容
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() //在容器中寻找值为k的元素，返回该元素的迭代器。否则，返回map.end()
[] 注意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位取反