1.链表与邻接表：树与图的存储
我们将结构体和指针结合来实现链表
struct Node
{
int val;
Node * next;
};
new Node;//这样创建结点是相当慢的
我们算法主要是用数组来模拟链表，这样效率会高一些。
数组模拟单链表
邻接表：存储图和树
实现一个单链表，链表初始为空，支持三种操作：
-
向链表头插入一个数
-
删除第k个插入的数后面的数
-
在第k个前面插入一个数
#include<iostream>
using namespace std;
const int N = 100010;
//head为头结点的下标
//e[i]表示节点i的值
//ne[i]表示节点i的节点next指针
//idx存储当前已经使用到的点的位置
int head, idx, e[N], ne[N];
void init()
{
head = -1;
idx = 0;
}
//将x插入到头结点
void add_to_head(int x)
{
e[idx] = x;
ne[idx] = head;
head = idx;
idx++;
}
//将x插入到k的节点位置
void add(int k, int x)
{
e[idx] = x;
ne[idx] = ne[k];
ne[k] = idx;
idx++;
}
//将k后面的点去掉
void remove(int k)
{
ne[k] = ne[ne[k]];
}
int main()
{
int m;
cin >> m;
init();
while(m--)
{
int k, x;
char op;
cin >> op;
if(op == 'H')
{
cin >> x;
add_to_head(x);
}
else if(op == 'D')
{
cin >> k;
if(k == 0) head = ne[head];
remove(k-1);
}
else
{
cin >> k >> x;
add(k-1, x);
}
}
for(int i = head;i != -1;i = ne[i])
{
cout << e[i] << ' ';
}
return 0;
}数组模拟双链表的模板：
#include<iostream>
using namespace std;
const int N = 100010;
int m;
int e[N], l[N], r[N], idx;
void init()
{
//0表示左端点，1表示右端点
r[0] = 1, l[1] = 0;
idx = 2;
}
//在下标的k的右边插入x
void add(int k, int x)
{
e[idx] = x;
r[idx] = r[k];
l[idx] = k;
l[r[k]] = idx;
r[k] = idx;
}
//删除第k个点
void remove(int k)
{
r[l[k]] = r[k];
l[r[k]] = l[k];
}2.栈与队列：单调队列、单调栈
栈是先进后出，队列是先进先出。
数组实现栈：
#include<iostream> using namespace std; const int N = 100010; int stk[N], tt; //插入stk[++tt] = x; //弹出tt--; //判断栈是否为空 if(tt>0) 不为空，否则为空 //栈顶 stk[tt];
数组实现队列
#include<iostream> using namespace std; //在队尾插入元素，在队头弹出元素 int q[N], hh, tt = -1; //判断队列是否为空 if(hh <= tt) not empty; else empty; //取出队头、队尾元素 q[hh]; q[tt];
单调栈例题：
给定一个长度为 N 的整数数列，输出每个数左边第一个比它小的数，如果不存在则输出 -1。
int tt;
for(int i = 1;i <= n; i++)
{
while(tt && check(q[tt], i)) t--;
stk[++tt] = i;
}
题目代码：
#include<iostream>
using namespace std;
const int N = 1e5 + 10;
int n;
int q[N], tt;
int main()
{
scanf("%d", &n);
for(int i = 0;i < n; i++)
{
int x;
scanf("%d",&x);
while(tt && stk[tt] >= x) tt--;
if(tt) printf("%d ",stk[tt]);
else printf("-1 ");
stk[++tt] = x;
}
return 0;
}只有出栈和入栈两次操作，所以它的时间复杂度为O(n)
单调队列例题：
移动窗口的例题，k为窗口大小且k=3，打印出三个数中最小数，如果窗口下数不足，则输出-1
1 3 -1 -3 5 3 6 7
由上面的例子我们可以知道在3 -1 -3这个序列中3绝对不可能为最小值，-3的生命周期要比3长。我们要优化该形式，可以用单调队列的形式，将不满足的点删掉。
我们的队列里存的不是值而是下标。
int hh = 0, tt = 1;
for(int i = 0;i < n; i++)
{
if(hh <= tt && check_out(q[hh])) hh++;
while(hh <= tt && check(q[tt],i)) tt--;
q[++tt] = i;
}
本题代码
#include<iostream>
using namespace std;
const int N = 1e6 + 10;
int n,k;
int a[N], q[N];
int main()
{
scanf("%d%d", &n, &k);
for(int i = 0;i < n; i++)
{
scanf("%d", &a[i]);
}
int hh = 0, tt = -1;
for(int i = 0;i < n; i++)
{
//判断队头是否已经超出滑出窗口
if(hh <= tt && i - k + 1 > q[hh]) hh++;
while(hh <= tt && a[q[tt]] >= a[i]) tt--;
q[++tt] = i;
if(i >= k - 1)
printf("%d ", a[q[hh]]);
}
printf("");
return 0;
}3.kmp算法
KMP算法是一种字符串匹配算法，用于在一个字符串中查找另一个字符串出现的位置。它的全名是Knuth-Morris-Pratt算法，是由Donald Knuth、James H. Morris和Victor S. Pratt三人共同发明的。
S[N]，p[M]我们如果用暴力算法（朴素做法）来做的话，代码如下：
for(int i = 1;i <= n; i++)
{
bool flag = true;
for(int j = 1;j <= m; j++)
{
if(s[i] != p[j])
{
flag = false;
break;
}
}
}
KMP算法的思想是在匹配过程中，尽量利用已经匹配过的信息来快速跳过不匹配的位置，从而达到减少匹配次数和提高匹配效率的目的。具体来说，它通过预处理出一个next数组，来记录匹配模式串中每个位置上最长的相同前缀和后缀的长度。在匹配过程中，如果发现当前字符不匹配，就可以利用next数组中记录的信息，快速地将模式串向右移动一定的距离，而无需重新从头开始匹配。
KMP算法的时间复杂度为O(m+n)，其中m和n分别为匹配串和模式串的长度。相比于暴力匹配算法，KMP算法可以在很大程度上减少匹配的次数，从而提高匹配的效率。但是，KMP算法的实现比较复杂，需要对next数组进行正确的计算和处理，因此在实际应用中需要仔细考虑其实现方式和适用场景。
next[i] = j， p[1, j] = p[i - j + 1, i]
acwing的KMP算法例题
给定一个模式串S,以及一个模板串P,所有字符串中只包含大小写英文字母以及阿拉伯数字。模板串P在模式串S中多次作为子串出现。求出模板串P在模式串S中所有出现的位置的起始下标。
输入样例：3 aba 5 ababa 输出：0 2
代码：
#include<iostream>
using namespace std;
const int N = 1e4 + 10, M = 1e5 + 10;
int n, m;
char p[N], s[M];
int ne[N];
int main()
{
cin >> n >> p + 1 >> m >> s + 1;
//求next的过程
for(int i = 2, j = 0;i <= n; i++)
{
while(j && p[i] != p[j + 1]) j = ne[j];
if(p[i] == p[j + 1]) j++;
ne[i] = j;
}
//kmp的匹配过程
for(int i = 1, j = 0;i <= m; i++)
{
while(j && s[i] != p[j + 1]) j = ne[j];
if(s[i] == p[j + 1]) j++;
if(j == n)
{
//匹配成功
printf("%d ",i - n);
j = ne[j];
}
}
return 0;
}4.Trie树
Trie（又称前缀树或字典树）是一种基于树结构的数据结构，用于快速地检索和插入字符串。Trie的每个节点代表一个字符串的前缀，从根节点到叶子节点的路径上表示一个完整的字符串。
Trie的特点是它的每个节点都有多个子节点，每个子节点代表一个字符。根节点没有父节点，每个非叶子节点的子节点数等于它的编号（从0开始）减去1。
在Trie中，插入一个字符串的操作是从根节点开始，按照字符串的字符顺序依次遍历每个字符，如果当前节点的子节点中没有对应字符，就新建一个子节点，并将当前节点移动到该子节点。如果已经遍历到字符串的末尾，则说明该字符串已经成功插入到Trie中。
Trie的另一个常见操作是查找一个字符串是否存在于Trie中。从根节点开始，按照字符串的字符顺序依次遍历每个字符，如果当前节点的子节点中没有对应字符，则说明该字符串不存在于Trie中。如果已经遍历到字符串的末尾，且当前节点是一个叶子节点，则说明该字符串存在于Trie中。
Trie的主要优势是它可以快速地检索和插入字符串，时间复杂度为O(m)，其中m为字符串的长度。但是，由于Trie的每个节点都需要存储多个子节点，因此它的空间复杂度比较高，适用于数据规模较小的情况。在大数据处理和文本处理等领域，Trie通常被用来实现词典和关键字过滤等功能。
trie字符串统计：
维护一个字符串集合，支持两种操作：
-
‘lx’向集合中插入一个字符串x
-
‘Qx’询问一个字符串在集合中出现了多少次
一共有N次操作，输入的字符串总长度不超过105，字符串仅包含小写英文字母。
#include<iostream>
using namespace std;
const int N = 1e5 + 10;
int son[N][26], cnt[N], idx;//下标是0的点，既是根节点，有是空节点
int str[N];
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];
}
int main()
{
int n;
scanf("%d", &n);
while(n--)
{
char op[2];
scanf("%s%s", op, str);
if(op == 'I') insert(str);
else printf("%d\n", query(str));
}
return 0;
}最大异或对
5.并查集
并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题。
-
将两个集合合并
-
询问两个元素是否在一个集合当中。
基本原理：每隔几何用一棵树来表示，树根的编号就是一整个集合的编号。每个节点存储它的父节点，p[x]表示x的父节点。
问题1：如何判断树根：if(p[x] == x);
问题2：如何求x的集合编号：while(p[x] != x) x = p[x];
问题3：如何合并两个集合：px是x的集合编号，py是y的集合编号。p[x] = y
基本上来说是O(1)的时间复杂度
合并集合：
一共有n个数，编号是1~n，最开始每个数各自在一个集合中。
现在要进行m个操作，操作一共有两种
-
将编号为a，b的两个数所在集合进行合并，如果两个数已经在集合中，即忽略这个操作
-
询问编号为a，b的两个数是否在同一个集合中
#include<iostream>
using namespace std;
const int N = 1e5 + 10;
int n, m;
int p[N];
int find(int x)//返回x的祖宗结点+路径压缩
{
if(p[x] != x) p[x] = find(p[x]);
return p[x];
}
void merge(int a, int b)
{
p[find(a)] = find(b);
}
int main()
{
scanf("%d%d", &n, &m);
for(int i = 1;i <= n; i++)
p[i] = i;
while(m--)
{
char op[2];
int a, b;
scanf("%s%d%d", op, &a, &b);
if(op[0] == 'M')
merge(a, b);
else
{
if(find(a) == find(b))
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}近乎O(1)的时间
连通块中点的数量：
给定一个包含n个点（编号为1~n）的无向图，初始时图中没有边。
现在要进行m个操作，操作一共有三个：
-
“Cab”，在点a和点b之间连一条边，a和b可能相等
-
“Q1ab”，询问点a和点b是否在同一连通块内，a和b可能相等
-
“Q2ab”，询问点a所在的联通快中点的个数。
#include<iostream>
using namespace std;
const int N = 1e5 + 10;
int n, m;
int p[N], size[N];
int find(int x)
{
if(p[x] != x) p[x] = find(p[x]);
return p[x];
}
void merge(int a, int b)
{
p[find(a)] = find(b);
}
int main()
{
scanf("%d%d", &n, &m);
for(int i = 1;i <= n; i++)
{
p[i] = i;
size[i] = 1;
}
while(m--)
{
char op[5];
int a, b;
scanf("%s", op);
if(op[0] == 'C')
{
scanf("%d%d", &a, &b);
if(find(a) == find(b)) continue;
size[find(b)] += size[find(a)];
merge(a, b);
}
else if(op[1] == '1')
{
scanf("%d%d", &a, &b);
if(find(a) == find(b))
printf("Yes\n");
else
printf("No\n");
}
else
{
scanf("%d", &a);
printf("%d\n", size[find(a)]);
}
}
return 0;
}食物链
动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。
A吃B， B吃C，C吃A。
现有N个动物，以1－N编号。
每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。
有人用两种说法对这N个动物所构成的食物链关系进行描述：
第一种说法是”1 X Y”，表示X和Y是同类。
第二种说法是”2 X Y”，表示X吃Y。
此人对N个动物，用上述两种说法，一句接一句地说出K句话，这K句话有的是真的，有的是假的。
当一句话满足下列三条之一时，这句话就是假话，否则就是真话。
1） 当前的话与前面的某些真的话冲突，就是假话； 2） 当前的话中X或Y比N大，就是假话； 3） 当前的话表示X吃X，就是假话。
你的任务是根据给定的N和K句话，输出假话的总数。
#include<iostream>
using namespace std;
int main()
{
return 0;
}
6.堆
如何手写一个堆？
堆是维护数与集合。
堆是一种数据结构，它满足以下两个条件：
-
完全二叉树：堆的总是一棵完全二叉树，即除了最后一层外，其他层都是满的，并且最后一层的节点都集中在左侧。
-
堆性质：对于每个节点X，其父节点的值小于等于（或大于等于，称为最小堆）其子节点的值。
堆通常用于实现优先队列，其中每个节点代表一个事件或任务，节点的值表示任务的优先级。通过将任务按照优先级从上到下放置在堆中，可以保证优先级最高的任务总是最先被执行。
在实现上，堆可以使用数组来表示。对于一个节点X，其父节点和子节点的位置可以通过简单的数学计算来确定。例如，对于一个最小堆，节点X的父节点和左子节点的位置可以通过以下公式计算：
-
父节点位置：parent(X) = (X-1)/2
-
左子节点位置：left_child(X) = 2*X + 1
堆也可以用来实现优先级调度、任务调度等应用。
-
插入一个数
heap[++size] = x; up(size); -
求集合当中的最小值
heap[1]; -
删除最小值 用最后一个元素覆盖根节点
heap[1] = heap[size];size--;down(1); -
删除任意元素
heap[k] = heap[size];size--; -
修改任意元素
heap[k] = x; down(k); up(k);
838.堆排序：
输入一个长度为n的整数数列，从小到大输出前m小的数。
输入格式：第一行包含整数n和m，第二行包含n个整数，表示整数数列。
输出格式：共一行，包含m个整数，表示整数数列中前m小的数。
5 3 \n 4 5 1 3 2
1 2 3
代码：
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e5 + 10;
int n, m;
int h[N], size;
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)
{
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);
}
return 0;
}839.模拟堆：
维护一个集合，初始时集合为空，支持如下几种操作：
-
"lx"，插入一个数x；
-
“PM”，输出当前集合中的最小值；
-
“DM”，删除当前集合的最小值（当最小值不唯一时，删除最早插入的最小值）；
-
“Dk”，删除第k个插入的数；
-
“Ckx”，修改第k个插入的数，将其变为x；
现在要进行N次操作。对于所有第2个操作，输出当前集合的是小值。
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int N = 1e5 + 10;
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 / 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"))
{
scanf("%d", &x);
size++;
m++;
ph[m] = size, hp[size] = m;
h[size] = x;
up(size);
}
else if(!strcmp(op, "PM")) printf("%d\n", h[1]);
else if(!strcmp(op, "DM"))
{
heap_swap(1, size);
size--;
down(1);
}
else if(!strcmp(op, "D"))
{
scanf("%d", &k);
k = ph[k];
heap_swap(k, size);
size--;
down(k), up(k);
}
else
{
scanf("%d%d", &k, &x);
k = ph[k];
h[k] = x;
down(k), up(k);
}
}
return 0;
}7.Hash表
哈希表是一种使用哈希函数组织数据，以支持快速插入和搜索的数据结构。
哈希表可以用来实现动态集合。它支持以下操作：
-
插入：将一个元素插入到哈希表中。
-
删除：将一个元素从哈希表中删除。
-
搜索：在哈希表中查找一个元素。
哈希表的实现基于哈希函数，它将键映射到存储桶（bucket）中。每个存储桶是一个链表，链表中的每个节点都包含一个键值对。当插入一个元素时，哈希函数将键映射到一个存储桶，然后将元素添加到该存储桶的链表中。当搜索一个元素时，哈希函数将键映射到相应的存储桶，然后在该存储桶的链表中查找元素。
哈希表有多种实现方式，其中最常用的是开放地址法和相联数组法。开放地址法在哈希表中使用一个数组来存储存储桶，当发生哈希冲突时，它使用线性探测、二次探测、双重散列等方法来找到空槽位。相联数组法在哈希表中直接使用一个数组来存储键值对，当发生哈希冲突时，它将新元素添加到数组的末尾。
哈希表在计算机科学中广泛应用，例如在数据库、操作系统、网络通信等领域。它能够提供常数级别的查找效率，比其他数据结构更高效。
7.1哈希表的存储结构
1.开放寻址法 2.拉链法
840.模拟散列表
维护一个集合，支持如下几种操作：
-
“lx”，插入一个数
-
“Qx”，询问数x是否在集合中出现过
现在要进行N次操作，对于每个询问操作输出对应的结果
一般情况下，对哈希函数进行取模，但是由于取模的原因，可能会有冲突，若干不同的数可能会映射在同一个位置。
开放寻址法：
#include<iostream>
#include<cstring>
using namespace std;
cosnt int N = 200003, null = 0x3f3f3f3f;
int h[N];
int find(int n)
{
int t = (x % N + N) % N;
while(h[t] != null && h[t] != x)
{
t++;
if(t == N)
t = 0;
}
return t;
}
int main()
{
int n;
scanf("%d", &n);
merset(h, 0x3f, sizeof(h));
while(n--)
{
char op[2];
int x;
scanf("%s%d", op, &x);
int k = find(x);
if (op == 'I')
{
h[k] = x;
}
else
{
if (h[k] != null)
puts("Yes");
else
puts("No");
}
}
return 0;
}拉链法：
#include<iostream>
#include<cstring>
using namespace std;
const int N = 100003;
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;
else
return false;
}
int main()
{
int n;
scanf("%d", &n);
memset(h, -1, sizeof(h));
while(n--)
{
char op[2];
int x;
scanf("%s%d", op, &x);
if(op == "I") insert(x);
else
{
if(find(x)) puts("Yes");
else puts("No");
}
}
return 0;
}7.2.字符串前缀哈希方法
str = "ABCDEFADCYUGHJJDFDGKHJK"
预处理：特殊h[0] = 0
h[1] = "A"的对应的哈希值，后面的一样 h[2] = "AB" h[3] = "ABC".....
-
不能映射为0
-
Rp足够好，不产生冲突
841.字符串哈希
给定个长度为的字符串，再给定m个询问，每个询问包含四个整数l1，r1，l2，r2，请你判断[l1,r1]和[l2,r2]这两个区间所包含的字符串子串是否完全相同。
字符串中只包含大小写英文字母和数字。
#include<iostream>
using namespace std;
typedef unsigned long long ULL;
const int N = 100010;
int n, m;
char str[N];
ULL h[N], p[N];
ULL get(int l, int r)
{
return h[r] - h[l - 1] * p[r - l + 1];
}
int main()
{
scanf("%d%d%s", &n, &m, str + 1);
p[0] = 1;
for(int i = 1;i <= n; i++)
{
p[i] = p[i-1] * p;
h[i] = h[i-1] * p + str[i];
}
while(m--)
{
int l1, r1, l2, r2;
scanf("%d%d%d%d",&l1, &r1, &l2, &r2);
if(get(l1, r1) == get(l2, r2))
puts("Yes");
else
puts("No");
}
return 0;
}8.C++STL使用技巧
vector：变长数组，倍增的思想
string：字符串，substr()，c_str()
queue：队列，push(), front(), pop()
priority_queue：优先队列，push()， top()，pop()
stack：栈，push(), top(), pop()
deque：双增队列
set, map, multiset和multimap：基于平衡二叉树，动态维护有序序列
unorder_set、unorder_map、unorder_multiset、unorder_multimap：基于哈希表
bitset：压位
list
#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
#include<cstdio>
using namespace std;
int main()
{
vector<int> a(10, 3);
//vector<int> a[10];
a.size();//返回元素个数
a.empty();//返回是否为空
a.clear();//清空
a.front();//返回第一个数
a.back();//返回最后一个数
a.push_back();//尾插
a.pop_back();//尾部释放
a.begin()/a.end();//vector的迭代器
for(int i = 0;i < 10; i++)
a.push_back();
for(int i = 0;i < a.size(); i++)
cout << a[i] << ' ';
cout << endl;
for(vector<int>::iterator i = a.begin();i != a.end(); i++)
cout << a[i] << ' ';
cout << endl;
//支持比较运算
vector<int> a(4, 3), b(3, 4);
if(a > b) cout << "a > b" << endl;
return 0;
}系统内某一程序分配空间时，所需时间，与空间大小无关，与中间次数有关
pair<int, int>：存储一个二元组
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<vector>
using namespace std;
int main()
{
pair<int, string>p;
p.first;
p.second;
//支持比较运算
//以first为第一关键词，以second为第二关键词
p = make_pair(10, "yxc");
p = {20, "abc"};
pair<int, pair<int>>w;
return 0;
}string
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int main()
{
string a = "yxc";
a += "def";
a += "c";
cout << a << endl;
cout << a.substr(2, 3) << endl;
return 0;
}queue队列
#include<iostream>
#include<queue>
#include<algorithm>
#include<vector>
using namespace std;
int main()
{
queue<int> q;
q = queue<int>;
//优先队列
priority_queue<int> heap;
heap.clear();
priority_queue<int, vector<int>, greater<int>> heap;//定义一个小根堆
return 0;
}stack栈
deque双端队列
size() empty() clear() front() back() push_front() pop_front() push_back pop_back() begin() end()
缺点就是deque比较慢
set
#include<iostream>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
int main()
{
set<int> S;
multiset<int> S1;//可以有重复元素，set不允许
S.insert(1);//插入一个数
S.find();//查找一个数
S.count();//返回某一个数的个数
S.erase();//1.输入的是一个数，就删除该数的所有存储 2.输入一个迭代器，就删除这个迭代器
S.lower_bound(x);//返回大于等于x的最小的数的迭代器
S.upper_bound(x);//返回大于x的最小数的迭代器
return 0;
}map/multimap
insert()插入的数是一个pair erase()输入的参数是pair或者是迭代器 find()
[] 时间复杂度是O(nlogn) 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
reset()把所有位都变成0
flip()等价~ flip(k)把第k位反转。
文章来源：https://www.toymoban.com/news/detail-600811.html
文章来源地址https://www.toymoban.com/news/detail-600811.html
到了这里，关于算法竞赛备赛之经典数据结构训练提升，暑期集训营培训的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
