STL&&用法集合

.....STL是c++里很强势很好用的一系列容器（函数）之类的，之前一直不太会用，所以总是暴毙。。。。想着快比赛了，是时候理一下这些东西了。

-1、pair

存放两个基本元素的东西

定义方法：

pair<type,type> name

若不定义优先级则默认为第一元素的优先级

0、重载运算符（对于结构体的重载）

#include<bits/stdc++.h>
using namespace std;
struct node
{
    int a,b;
    int operator + (const node x)const
    {
        return a+x.a;
    }
};
int main()
{
    node x={1,2};
    node y={2,3};
    int c=x+y;
    printf("%d",c);
    return 0;
}

譬如+：

返回两个元素的和

#include<bits/stdc++.h>
using namespace std;
struct node
{
    int a,b;
    node operator + (const node x)const
    {
        return a+x.a;
    }
};
int main()
{
    node x={1,2};
    node y={2,3};
    int c=x+y;
    printf("%d",c);
    return 0;
}

1、queue（队列）（头文件：queue）（多用于广搜）

第一个当然是队列了。

定义方法：

queue <类型> 名称

其中类型可以是各种各样的东西，包括结构体，pair，等。

使用方法：以下队列名称全部用q

q.push(a);//向队列的尾部塞一个元素a
q.pop();//弹掉队列的元素
q.front()//返回队头元素的值
q.size()//返回队列长度（元素个数）
q.emoty()//判断队列是否为空

2、deque（双端队列）（头文件：deque（这玩意还要一个头文件....））（多用于SPFA之SLF优化）

定义方法：

deque <类型> 名称

同上，类型也很多。

使用方法：（名称为q）

q.push_back(a);//向队尾塞一个元素a
q.push_front(a);//向队头塞一个元素a
q.pop_back();//删除队尾元素
q.pop_front();//删除队头元素
q.front()//返回队尾元素
q.back()//返回队头元素
q.empty()//判断队列是否为空，若空则返回1，否则0
q.size()//返回队列长度
q.clear()//清空队列

3、priority_queue（优先队列，堆）（头文件：queue）

c++STL强大的首体验

用于维护一个序列的大小，可以理解为自动排序，本质是一个二叉堆，内部严格遵守堆顶优先级最大（也就是值最小，在大根堆里）

定义方法：

priority_queue < 类型 > 名称

更一般地，定义使用这种方法：

priority_queue < type , vector < type > cmp > q;

此为priority_queue的标准定义，队列类型，动态数组类型，优先级

可以省略为上面那个类型，对priority_queue只定义类型，而第二个类型默认为vector。

注意：这样貌似只能定义一个大根堆（把优先级靠后，也就是大的值往后排），node要重载运算符||cmp（好吧还是重载运算符），pair的话自动用第一个元素的值排序

更广泛的写法（更好用，也就是自己定义优先级）

struct cmp
{
    bool operator()(int a,int b)
    {
        return a<b;//想干的事
    }
};
priority_queue < int , vector < int > , cmp > q ;

谈谈基本操作：

q.push(a);//塞a
q.pop();//弹队头，也就是堆顶
q.top();//返回堆顶值
q.empty()//同上
q.size()//队列长度

 4、map（映射）（头文件：map）

有点类似于桶，可以用于直接hash

谈谈定义：

map < type1 , type2 > m;
两个type可以相同， 但type1只能为基础数据结构，type2可以是结构体

谈谈用法：（下称m）

塞元素： 
常用数组法：m[a]=b;a是第一关键字；

m.size()，返回元素个数（总共多少个map，并不是严格元素个数）
 

5、vector（动态数组）（头文件vector）

一个可以动态改变内存的数组，常用于建图。

定义方法：

vector < type > name;
type可以是结构体，name后面也可以跟[n]，表示二维数组。
vector < type > :: iterator it;
定义一个迭代器用于各种操作

注意，查询是从0开始

谈谈用法（下称g）

它可以像普通数组一样进行操作
vector < int > :: iterator it
g.push_back(a)   //在数组的最后添加一个元素a
g.pop_back()    //去掉数组的最后一个数据 
g.front() 　　　　//返回第一个元素(栈顶元素)
g.begin()           //得到数组头的指针，用迭代器接受
g.end()             //得到数组的最后一个单元+1的指针，用迭代器接受
g.clear()        // 移除容器中所有数据
g.empty()         //判断容器是否为空
g.erase(it)        //删除it位置的数据
g.erase(beg,end)// 删除[beg,end)区间的数据(beg,end是地址，不是下标)
g.size()         //回容器中实际数据的个数
g.insert(it,a) //在it处插入数据

 6、set（集合）（头文件：set）

说是集合，其实它是一个封装了红黑树（一种非严格自平衡平衡树）的容器。

说它是集合因为它不能装重复的元素（可以达到去重的效果（话说有你我要unique干啥））

其实也有能装重复元素的东西，下面介绍。

定义：

set < type > name;
因为它是一个平衡树，所以有比较，所以如果是结构体类型的话需要重载运算符。

用法：（下称s）五花八门，十分方便

基础用法：

s.insert(a)//塞元素a，自排序
s.begin()//返回set容器的第一个元素
s.end()//返回set容器的最后一个元素
s.clear()//删除set容器中的所有的元素 
s.empty()//判断set容器是否为空
s.max_size()//返回set容器可能包含的元素最大个数 
s.size()//返回当前set容器中的元素个数 

花哨（实用）：

s.count(a)//查找元素a出现的个数（虽然就1....）
s.erase(it)//删除it处的元素，it是迭代器
s.find(a)//查找a元素，找到返回地址，找不到返回s.end()；
s.lower_bound(a)//查找第一个大于等于a的元素，返回地址
s.upper_bound(a)//查找第一个小于等于a的元素，返回地址

有了这一堆，能够省很多事，但是要慎用，毕竟STL常数不小.....