SET专题

一、排序

C++自带的库函数进行排序

头文件#include<algorithm>

sort(a,a+n);//省略形式默认从小到大排序。

sort(a,a+n,cmp);//自定义比较函数cmp。

例如：a数组的规模为n，需要从小到大进行排序

sort(a,a+n);

例如：a数组的规模为n，需要从大道小进行排序

int cmp(const int &a,const int &b)//函数名字可以自己定义，不一定是cmp

{

return a>b;//交换成立的条件。两元素相同必须返回0或者false

}

该函数写法特别适用于多层比较

例如：

有一结构体student。包含成绩score和学号id。要求先按成绩从大到小，若成绩相同，则按学号从小到大。

int cmp(const student &a,const student &b)

{

If (a.score>b.score) return 1;

If (a.score<b.score) return 0;

If (a.id<b.id) return 1;

return 0;

}

 

二、重载运算符

在我们写高精度的时候，为了代码的书写自然，我们可以利用重载运算符来解决高精度运算符定义的问题。

首先我们定义一个高精度的结构体

const int MAXN=1000;

struct BIGNUM{

int len,s[MAXN];

BIGNUM(){len=1;memset(s,0,sizeof(s));}

}

结构体里面和结构体名字一样的函数叫做构造函数，可以看作是结构体的初始化。

例如：重定义一个＜运算符，注意，这些定义一定在结构体里面写

bool operator < (const BIGNUM &x) const {

if (len!=x.len) return len<x.len;

//在这里，len指的是前一个数，x.len指的是后一个数

for (int i=len-1;i>=0;i--)

{

if (s[i]!=x.s[i]) return s[i]<x.s[i];

}

return false;//全部都相等，说明小于不成立

}

有了小于以后，其他比较符号的重定义就简单了。

例如：

bool operator > (const BIGNUM &x) const {return x<*this;}//*this指前面那个数

bool operator <= (const BIGNUM &x) const {return !(x<*this);}

bool operator != (const BIGNUM &x) const {return x<*this || *this<x);}

 

三、字符串（string）

在使用string类型时，必须包含string头文件

#include<string>

string 类型的定义与初始化

string s1; //定义一个字符串s1，并初始化为空

string s2(s1); //用s1初始化s2

string s3(“value”); //将s3初始化为”value”

string s4(n,’c’); //将s4初始化为字符’c’的n个副本，简单来说就是n个’c’字符

string的读写一般都是用cin和cout来实现。读取规则和字符数组用scanf时一样。

若要读取整行，用getline来实现，getline(cin,s);

string的操作

s.empty() //若s为空串，则返回true，否则为false；

s.size() //返回s中字符的个数，s.length()与其相同

s[n] //返回s中位置为n的字符，记得从0开始

s1+s2 //把s1和s2连接成一个新的字符串，注意的是+的左边必须是sring类型，不能是字符数组

s1=s2 //把s1内容替换成s2

s1==s2 //比较s1和s2是否相等，其他比较符号也同样适用

s.insert(pos,s2) //在s下标为pos的元素前插入字符串s2、

s.substr(pos,len) //返回s中下标为pos起的长度为len的子串。

s.replace(pos,len,s2) //删除s中下标为pos起的长度len个字符，并在pos位置插入字符串s2

s.find(s2,pos) //在s中查找s2第一次出现的位置

s.c_str() //返回一个与s相同C风格的字符串临时指针，可作为输出，但不能作为输入）

 

四、FIFO队列和优先队列

要用队列必须使用头文件queue

#include<queue>

定义FIFO队列

queue <类型名>变量名

例如：queue <int> q //定义q为一个int类型的队列

也可以定义结构体类型的队列

例如：

struct node{*****};

queue <node> p;

优先队列：和队列类似，可以随时插入和弹出元素，但弹出默认是按照当前最大值来进行弹出。运行内部有类似堆的机制。

定义优先队列：

priority_queue <int> h; //定义h为一个int类型的优先队列。

若要按照最小值优先弹出，可以把每个元素乘以-1；

也可以定义结构体的优先队列，不过值得注意的是，必须在结构体里面重定义“<”符号

例如：定义一个按最小值弹出的优先队列

struct data{

int x;

bool operator < (const data &a) const {return x>a.x;} //后面的const不要漏了

}

队列操作：

q.empty() //若队列为空，则返回true；

q.size() //返回队列中的元素个数

q.pop() //删除队首元素，但不返回其值

q.front() //返回队首元素的值，仅适用于普通队列

q.back() //返回队尾元素的值，仅适用于普通队列

q.top() //返回最高优先级的元素值，仅适用于优先队列

q.push() //对普通队列，在队尾压入新的元素，对于优先队列，基于优先级在适当位置插入新元素

例题：合并果子

#include<cstdio>

#include<iostream>

#include<queue>

using namespace std;

priority_queue <int> q;

int main()

{

int n,x;

cin>>n;

for (int i=0;i<n;i++)

{

cin>>x;

q.push(-x);

}

int ans=0,tmp;

for (int i=1;i<n;i++)

{

tmp=q.top();

q.pop();

tmp+=q.top();

q.pop();

ans-=tmp;

q.push(tmp);

}

cout<<ans<<endl;

return 0;

}

 

五、动态数组

为了节省空间，有时我们可以开动态数组vector

头文件#include<vector>

定义动态数组

vector <类型名>变量名

如：vector <int> a

类型也允许是结构体

动态数组操作：

a[i] //返回动态数组的第i个元素

a.empty() //若动态数组为空则返回true；

a.size() //返回动态数组中元素的个数

a.resize() //修改动态数组大小

a.push_back() //向动态数组尾部插入一个元素

a.pop_back() //删除动态数组尾部一个元素

a.begin() //返回指向动态数组开始的迭代器（指针）

a.end() //返回指向动态数组结尾后一个元素的迭代器（指针）

 

六、关联式容器

在一些应用中，使用map容器来作为一个有序的映射表，可以把它看作是一个下标可以是任何类型的数组。对map单次操作的时间复杂度为O(lgn)

头文件#include<map>

定义map

map <类型1，类型2>变量名；

例如：map<string,int>ma;

ma[“abc”]=2; //将字符串”abc”映射到整数2

cout<<ma[“abc”]; //输出为2

map也可以用于结构体，但必须重定义“<”号

操作：

operator[] //访问map中的元素，若该元素不存在，则创建一个新元素，并返回类型2初始值。

ma.begin() //返回map中第一个元素的迭代器（指针）

ma.end() //返回map中最后一个元素后一个的迭代器（指针）

ma.size() //返回map中元素的个数

ma.count(element) //判断元素element是否存在map中

ma.clear() //初始化map

ma.lower_bound() //返回键值大于等于给定元素的第一个位置

注意：一旦map中的一个元素被访问，不论它之前是否已经被赋值，它都被视为存在。

遍历map中所有元素，可以使用迭代器来逐一遍历

map<string,int> m;

map<string,int>::iterator i;

for (i=m.begin();i!=m.end();i++)

{

cout<<i->first<<” “<<i->second<<endl;

}

 

七、栈（stack）

头文件#includ<stack>

定义stack：

stack<类型名>变量名

例如：stack<int> s;

当然，也可以使用与自定义结构体

操作：

s.push() //压栈，把新元素放到栈顶

s.pop() //出栈，把栈顶元素弹出

s.top() //访问栈顶元素，但不删除

s.empty() //判断栈空，若是返回true

s.size() //返回当前栈的大小

 

八、练习：

uva10474，101，156，12096，540，136，400，1592，207，814，221

Uva1593，1594，10935，10763，10391，1595，12100，230，1596，1597，12504，511，822，1598，12333，212