一、链表与邻接表：树与图的存储
二、栈与队列：单调队列、单调栈
三、kmp
四、Trie
五、并查集
六、堆
七、Hash表
一、链表与邻接表：树与图的存储
1.用数组模拟单链表，考得最多的是模拟邻接表的情况
（1）邻接表的作用
1存储图
2存储树
（2）数组模拟单链表的方法
首先需要两个数组e和ne，前者是用来存元素的，e的下标就表示结点的序号，内容就是表示该结点存的元素。ne 数组存的是下一个指向结点的位置，它的下标表示该结点的序号，里面存的是该结点指向的下一个结点的序号。
（3）步骤：
1.先设置出必要元素数组e,he,头指针head以及指针idx
2.编写初始化函数。一开始head为-1，因为-1表示为链表尾的号码。IDX 为0，指向第一个。
3.编写插入函数。
第一种插入情况：插入为头结点。分三步，第一步将数据存入到当前idx指向的结点e[idx]=new。第二步将新点的ne指向原来head指向的下一个结点位置。第三步head指回到新的头结点。第四步，idx++
第二种插入情况：将点插入到结点为k的点的后面。分四步走。第一步将新结点的数据存进来，e[idx]=new;第二步将新结点的ne 指向k结点的ne;第三步将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];
}
2.用数组模拟双链表，考得最多的是用来优化某些问题
（1）用数组模拟双链表的方法
首先需要三个数组，e,l,r，e用来存这个该结点的元素是什么，l用来存该结点左边指向的是谁，r用来存该结点右边指向的是谁。然后还要一个 idx是用来作为遍历链表的指针，注意，我们直接将e[o]作为head，将最后一个结点作为tail
由于数组中的第0位和第1位已经当成了链表的最右端和最左端的端点，接下来每次都是往后面，实现双链表使用L，R的数组去引导，即E数组只是用于存储数据，实现链表指针的是R，L数组，此外，还要注意，比如在第K个插入的数后面在插入数据A，则插入的位置是Ｋ+2-1，因为数组的头两个已经存了。
（2）模版代码如下：
1.设置必要的数组。
2.编写初始化函数。
3.编写插入函数。插入的时候可以插入右边也可以插入左边。
第一个情况：在k的右边插入一个新结点；分为五步走：第一步将结点的数据存进来e[idx]=new;第二步将新结点的右边指向原结点的右边；第三步将新结点的左边指向原结点的左边；第四步将原结点的下一个结点的左边指向新结点；第五步将原结点的右边指向新结点。
第二种情况，在k的左边插入一个新结点。直接变成在k的前一个结点的右边插入一个新结点就行，然后调用第一种情况的。
4.编写删除函数。
直接将该结点的右边指向该结点的左边结点，将该结点的左边指向该结点的右边结点即可。
代码：
双链表
// 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];
}二、栈与队列：单调队列、单调栈
1.栈与队列的定义：栈是先进后出，队列是先进先出。
2.栈的各种操作：直接用数组模拟，然后在用一个指针to 来指示。插入操作：stk[tt++]=x。
弹出操作：tt--。
判断栈是否为空：
if(tt>0) not empty else empty 。栈顶：skt[tt]// tt表示栈顶
int stk[N], tt = 0;
// 向栈顶插入一个数
stk[ ++ tt] = x;
// 从栈顶弹出一个数
tt -- ;
// 栈顶的值
stk[tt];
// 判断栈是否为空
if (tt > 0)
{
}普通队列：
3.队列的各种操作：在队尾插入元素，队头弹出元素。q[N],hh,yy=-1。插入操作：q[++tt]=x;
弹出hh++; 判断队列是否为空：if(hh<=tt) not empty else empty；取出队头队尾元素q[hh],q[tt]。
队列
// hh 表示队头，tt表示队尾
int q[N], hh = 0, tt = -1;
// 向队尾插入一个数
q[ ++ tt] = x;
// 从队头弹出一个数
hh ++ ;
// 队头的值
q[hh];
// 判断队列是否为空
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];
// 判断队列是否为空
if (hh != tt)
{
}单调栈
（1）对应题型：给定一个序列，找出每个数的左边（右边）离他最近的，且比它小（大）的数在什么地方，
常见模型：找出每个数左边离它最近的比它大/小的数
（3）优化做法：
首先，考虑是否具有单调性，假设从头开始出发的指针去扫描，因为找的是某个元素左边离他最近的最小的元素，所以扫描的时候如果新的元素比他大就不往前走了，因此，这具有单调性，我们可以用栈来实现，我们可以设置一个单调栈，就是，每次读入一个元素的时候，先将栈头的指针定位到比该元素小的最近的那个，如果栈顶指针不为空的话就说明已经找到最小的那个了，直接把结果输出去就行，然后把它加进单调栈里面，如果没找到的话，就输出-1即可然后比较一下，如果这个元素小的话就把它加进站里面
（4）本节学到的知识点（重点）：
第一：单纯的cin,cout要比scanf慢十倍左右，所以如果输入输出很多的的话，还是非常建议用scanf才好
第二：在main函数中或者要用到cin ,cout的地方之前加上：这样读入读出时间可以比拟 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;
}单调队列
模板题：滑动窗口的是最大最小值
用队列来维护滑动窗口：第一步将滑动队列向右滑动滑动一位队头进来，然后队尾出去一位。发现单调性：依次遍历的时候，只要前面的点比后面的点要大那么就不可能被选上，所以就可以直接删去。这样就变成了一个单调队列。
单调队列和单调栈的一个思路都是：
先考虑这一题的朴素算法是啥，暴力模拟一边；然后在考虑这个朴素算法里面哪些元素是没有用的，把这些没有用的都删掉，接着看剩下的元素是否就构成了有单调性；如果有单调性就可以做优化——取极值就取两端，找元素就用二分。
注意：STL的容器若不开O2优化，则会比数组模拟的要2慢
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;
}总结：
一共分三步走：
1.判断单调队列是否滑出窗口
2.判断原数组的下一个元素是否比当前单调队列中的元素还要小，如果是的话，则一直出队
3.将该原数组的元素进队
4.输出结果：如果是求最大最小值则直接输出队首元素，也可以利用二分查找的等函数。注意，输出的时候，要保证此时的长度达到了滑动窗口的长度，即元素组的下标要达到长度。
注意：判断滑动窗口是否滑出的时候，如果题目中一次就移动一个格，可以用if，但是如果题目中要求的是一次移多个格，就要用while.
三、KMP
1.定义：
给出一个长串S[N]与以及一个模板串P[M],用模板串去匹配长串，如果长串中有包含模板串的部分，则输出true;
2.思考方向：
（1）先去思考暴力算法怎么做
（2）再去思考怎么去优化
3.暴力算法：
for(int i=0;i<n;i++)
for(int j=i-1;j>=0;j--)
if(ai>aj)
{
cout<<aj<<endl;
break;
}4.优化方向
对模板串P[N]进行一个预处理，找出其以一个点的后缀与该点前缀相同的位置；这样子模板串去匹配长串的时候，如果匹配到长串的某一个位置失败了，那么就知道可以移动的最大长度了，因为我们找出了模板串中某个点后缀与该点前缀相同的位置。
这个就是KMP中next数组的含义，next[i]表示的这一段的字符串中后缀与以1为起点的前缀相等长度最长是多少
注意点：
1.S数组用来存长串数组，P数组用来存模版数组，且两者都是从1开始存数据
2.在P匹配S数据的时候，为了保证不出错，都是统一用P[j+1]和S[i]进行匹配，因此扫描的时候，P数组是从0开始扫描，这样P[j+1]才是有值的，S数组是从1开始扫描，因为S 数组从1开始存数据
代码如下：
// 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];
// 匹配成功后的逻辑
}
}四、Trie
基本作用：高效地存储和查找字符串集合的数据结构。
用Trie树存储字符串的时候，字符串一般都是全小写或者是全大写并且字母的个数不会很多即限制只有26个或52个
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];
}五、并查集
思维强，短小代码
1.作用：并查集可以快速的处理如下问题：
(1) 将两个集合合并
(2) 询问两个元素是否在一个集合当中
可以近乎在O（1)的时间内完成上述操作
2.基本思想：每个集合用一颗树来表示。树根的编号就是整个集合的编号。每个节点存储它的父节点，p[x]表示x的父节点
3.解决的问题：
(1) 如何判断树根：if(p[x]==x）
(2) 如何求x的集合的编号：while(p[x]!=x) x=p[x] 即x不是树根，那么就一直往上走，直到找到了树根
(3) 如何合并两个集合——加一条边就行，即把一个集合插到另外一个集合就行：假设px是x的集合编号，py是y的集合编号。p[x]=y。此时的优化操作为路径压缩：即找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的并查集：
扩展：在更新路径的时候如何维护额外的信息之统计每一个集合内的点的数量，还可以维护节点到根节点的距离
维护一个数组size记录每个集合的节点个数，且这个数组只需要保证根节点的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.堆的基本操作
（1）插入一个数
（2）求集合当中的最小值
（3）删除最小值
（4）删除任意一个元素
（5）修改任意一个元素
2.堆的基本结构
是一棵完全二叉树，即除了最后一层之外，其它层的节点都是满的
小根堆：根节点小于等于左右两个子节点
大根堆：根节点大于等于左右两个子节点
3.堆的存储
用一个一维数组来存根节点和左右节点的下标表示：并且下标要从1开始标
4. down(x)
顾名思义即往下调整，即如果在小根堆里面有一个值变大了，那么就要往下调整，此时要和子两个节点一起比较
5.up(x）
顾名思义即向上调整，即如果在大根堆里面有一个值变小了，就要往上调整，只需要和父节点进行比较就可以
6.利用up和down两个操作去完成堆的所有操作
（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)
具体代码表格化：
把数组变成堆：
for(int i=n/2;i;i--) down(i);
// 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);down操作代码：
#include <bits/stdc++.h>
using namespace std;
const int N=100010;
int n,m;
int h[N],size;
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)//说明调整了
{
swap(h[u],h[t]);
down(t);
}
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) scanf("%d",&h[i]);
size=n;
for(int i=n/2;i;i--) down(i);//将数组变成堆
while(m--)
{
printf("%d",h[1]) ;//输出最小值
h[1]=h[size];
size--;
down(1);//删除最小元素
}
}
七、Hash表
哈希表（H a s h HashHash表、散列表）
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。
(1).拉链法（用个链表来存储每个位置上的集合）
AC核心代码：要记得把h数组全部赋值为-1。这里N为大于100000的第一个质数，用质数来说相对比较好，能最大限度减少冲突
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).开放寻址法
核心就是先找个一个位置，如果这个位置上有数就往看下一个位置，直到找到没得数的位置。一般把数组开成原来的2-3倍大小。同样也要把N设置为第一个大于的质数，减少冲突
注意这道题不能把 h hh 数组赋值为全 0 00 ，因为 0 00 可能在数据集里面，应该全部赋值为一个永远用不到的数，比如 n u l l = 0 x 3 f 3 f 3 f 3 f null=0x3f3f3f3fnull=0x3f3f3f3f
AC核心代码如下：
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;
}字符串哈希（这里介绍的是字符串前缀哈希）
代码：
#include<bits/stdc++.h>
using namespace std;
#define ULL unsigned long long
const int MAXN = 1e5 + 10;
int P = 131;
ULL arr[MAXN], p[MAXN];
int n, m, l1, r1, l2, r2;
char str[MAXN];
ULL get(int l, int r)
{
return arr[r] - arr[l - 1] * p[r - l + 1];
}
int main()
{
p[0] = 1;
scanf("%d%d%s", &n, &m, str + 1);
for(int i = 1; i <= n; ++i)
{
p[i] = p[i - 1] * P;
arr[i] = arr[i - 1] * P + str[i];
}
while(m--)
{
scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
if(get(l1, r1) == get(l2, r2))
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
模板：
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];
}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位取反
6550
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
