关于STL的大整理

set

集合，用于去重和排序。

用法

set<type> name;

常用函数

//时间复杂度O(logn)

insert() //插入元素，自动排序
//示例
s.insert(3);s.insert(1);s.insert(2);s.insert(4);s.insert(1);s.insert(5);
//输出1 2 3 4 5

find()  //查找一个数,返回迭代器

count()  //返回某一个数的个数
//示例
cout << s.count(1) << endl;
//返回1的个数，若是 multiset 可以返回总共多少个。

erase()
    (1) 输入是一个数x，删除所有x   O(k + logn)
    (2) 输入一个迭代器，删除这个迭代器
lower_bound()/upper_bound()
    lower_bound(x)  返回大于等于x的最小的数的迭代器
    upper_bound(x)  返回大于x的最小的数的迭代器

用法

• 输出头尾元素，可以用作‘双端优先队列’
  cout << *st.begin(); << " " << *(--st.end());
  或者

set<元素类型>::iterator it = se.end(); //auto 也可以
it--;
cout << *it << endl;

• set自定义cmp
  示例：

struct cmp
{
	bool operator() (const int &a,const int &b) 
	{
		return a < b;
	}
};

set<int,greater<int> > s;
set<int,cmp> s;

//同理pq也有这种用法
priority_queue<int ,vector<int>,cmp> q;

记录一个比较奇葩的东西。

点击查看代码

struct cmp
{
	bool operator ()(const int & a,const int &b)
	{
		return a <b;
	}
};

struct node
{
	int x,b;
	bool operator < (const node &a) const
	{
		return x < a.x;
	};
};
priority_queue<int,vector<int>,cmp> q;
priority_queue<node> q2;
set<node> s;
int main()
{
	q.push(2);q.push(3);q.push(1);
	cout << q.top() << endl;
	q2.push({2,0});q2.push({3,0});q2.push({1,0});
	cout << q2.top().x << endl;
	s.insert({2,0});s.insert({3,0});s.insert({1,0});
	cout << (*s.begin()).x << endl;
	return 0;
}

//3
//3
//1

简而言之，在结构体中写自定义比较函数，比如是小于号，则sort和set里使用时则是按照升序排序，而priority_queue中则是降序排序。

• 操控 it 左右移动的方式

//第一种
auto it = s.lower_bound(x);
it--,it++;
// 第二种
it = prev(it);
it = next(it);

时间复杂度 $O(\log n)$

array

功能更加强大的数组
用法：

array<元素类型,长度> a;

示例：

array<ll,6> a;
//等同于：
ll a[6];

它甚至可以用于哈希：

map<array<ll,6>,int> mp;

array<ll,6> a;

int main()
{
	a[1] = 1,a[2] = 2,a[3] = 3,a[4] = 4,a[5] = 5;
	mp[a]+=3;
	a[1] = 2;
	a[1] = 1;
	cout << mp[a] << endl;
	return 0;
}

rope

//头文件
#include <ext/rope>
using namespace __gnu_cxx;

//用法
rope<数据类型> 名称;
//如：
rope<int> rp;
rope<long long> r1;
rope<char> r2;
struct node{...};
rope<node> r3;
rope<int> r4(100);

整理自：（https://zhuanlan.zhihu.com/p/675904773）

bitset

#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值：0011

std::bitset<4> foo(std::string("0101")); //字符串初始化，字符串中必须只能含有‘0’/‘1’

位运算都可以用： 与、或、非、异或，左移，右移
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的结果
foo._Find_next(id) 返回 id 下一个 1 的位置
foo._Find_first() 返回第一个 $1$。

bitset<8> foo ("10011011");

cout << foo.count() << endl;　　//5　　（count函数用来求bitset中1的位数，foo中共有５个１
cout << foo.size() << endl;　　 //8　　（size函数用来求bitset的大小，一共有８位

cout << foo.test(0) << endl;　　//true　　（test函数用来查下标处的元素是０还是１，并返回false或true，此处foo[0]为１，返回true
cout << foo.test(2) << endl;　　//false　　（同理，foo[2]为０，返回false

cout << foo.any() << endl;　　//true　　（any函数检查bitset中是否有１
cout << foo.none() << endl;　　//false　　（none函数检查bitset中是否没有１
cout << foo.all() << endl;　　//false　　（all函数检查bitset中是全部为１

整理自https://blog.csdn.net/qq_44918090/article/details/130118709

运算符优先级

结构体运算符重载

struct test
{
    int a,b,c;
};

bool operator < (test a,test b)
{
    return a.a < b.a; // ...
}

priority_queue<test> q; //大根堆,即大的在前
set<test> s; // 小的在前

原理

因为优先队列默认大根堆，而 $set$ 默认小的在前，因此当重载 $<$ 时若内部也是小于号，那么性质不变。

反之：

bool operator < (test a,test b)
{
    return a.a > b.a; // ...
}

priority_queue<test> q; //小的在前
set<test> s; // 大的在前