由于做了更多的题，对STL的用法也稍微有了一些领悟，结合y总的教案小小的总结一下
1

#include <vector>

1.1 声明

1 vector<int> a //相当于一个长度动态变化的int数组
2 vector<int> a(n) 
/**
*跟第一个类似，可以在读入时直接cin >> a[i],
*同时长度为n的数组初始为0，避免在声明局部变量数组的时候需要将所有数组元素初始成0
*vector<int> a(n, x) 表示将长度为n的a[i]赋成x
*vector dp(n + 1, vector<int> (m + 1, 0)) 类型vector<vector<int>>类似二维数组，可以直接进行访问
*/
3 vector<int> a[n] //声明一个一维长n，第二位长度动态变化的int数组
4 struct rec{...} vector<rec> a // 自定义的结构体类型也可以保存在vector中

1.2 主要作用

1 直接当数组用
2 离散化
3 高精度
4 存图
5 tarjan强连通分量
/**
* vector<int> e;
* for (int i = 0; i < n; i ++) 
* {
*     int a, b; cin >> a >> b;
*     e[a].push_back(b);
*     e[b].push_back(a);//无向图存储
*  }
*/

1.3 主要函数

vector<int> a;
1 a.size() //返回a中元素数量
2 a.empty() //返回a中是否有元素，若没有返回true，有返回false
3 a.push_back(x) //将x插入a的尾部
4 a.pop_back() //删除a的最后一个元素
5 a.clear() //将a清空，如果a是多维的，需要一维一维清空
6 a.begin() //返回a中第一个元素的迭代器
7 a.end() //返回a的尾部，但注意这是越界访问，相当于访问a[n]，其中n = a.size()
8 a.front() //返回a中的第一个元素，等价于a[0], *a.begin()
9 a.back() //返回a中的最后一个元素，等价于a[n - 1], *(--a.end())，其中n = a.size()

1.4 迭代器

和指针类似，如果需要访问该迭代器指向的数，需要加*解除引用
类型 vector<int> :: iterator //对于vector<int> 而言
vector的迭代器是“随机访问迭代器”，可以把vector的迭代器与一个整数相加减，其行为和指针的移动类似。
可以把vector的两个迭代器相减，其结果也和指针相减类似，得到两个迭代器对应下标之间的距离。

1.5 遍历方式

for (int i = 0; i < a.size(); i ++)
    cout << a[i] << endl;

for (vector<int>::iterator it = a.begin(); it != a.end(); it ++)
    cout << *it << endl;

2

include <queue>

2.1 声明

queue<int> q;
struct rec{…}; queue<rec> q;
priority_queue<int> q;                              // 大根堆,若在里面存放结构体，需要重新定义小于号
priority_queue<int, vector<int>, greater<int>> q;   // 小根堆，若存放结构体，需要重新定义大于号
priority_queue<pair<int, int>> q;
下面给出存放结构体的示范
大根堆
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;
struct e
{
    int x, y;
    bool operator < (const e & W) const
    {
        return y < W.y;
    }
};

int main()
{
    priority_queue<e> q;
    q.push({1, 2}), q.push({2, 4});
    cout << q.top().y << endl;
}
小根堆
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;
struct e
{
    int x, y;
    bool operator > (const e & W) const
    {
        return y > W.y;
    }
};

int main()
{
    priority_queue<e, vector<e>, greater<e>> q;
    q.push({1, 2}), q.push({2, 4});
    cout << q.top().y << endl;
}

2.2 主要作用

1 队列主要用于bfs，spfa
2 优先队列中的小根堆用于dijkstra最短路，每次弹出队列中最小的元素
3 大根堆用于一些比较特殊的dijkstra，例如求最大路的时候会用，可参考1026最小花费
4 某些CF上的思维题会用

2.3 主要函数

queue
push    // 从队尾插入
pop     // 从队头弹出
front   // 返回队头元素
back    // 返回队尾元素

priority_queue
push    // 把元素插入堆
pop     // 删除堆顶元素
top     // 查询堆顶元素（最大值）

3

#include <stack>

3.1 主要作用

目前只发现可以进行括号匹配
强连通分量tarjan算法

3.2 主要函数

push    // 向栈顶插入
pop     // 弹出栈顶元素

4

#include <deque>

4.1 主要用途

spfa的SLF优化（只是对数据进行优化，想卡还是可以卡掉）
双端队列广搜
在边权只有0，1时可以用deque代替queue实现bfs，性能优于priority_queue
目前还没遇到其他的，待补充

4.2 主要函数

[]              // 随机访问
begin/end       // 返回deque的头/尾迭代器
front/back      // 队头/队尾元素
push_back       // 从队尾入队
push_front      // 从队头入队
pop_back        // 从队尾出队
pop_front       // 从队头出队
clear           // 清空队列

5

#include <set>

头文件set主要包括set和multiset两个容器，分别是“有序集合”和“有序多重集合”，即前者的元素不能重复，而后者可以包含若干个相等的元素。set和multiset的内部实现是一棵红黑树，它们支持的函数基本相同。
5.1 声明

set<int> s;
struct rec{…}; set<rec> s;  // 结构体rec中必须定义小于号
multiset<double> s;

5.2 主要用途

思维题
待完善

5.3 主要函数

5.2 size/empty/clear
与vector类似

5.3 迭代器
set和multiset的迭代器称为“双向访问迭代器”，支持星号*解除引用。仅支持++和--两个与算术相关的操作。
注意这玩意不支持随机访问，不支持随机访问，也就是说s[i]是不对的

设it是一个迭代器，例如set<int>::iterator it;

若把it ++，则it会指向“下一个”元素。这里的“下一个”元素是指在元素从小到大排序的结果中，排在it下一名的元素。
同理，若把it --，则it将会指向排在“上一个”的元素。

5.4 begin/end
返回集合的首、尾迭代器，时间复杂度均为 O(1)

s.begin()是指向集合中最小元素的迭代器。

s.end()是指向集合中最大元素的下一个位置的迭代器。换言之，就像vector一样，是一个“前闭后开”的形式。
因此s.end()是指向集合中最大元素的迭代器。

5.5 insert
s.insert(x)把一个元素x插入到集合s中，时间复杂度为 O(logn)

在set中，若元素已存在，则不会重复插入该元素，对集合的状态无影响。

5.6 find
s.find(x)在集合s中查找等于x的元素，并返回指向该元素的迭代器。若不存在，则返回s.end()。
时间复杂度为 O(logn)

5.7 lower_bound/upper_bound
这两个函数的用法与find类似，但查找的条件略有不同，时间复杂度为 O(logn)

s.lower_bound(x)查找大于等于x的元素中最小的一个，并返回指向该元素的迭代器。

s.upper_bound(x)查找大于x的元素中最小的一个，并返回指向该元素的迭代器。
注意这俩不能学数组一样减一个s.begin()，不然会报错
5.8 erase
设it是一个迭代器，s.erase(it)从s中删除迭代器it指向的元素，时间复杂度为 O(logn)

设x是一个元素，s.erase(x)从s中删除所有等于x的元素，时间复杂度为 O(k+logn)，其中 k是被删除的元素个数。

5.9 count
s.count(x)返回集合s中等于x的元素个数，时间复杂度为 O(k+logn)，其中 k 为元素x的个数。

6

#include <map>

map容器是一个键值对key-value的映射，其内部实现是一棵以key为关键码的红黑树。Map的key和value可以是任意类型，其中key必须定义小于号运算符。
6.1 声明

map<key_type, value_type> name;

//例如：
map<long long, bool> vis;
map<string, int> hash;
map<pair<int, int>, vector<int>> test;

6.2 主要作用

1 记录路径，例如提高课中的八数码
2 思维题

6.3 主要函数

6.2 size/empty/clear/begin/end
均与set类似。

6.3 insert/erase
与set类似，但其参数均是pair<key_type, value_type>。

6.4 find
h.find(x)在变量名为h的map中查找key为x的二元组。

6.5 []操作符
h[key]返回key映射的value的引用，时间复杂度为 O(logn)

[]操作符是map最吸引人的地方。我们可以很方便地通过h[key]来得到key对应的value。
同时可以对h[key]进行赋值操作，改变key对应的value。

7

#include <unordered_map>

与map很像，区别是map对于insert的变量会自动排序，而unordered_map不会，查找效率非常高可以达到O(1)，但缺点是，unordered_map是可以被卡的，如果制造很多哈希冲突就会导致查询效率非常低，所以貌似CF大佬都喜欢用map