ACM寒假集训#1

最新推荐文章于 2022-06-09 16:47:42 发布

MJ的码农空间

最新推荐文章于 2022-06-09 16:47:42 发布

阅读量550

点赞数 3

分类专栏： ACM寒假集训文章标签： c++ stl

本文链接：https://blog.csdn.net/Michael___J/article/details/112909441

版权

ACM寒假集训专栏收录该内容

7 篇文章 0 订阅

订阅专栏

ACM寒假集训

Day One

MJ的第一条博客

各大OJ网站

https://vjudge.net/
https://www.nowcoder.com/
https://pintia.com/

竞赛常用语言C++

绝大部分情况下用C++（效率高、code速度快），少数情况用Java（有大数）、Python（兼容度不高）
输入输出：cin cout
数组尽量放全局
数组尽量开大

时间（空间）复杂度

时间复杂度：又称时间复杂性，用来描述程序运行时间与输入数据规模的函数关系
算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f (n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。

时间（空间）复杂度

时间复杂度只保留最高项，忽略常数
O(2n^2+5n+10)=O(n2)
O(2ⁿ⁺ⁿ100+5)=O(2^n)
O(3n+logn)=O(n)
O(1000)=O(1)

常见算法的复杂度O(n) O(n^2) O(nlogn) O(2^n)
在这里插入图片描述

STL

STL：C++标准模板库（Standard Template Library）

容器：string vector queue stack set map list

函数：sort reverse next_permutation

C++的各类头文件

#include<bits/stdc++.h>//万能头文件
#include <algorithm>　　　 //STL通用算法
#include <bitset>　　　　　//STL位集容器
#include <cctype>                //字符处理
#include <cerrno>　　　　 //定义错误码
#include <clocale>　　　　//定义本地化函数
#include <cmath>　　　　　//定义数学函数
#include <complex>　　　　 //复数类
#include <cstdio>　　　　//定义输入／输出函数
#include <cstdlib>　　　　//定义杂项函数及内存分配函数
#include <cstring>　　　　//字符串处理
#include <ctime>　　　　　//定义关于时间的函数
#include <deque>　　　　　 //STL双端队列容器
#include <exception>　　　 //异常处理类
#include <fstream>　　　//文件输入／输出
#include <functional>　　　//STL定义运算函数（代替运算符）
#include <limits>　　　　//定义各种数据类型最值常量
#include <list>　　　　　　//STL线性列表容器
#include <map>　　　　　　 //STL 映射容器
#include <iomanip>　　　//参数化输入／输出
#include <ios>　　　　　　//基本输入／输出支持
#include<iosfwd>　　　　　//输入／输出系统使用的前置声明
#include <iostream>　　　//数据流输入／输出
#include <istream>　　　　 //基本输入流
#include <ostream>　　　　 //基本输出流
#include <queue>　　　　　 //STL队列容器
#include <set>　　　　　　 //STL 集合容器
#include <sstream>　　　　//基于字符串的流
#include <stack>　　　　　 //STL堆栈容器　　　　
#include <stdexcept>　　　 //标准异常类
#include <streambuf>　　　//底层输入／输出支持
#include <string>　　　　　//字符串类
#include <utility>　　　　 //STL通用模板类
#include <vector>　　　　　//STL动态数组容器
#include <cwchar>　　　　//宽字符处理及输入／输出
#include <cwctype>　　　　//宽字符分类

string

string是C++标准库的一个重要的部分，主要用于字符串处理。可以使用输入输出流方式直接进行string操作，也可以通过文件等手段进行string操作。同时，C++的算法库对string类也有着很好的支持，并且string类还和c语言的字符串之间有着良好的接口。

动态长度字符串
构造函数 string s1="1234"
迭代器：string::iterator it=s1.begin()
常用函数：
a) =,assign()   //赋以新值
b) swap()  //交换两个字符串的内容
c) +=,append(),push_back() //在尾部添加字符
d) insert() //插入字符
e) erase() //删除字符
f) clear() //删除全部字符 
g) replace() //替换字符
h) + //串联字符串
i) ==,!=,<,<=,>,>=,compare()  //比较字符串
j) size(),length()  //返回字符数量
k) max_size() //返回字符的可能最大个数
l) empty()  //判断字符串是否为空
m) capacity() //返回重新分配之前的字符容量
n) reserve() //保留一定量内存以容纳一定数量的字符
o) [ ], at() //存取单一字符
p) >>,getline() //从stream读取某值
q) <<  //将谋值写入stream
r) copy() //将某值赋值为一个C_string
s) c_str() //将内容以C_string返回
t) data() //将内容以字符数组形式返回
u) substr() //返回某个子字符串
v) find()//查找函数
w) begin() end() //提供类似STL的迭代器支持
x) rbegin() rend() //逆向迭代器
y) get_allocator() //返回配置器

vector

动态数组，内存连续

构造函数:vector<int>v1;vector<string>v2("1234");
vecotr<int>v3(5,2);vector<int>v4(v3);
可以随机访问 访问O(1) 删除O(n)
常用函数：
	（1）a.assign(b.begin(), b.begin()+3); //b为向量，将b的0~2个元素构成的向量赋给a
    （2）a.assign(4,2); //是a只含4个元素，且每个元素为2
    （3）a.back(); //返回a的最后一个元素
    （4）a.front(); //返回a的第一个元素
    （5）a[i]; //返回a的第i个元素，当且仅当a[i]存在2013-12-07
    （6）a.clear(); //清空a中的元素
    （7）a.empty(); //判断a是否为空，空则返回ture,不空则返回false
    （8）a.pop_back(); //删除a向量的最后一个元素
    （9）a.erase(a.begin()+1,a.begin()+3); //删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+         3（不包括它）
    （10）a.push_back(5); //在a的最后一个向量后插入一个元素，其值为5
    （11）a.insert(a.begin()+1,5); //在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
    （12）a.insert(a.begin()+1,3,5); //在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5
    （13）a.insert(a.begin()+1,b+3,b+6); //b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8         ，插入元素后为1,4,5,9,2,3,4,5,9,8
    （14）a.size(); //返回a中元素的个数；
    （15）a.capacity(); //返回a在内存中总共可以容纳的元素个数
    （16）a.resize(10); //将a的现有元素个数调至10个，多则删，少则补，其值随机
    （17）a.resize(10,2); //将a的现有元素个数调至10个，多则删，少则补，其值为2
    （18）a.reserve(100); //将a的容量（capacity）扩充至100，也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才         显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能） 
    （19）a.swap(b); //b为向量，将a中的元素和b中的元素进行整体性交换
    （20）a==b; //b为向量，向量的比较操作还有!=,>=,<=,>,<

queue

队列，先进先出(FIFO)  打印机、排队队伍

构造函数:
queue<int>qu;
常用函数：
push() //插入字符	
pop() //删除字符
front() //返回第一个元素
back() //返回最后一个元素
size() //返回元素个数
empty()//判断是否为空，空则返回ture

stack

堆栈，先进后出(FILO)

构造函数stack<int>st;
常用函数：
push() //插入字符
pop() //删除字符
top() //返回最顶端元素
size() //返回元素个数
empty()//判断是否为空，空则返回ture

set

集合，元素有序排列、不重复
构造函数:set<int>se
常用函数:
insert() //插入元素
erase() //删除元素
find() //返回元素位置
size() //返回元素个数
clear() //清空容器
count()//返回某一元素个数
lower_bound(x)//大于等于x的第一个元素位置，不存在返回end()
upper_bound(x)//大于x的第一个元素位置，不存在返回end()
查询、插入、删除O(logn）

map

字典，key-value键值对，按key有序排列

构造函数:map<int,int>mp
常用函数:
erase() //删除元素
find() //返回查找元素位置
size() //返回元素个数
clear() //清空容器
count() //返回某一元素个数
lower_bound() //从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。
upper_bound()//从数组的begin位置到end-1位置二分查找第一个大于num的数字，找到返回该数字的地址，不存在则返回end
可以像数组一样通过[]访问
插入、删除O(logn）

list

双向链表，内存不连续

构造函数:list<int>li
常用函数:
push_back() //在最后插入字符
push_front() //在开头插入字符
pop_back() //删除最后的字符
pop_front() //删除开头的字符
insert() //插入字符
erase()//删除字符
不支持随机访问，插入、删除O(1)，与vector相反

sort

vector<int>ve({4,3,5,2,6,1}); 
sort(ve.begin(),ve.end());
sort(ve.begin(),ve.end(),greater<int>());
bool cmp(int a,int b)
{
	if(a%2==b%2) return a<b;
	return a%2>b%2;
}
sort(ve.begin(),ve.end(),cmp);

reverse

翻转数组、容器
int x[1005];
reverse(x+1,x+1+n);
vector<int>ve;
reverse(ve.begin(),ve.end());

next_permutation

求全排列中字典序更大的一个序列，不存在更大时返回false
int x[105];
int n=5;
for(int i=1;i<=n;i++)x[i]=i;
do{
	for(int i=1;i<=n;i++)printf("%d ",x[i]);
	puts("");
}while(next_permutation(x+1,x+1+n));

MJ的码农空间

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
ACM寒假集训#1

*ACM寒假集训Day OneMJ的第一条博客各大OJ网站https://vjudge.net/https://www.nowcoder.com/https://pintia.com/竞赛常用语言C++绝大部分情况下用C++（效率高、code速度快），少数情况用Java（有大数）、Python（兼容度不高）输入输出：cin cout数组尽量放全局数组尽量开大时间（空间）复杂度时间复杂度：又称时间复杂性，用来描述程序运行时间与输入数据规模的函数关系算法中基本操作重复执行的次数是
复制链接

扫一扫