库函数笔记

向上取整double ceil(double x)

C++11扩展：提供ceilf（float）、ceill（long double）
除数a被除数b -> a/b向上取整可以表示为(a+b-1)/b

ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);

关io同步流，减少输入输出时间复杂度，但导致scanf不能一起用。

unique 去重

http://t.csdnimg.cn/rEFrD

  1. 函数作用：“去除”容器或数组中相邻元素之间重复出现的元素（所以一般使用前需要排序）。
  2. 函数参数：第一个参数是集合的起始地址，第二个参数是集合的最后一个元素的下一个元素的地址（其实还有第三个参数，比较函数，但是几乎不用，就不说了，其实和sort函数很像）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include <algorithm>
int main(void){
    int a[8] = {2, 2, 2, 4, 4, 6, 7, 8};
    int c;
    std::sort(a, a + 8);  //对于无序的数组需要先排序
    c = (std::unique(a, a + 8) - a );
    std::cout<< "c = " << c << std::endl;//去重函数返回地址为：去重后最后一个不重复元素地址
    //打印去重后的数组成员
    for (int i = 0; i < c; i++)
        std::cout<< "a = [" << i << "] = " << a[i] << std::endl;
    return 0;
}
//运行结果：c=5
//a数组前五项：2 4 6 7 8

vector容器去重

1
2
3
4
5
6
std::vector<int> ModuleArr;
//排序
std::sort(ModuleArr.begin(), ModuleArr.end());
//去重
ModuleArr.erase(unique(ModuleArr.begin(), ModuleArr.end()), ModuleArr.end());

reverse 翻转

翻转一个 vector：

1
reverse(a.begin(), a.end());

翻转一个数组，元素存放在下标 1~n：

1
reverse(a + 1, a + n + 1);

random_shuffle 随机打乱

用法与 reverse 相同

sort 排序

对两个迭代器（或指针）指定的部分进行快速排序。可以在第三个参数传入定义大小比较的函数，或者重载“小于号”运算符。默认从小到大

把一个int数组（元素存放在下标1~n）从大到小排序，传入比较函数：

1
2
3
4
5
6
7
8
int a[MAX_SIZE];

bool cmp(int a, int b) {return a > b; }

sort(a + 1, a + 1 + n, cmp);

//或者
sort(a + 1, a + n, greater<int());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
把自定义的结构体vector排序，重载“小于号”运算符：

struct rec{ int id, x, y; }

vector<rec> a;

bool operator <(const rec &a, const rec &b) {

    return a.x < b.x || a.x == b.x && a.y < b.y;

}

sort(a.begin(), a.end());
//或者
struct rec{
    int xh,year;
    string id;
}a[50005];
bool cmp(rec x,rec y)
{
    return x.xh>y.xh;
}

lower_bound/upper_bound 二分

lower_bound 的第三个参数传入一个元素x，在两个迭代器（指针）指定的部分上执行二分查找，返回指向第一个大于等于x的元素的位置的迭代器（指针）。

upper_bound 的用法和lower_bound大致相同，唯一的区别是查找第一个大于x的元素。当然，两个迭代器（指针）指定的部分应该是提前排好序的。

在有序int数组（元素存放在下标1~n）中查找大于等于x的最小整数的下标：

1
int I = lower_bound(a + 1, a + 1 + n, x) – a;

在有序vector 中查找小于等于x的最大整数（假设一定存在）：

1
int y = *--upper_bound(a.begin(), a.end(), x);

memset 初始化

1
2
3
4
5
6
7
void memset(void *ptr, int value, int size_num);
//ptr  指向要设置值的指针
//value 要设置的整数
//size_num 字节数

int a[10];
memset(a,0,sizeof(arr));

​

fill初始化

1
2
3
4
5
6
7
8
#include <algorithm> // 包含 std::fill
#include <vector>
 
int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::fill(vec.begin(), vec.end(), 0); // 将 vec 中的所有元素设置为 0
    return 0;
}

swap 交换

swap可以交换任意类型的变量，包括整形，浮点型，结构体，类对象等。

1
swap(a,b);

islower/isupper 大小写判断

判断一个字符是否为小写或者大写，返回值为bool类型

tolower/toupper 大小写转换

将一个字符转换成小写或者大写

cout<<fixed << setprecision() 控制小数点位数

加fixed固定小数点位数，会影响后面的cout，不加则不影响

next_permutation全排列函数实现升序

1
2
3
4
5
next_permutaion(起始地址，末尾地址+1)
next_permutaion(起始地址，末尾地址+1，自定义排序)
bool cmp(test t1,test t2){//自定义的排列 
	return t1.val<t2.val;
}

prev_permutation实现降序同上

count统计元素个数

1
count(first,last,value); first是容器的首迭代器，last是容器的末迭代器，value是询问的元素。返回元素个数

stoll将string转long long

1
long long stoll (const string& str, size_t* pos = 0, int base = 10);

参数说明：

  • str：要转换为长长整型的字符串。
  • pos：可选参数，用于指定从字符串的哪个位置开始转换。如果转换成功，pos 将被更新为转换后的字符串的下一个字符位置。如果不需要使用这个参数，可以将其设置为 nullptr。
  • base：可选参数，用于指定转换的基数，默认为 10（十进制）。可以使用其他进制，如 2（二进制）、8（八进制）、16（十六进制）等。

min_element()和max_element

作用：返回容器中第一个最小值和最大值
max_element(first,end,cmp);其中cmp为可选择参数

String大全