vector

vector常用函数

#include<vector>
vector<int> a,b;
//b为向量，将b的0-2个元素赋值给向量a
a.assign(b.begin(),b.begin()+3);
//a含有4个值为2的元素
a.assign(4,2);
//返回a的最后一个元素
a.back();
//返回a的第一个元素
a.front();
//返回a的第i元素,当且仅当a存在
a[i];
//清空a中的元素
a.clear();
//判断a是否为空，空则返回true，非空则返回false
a.empty();
//删除a向量的最后一个元素
a.pop_back();
//删除a中第一个（从第0个算起）到第二个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+3（不包括它）结束
a.erase(a.begin()+1,a.begin()+3);
//在a的最后一个向量后插入一个元素，其值为5
a.push_back(5);
//在a的第一个元素（从第0个算起）位置插入数值5,
a.insert(a.begin()+1,5);
//在a的第一个元素（从第0个算起）位置插入3个数，其值都为5
a.insert(a.begin()+1,3,5);
//b为数组，在a的第一个元素（从第0个元素算起）的位置插入b的第三个元素到第5个元素（不包括b+6）
a.insert(a.begin()+1,b+3,b+6);
//返回a中元素的个数
a.size();
//返回a在内存中总共可以容纳的元素个数
a.capacity();
//将a的现有元素个数调整至10个，多则删，少则补，其值随机
a.resize(10);
//将a的现有元素个数调整至10个，多则删，少则补，其值为2
a.resize(10,2);
//将a的容量扩充至100，
a.reserve(100);
//b为向量，将a中的元素和b中的元素整体交换
a.swap(b);
//b为向量，向量的比较操作还有 != >= > <= <
a==b;

vector 创建二维数组

创建

vector<vector<int>>ans;
//不过这个时候ans 大小是0，不能访问。

初始化

// 创建有n行
vector<vector<int>>ans(N);
//n*m,并初始化为0
vector<vector<int>>ans(N,vector<int>(m,0));

例子

int main()
{while(cin>>n>>q){vector<vector<int>>ans(N);while(q--){cin>>fg;if(fg == 0){cin>>t>>x;ans[t].push_back(x);}else if(fg == 1){cin>>t;show(ans[t]);}else{cin>>t;ans[t].clear();}}}return 0;
}

list

list常用函数

Lst1.assign() 给list赋值
Lst1.back() 返回最后一个元素
Lst1.begin() 返回指向第一个元素的迭代器
Lst1.clear() 删除所有元素
Lst1.empty() 如果list是空的则返回true
Lst1.end() 返回末尾的迭代器
Lst1.erase() 删除一个元素
Lst1.front() 返回第一个元素
Lst1.get_allocator() 返回list的配置器
Lst1.insert() 插入一个元素到list中
Lst1.max_size() 返回list能容纳的最大元素数量
Lst1.merge() 合并两个list
Lst1.pop_back() 删除最后一个元素
Lst1.pop_front() 删除第一个元素
Lst1.push_back() 在list的末尾添加一个元素
Lst1.push_front() 在list的头部添加一个元素
Lst1.rbegin() 返回指向第一个元素的逆向迭代器
Lst1.remove() 从list删除元素
Lst1.remove_if() 按指定条件删除元素
Lst1.rend() 指向list末尾的逆向迭代器
Lst1.resize() 改变list的大小
Lst1.reverse() 把list的元素倒转
Lst1.size() 返回list中的元素个数
Lst1.sort() 给list排序
Lst1.splice() 合并两个list
Lst1.swap() 交换两个list
Lst1.unique() 删除list中重复的元素

遍历list

第一种

for(auto it = L.begin();it!=L.end();it++)cout<<*it<<endl;

第二种

for (auto e:L) {cout << e << endl;//auto循环更方便}

erase

erase 是删除之后会返回下一个位置。

如

cur = L.erase(cur);
//会讲 cur位置的元素删除掉，然后返回下一个位置的迭代器

insert

insert插入的是在当前位置的前一个位置，同时插入后返回插入位置的迭代器。
如

cur =  L.insert(cur,x);

splice

作用是将另一个list中的元素复制

 ans[t].splice(ans[t].end(),ans[s]);

queue

常用函数

1.入队：如q.push(x):将x元素接到队列的末端；2.出队：如q.pop() 弹出队列的第一个元素，并不会返回元素的值；3,访问队首元素：如q.front()4,访问队尾元素，如q.back();5,访问队中的元素个数，如q.size();

priority_queue

priority_queue常用函数

top 访问队头元素
empty 队列是否为空
size 返回队列内元素个数
push 插入元素到队尾 (并排序)
emplace 原地构造一个元素并插入队列
pop 弹出队头元素
swap 交换内容

大根堆，小根堆

默认是大顶堆

一般是：//升序队列
priority_queue <int,vector<int>,greater<int> > q;//大根堆
//降序队列
priority_queue <int,vector<int>,less<int> >q; //小根堆

// 也可以通过重载运算符来得到想要的根堆。

set

set常用函数

有一个multiset 是它的兄弟，区别是里边的元素可以是重复的，在函数使用上基本上是一样的，如erase，set删除的是单个，multiset 删除的是所有相同的。

begin();            // 返回指向第一个元素的迭代器
end();              // 返回指向迭代器的最末尾处（即最后一个元素的下一个位置）
clear();            // 清除所有元素
count();            // 返回某个值元素的个数empty();            // 如果集合为空，返回trueequal_range();      //返回集合中与给定值相等的上下限的两个迭代器erase()–删除集合中的元素find()–返回一个指向被查找到元素的迭代器get_allocator()–返回集合的分配器insert()–在集合中插入元素lower_bound()–返回指向大于（或等于）某值的第一个元素的迭代器key_comp()–返回一个用于元素间值比较的函数max_size()–返回集合能容纳的元素的最大限值rbegin()–返回指向集合中最后一个元素的反向迭代器rend()–返回指向集合中第一个元素的反向迭代器size()–集合中元素的数目swap()–交换两个集合变量upper_bound()–返回大于某个值元素的迭代器value_comp()–返回一个用于比较元素间的值的函数

find()

find()返回的是一个迭代器位置，如果没有找到则是end()

auto it = ans.find(n);if(it!=ans.end())cout<<1<<endl;elsecout<<0<<endl;

erase()

erase() 先通过 find()函数找到x元素的迭代器位置。如果不是end()就删除
注意：set中的erase（）无返回值。

if(it!=ans.end())ans.erase(it);

set取并集，交集，差集

基本介绍
set里面有set_intersection（取集合交集）、set_union（取集合并集）、set_difference（取集合差集）、set_symmetric_difference（取集合对称差集）等函数。

set_union

set_union(A.begin(),A.end(),B.begin(),B.end(),inserter(result,result.begin()));for(int i=0;i<result.size();i++){cout<<result[i]<<" ";}

set_intersection

set_intersection(A.begin(),A.end(),B.begin(),B.end(),inserter(result,result.begin()));for(int i=0;i<result.size();i++){cout<<result[i]<<" ";}

set_difference

set_difference(A.begin(),A.end(),B.begin(),B.end(),inserter(result,result.begin()));for(int i=0;i<result.size();i++){cout<<result[i]<<" ";}

注意事项

与 map/multimap 不同的是，map/multimap中存储的是真正的键值对<key,value>，set 中只放 value，但与底层实际存放的是由<value,value>构成的键值对；
set中插入元素时，只需要插入 value 即可，不需要构造键值对；
set中的元素不可以重复；
使用set 的迭代器遍历 set中的元素，可以得到有序序列；
set中的元素默认按照小于来比较
set中查找某个元素，时间复杂度为：log2N；

代码：

int main()
{while(~scanf("%d",&q)){multiset<int>ans;while(q--){scanf("%d%d",&fg,&n);if(fg == 0){ans.insert(n);int len = ans.size();printf("%d\n",len);}else if(fg == 1){int state = ans.count(n);printf("%d\n",state);}else if(fg == 2)ans.erase(n);else{int r;cin>>r;auto left = ans.lower_bound(n);while(left!=ans.end()&&*left<=r){printf("%d\n",*left);left++;}}}}return 0;
}

bitset

1、构造函数:

#include<bitset>
std::bitset<4> foo; //创建一个4位的位集，每一位默认为0
当整数的大小小于位数时，高位填充为0
std::bitset<4> foo(5);  //用整数初始化  5二进制位：101    foo值：0101
当整数的大小超过位数时，从整数二进制的低位开始赋值，高位被舍弃
std::bitset<4> foo(19);  //用整数初始化，19二进制位：10011     foo值：1100
std::bitset<4> foo(std:;string("0101")); //字符串初始化，字符串中必须只能含有‘0’/‘1’

2、常用操作：

位运算都可以用： 与、或、非、异或，左移，右移
foo&foo2
foo|foo2
~foo
foo^foo2
foo<<=2
foo>>=2
foo.size() 返回大小（位数）
foo.count() 返回1的个数
foo.any() 返回是否有1
foo.none() 返回是否没有1
foo.set() 全都变成1
foo.set(p) 将第p + 1位变成1
foo.set(p, x) 将第p + 1位变成x
foo.reset() 全都变成0
foo.reset(p) 将第p + 1位变成0
foo.flip() 全都取反
foo.flip(p) 将第p + 1位取反
foo.to_ulong() 返回它转换为unsigned long的结果，如果超出范围则报错
foo.to_ullong() 返回它转换为unsigned long long的结果，如果超出范围则报错
foo.to_string() 返回它转换为string的结果
b[pos] :访问b中在pos处的二进制位
b.test(pos) :   b中在pos处的二进制位是否为1？
b.set(pos)  把b中在pos处的二进制位置为1
b.reset(pos) 把b中在pos处的二进制位置为0

例子

int main()
{while(~scanf("%d",&q)){bitset<64>ans(0);while(q--){scanf("%d",&fg);if(fg == 0){scanf("%d",&n);cout<<ans[n]<<endl;}else if(fg == 1){scanf("%d",&n);ans.set(n);}else if(fg == 2){scanf("%d",&n);ans.reset(n);}else if(fg == 3){scanf("%d",&n);ans.flip(n);}else if(fg == 4){if(ans.count() == 64)printf("1\n");elseprintf("0\n");}else if(fg == 5){if(ans.any())printf("1\n");elseprintf("0\n");}else if(fg == 6){if(ans.none())printf("1\n");elseprintf("0\n");}else if(fg == 7){cout<<ans.count()<<endl;}else{cout<<ans.to_ullong()<<endl;}}}return 0;
}

string

数字的字典序比较

难点是将数字转化为字符，对于1位的加‘0’即可，但多位数的就不好处理，因此可以直接读入字符串。

int main()
{string s1,s2,s;cin>>n;for(int i=0;i<n;++i)cin>>s,s1 += s;cin>>m;for(int i=0;i<m;++i)cin>>s,s2 += s;if(s2>s1)cout<<1<<endl;elsecout<<0<<endl;return 0;
}

map

map的基本操作函数

C++ Maps是一种关联式容器，包含“关键字/值”对begin()          返回指向map头部的迭代器clear(）         删除所有元素count()          返回指定元素出现的次数empty()          如果map为空则返回trueend()            返回指向map末尾的迭代器equal_range()    返回特殊条目的迭代器对erase()          删除一个元素find()           查找一个元素get_allocator()  返回map的配置器insert()         插入元素key_comp()       返回比较元素key的函数lower_bound()    返回键值>=给定元素的第一个位置max_size()       返回可以容纳的最大元素个数rbegin()         返回一个指向map尾部的逆向迭代器rend()           返回一个指向map头部的逆向迭代器size()           返回map中元素的个数swap()            交换两个mapupper_bound()     返回键值>给定元素的第一个位置value_comp()      返回比较元素value的函数

erase() 删除元素

• size_t erase( const key_type& key );
  根据key来进行删除， 返回删除的元素数量，在map里结果非0即1
• iterator erase( iterator pos )
  删除迭代器指向位置的键值对，并返回一个指向下一元素的迭代器
• iterator erase( const_iterator first, const_iterator last );
  删除一定范围内的元素，并返回一个指向下一元素的迭代器

注意事项

• 使用insert方法插入的时候，如果键存在，不会覆盖原来的值，用数组的方式才可以。
• 还有一个很重要的点就是，如果访问了一个不存在的键，那么会返回0之后会自动创建这个键。
  因此可以如下来解决

cin>>s;if(!ans.count(s))cout<<0<<endl;elseprintf("%d\n",ans[s]);

multimap

multimap容器保存的是有序的键/值对，但是可以保存重复的元素。multimap中会出现具有相同键值的元素序列。multimap大部分成员函数的使用方式和map相同。因为重复键的原因，multimap有一些函数的使用方式和map有一些区别。

访问元素

单个find()

multimap 的成员函数 find() 可以返回一个键和参数匹配的元素的迭代器。

std::multimap<std::string, size_t> people {{"Ann",25},{"Bill", 46}, {"Jack", 77}, {"Jack", 32},{"Jill", 32}, {"Ann", 35} };
std::string name {"Bill"};
auto iter = people.find(name);
if (iter ! = std::end (people))std::cout << name << " is " << iter->second << std::endl;
iter = people.find ("Ann");
if (iter != std::end(people))std::cout << iter->first << " is " << iter->second <<std::endl;

equal_range

如果我们想访问给定键对应的所有元素。成员函数 equal_range() 就可以做到这一点。它会返回一个封装了两个迭代器的 pair 对象，这两个迭代器所确定范围内的元素的键和参数值相等。例如：

auto pr = people.equal_range("Ann");
if(pr.first != std::end(people))
{for (auto iter = pr.first ; iter != pr.second; ++iter)std:cout << iter->first << " is " << iter->second << std::endl;
}

insert()

只能使用insert来插入元素
例如：

ans.insert(make_pair(s,x));

reverse

区间是左闭右开的。

reverse函数用于反转在**[first,last)**范围内的顺序（包括first指向的元素，不包括last指向的元素），reverse函数无返回值

rotate

template <class ForwardIterator>void rotate (ForwardIterator first, ForwardIterator middle,ForwardIterator last);

官方手册

全排列函数

头文件：#include
函数模板：next_permutation(arr, arr+size);
函数模板：prev_permutation(arr, arr+size);
解释：arr为数组，size为数组长度。next_permutation(arr, arr+size);当有下一个较大值返回1，否则返回0，prev_permutation(arr, arr+size);当有上一个较小值返回1，否则返回0。例如：3 2 1，只有上一个较小值，没有下一个较大值。1 2 3只有下一个较大值，没有上一个较小值。2 1 3 的上一个较小值为 1 3 2，下一个较大值为 2 3 1.明白了吧！然后看下代码，怎么去用：

includes(子集)

在stl中有一个includes函数，对于vector来说，有v1和v2，如果判断v1里面的所有元素是否被v2所包含，则可以使用

includes(begin(v1),end(v1),begin(v2),end(v2))  

如果v1包含v2则会返回true。
注意使用前提是必须先进行排序
即sort(begin(v1),end(v1)) sort(begin(v2),end(v2))

二分查找

首先数组必须是有序的！

1.binary_search()（查找某个值在数组中是否存在）

使用方法：binary_search(list,list+n,a)

list为数组，a为要查询的值,n为数组大小

binary_search返回的是真假值，就是它只判断这个数组中是否存在这个数；

2. lower_bound查找第一个大于或等于某个元素的位置

使用方法：lower_bound(list,list+n,a)

list为数组，n为数组大小，a为要查询的值

注意事项：lower_bound()返回的是指针，所以所以减去数组的指针就是int变量了

3.upper_bound查找第一个大于某个元素的位置。

算法训练之STL使用汇总相关推荐

1. ACM算法训练赛——STL（完结）

   STL训练赛 A - JiaoZhu and SC #include <bits/stdc++.h> #define int long long #define rep(i, a, b) ...

2. 可由一个尾指针唯一确定的链表有_极客算法训练笔记(三)，链表详细图解，别再逃避了朋友...

   目录 缓存引爆链表 链表单链表双向链表循环链表双向循环链表 LinkedHashMap实现LRU缓存,源码解析(JDK1.8) 算法 爬楼梯 算法 反转链表 算法 链表环检测 缓存引爆链表 存储结构 ...

3. GitHub高赞，针对小白的算法训练仓库

   在家隔离的日子也是好好学习提高的日子,今天TJ君看到了一个专门针对小白的算法训练,感觉不错,和大家一起来分享一下. 整个学习流程有四个步骤,分别是: PART_1_算法基础 PART_2_力扣图解 P ...

4. 严蔚敏算法约瑟夫环_极客算法训练笔记(三)，链表详细图解，别再逃避了朋友...

   目录 缓存引爆链表 链表 单链表 双向链表 循环链表 双向循环链表 LinkedHashMap实现LRU缓存,源码解析(JDK1.8) 算法 爬楼梯 算法 反转链表 算法 链表环检测 缓存引爆链表 存 ...

5. 算法训练一（贪心、二分）（含解题思路）（下）

   目录 7-15种树(贪心) AC代码: 7-16会场安排问题(贪心) AC代码: 7-17最优合并问题(贪心) AC代码: 7-18简简单单的数学题(位运算 + 哈希表) AC代码: 7-19h148 ...

6. 算法训练 装箱问题（贪心，动态规划，蓝桥杯,C++）

   算法训练 装箱问题 资源限制 时间限制:1.0s 内存限制:256.0MB 问题描述 有一个箱子容量为V(正整数,0<＝V<＝20000),同时有n个物品(0<n<＝30),每 ...

7. 代码随想录算法训练Day11 LeetCode232. 用栈实现队列（模拟）；225.用队列实现栈(模拟）；20. 有效的括号（栈应用）；1047. 删除字符串中的所有相邻重复项（栈应用）

   代码随想录算法训练Day11 | LeetCode232. 用栈实现队列(模拟):225.用队列实现栈(模拟):20. 有效的括号(栈应用):1047. 删除字符串中的所有相邻重复项(栈应用) 关于栈 ...

8. 魔改算法——YOLOv5/YOLOv7改进系列汇总

   魔改YOLO系列算法改进: 改进YOLOv5/YOLOv7--魔改YOLOv5/YOLOv7提升检测精度__加勒比海带66的博客 目标检测算法--YOLOv7训练自己的数据集(保姆级教程) 目标检测算 ...

9. 目前最好用的大规模强化学习算法训练库是什么？

   点击蓝字  关注我们 本文整理自知乎问答,仅用于学术分享,著作权归作者所有.如有侵权,请联系后台作删文处理. 本文精选知乎问题"目前最好用的大规模强化学习算法训练库是什么?"评论区 ...

最新文章

1. 高通fastmmi（ffbm）的使用
2. erlang/thrift快速安装
3. express开发实例
4. SQL利用Case When Then多条件判断
5. iOS Dev (60) 怎样实现 UITextView 中的 placeHolder
6. 里面的自带的字典在哪里_影视剪辑高清素材哪里找？4种方法教你，适合新手入门...
7. 06-03 Jenkins 节点管理（Linux）
8. mac硬盘挂载不显示（exfat格式）
9. 用SQL语句实现：当A列大于B列时选择A列否则选择B列，当B列大于C列时选择B列否则选择C列。...
10. 基于内容的图像检索系统（合集）
11. java servlet 3.1,Servlet 3.1规范学习小记
12. ghost系统卡正在启动服务器,安装win7系统卡在正在启动windows界面的解决方法
13. 3D Point Cloud Descriptors in Hand-crafted and Deep Learning Age: State-of-the-Art
14. 计算机控制技术课程配套教材习题解答（第1、2、3章）
15. windows录屏_Windows电脑怎么录制屏幕？查看电脑自动录屏方法
16. 手绘图像检索：Deep Spatial-Semantic Attention for Fine-Grained Sketch-Based Image Retrieval
17. Win7环境安装Anaconda
18. Java中LinkedList详解
19. dayjs，当年月周日
20. Android FaceBook登录问题记录

热门文章

1. mysql在线模拟器_SQL在线模拟器
2. linux 进程间通信 dbus-glib【实例】详解一（附代码）（d-feet工具使用）
3. 如何遍历numpy数组？
4. pytorch torch.Tensor.new_ones()（返回一个与size大小相同的用1填充的张量。 默认返回的Tensor具有与此张量相同的torch.dtype和torch.device）
5. python os 文件操作 chdir(path)方法
6. python 原始字符串r的用法
7. python lambda表达式的使用方法（匿名函数）
8. Luntik and Subsequences 思维
9. MAT分析器查看jvm dump文件
10. Linux下Keepalived安装与配置