C++常用语法2（实用语法、STL库函数）

已于 2023-08-03 10:18:48 修改
阅读量271 收藏 3
点赞数 3
文章标签： c++ 开发语言
于 2023-04-05 18:06:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YMQyanmingqian/article/details/129917641
版权

目录

一、实用语法

1.重载运算符

 2.随机数生成

①rand()

②mt19937()

二、STL库函数

1.algorithm

用法1：排序（sort）

用法2：去重（unique）

用法3：二分查找（lower_bound、upper_bound） 

用法4：全排列（next_permutation、prev_permutation）

用法 5：最大、最小（max、min）

用法6：交换（swap）

用法7：查找（find） 

2.stack（栈）

括号匹配

 3.queue（队列）

周末舞会

合并果子

4.vector（向量）

5.map（映射）

查字典

 6.set（集合）

集合的并

 7.memset（填充）

8.pair（对）

9.万能头文件

--------------------------------------------end--------------------------------------------

一、实用语法

1.重载运算符

众所周知，结构体是一个我们编程中非常常用的工具，但它有一个比较大的缺陷：不能直接进行操作。比如说，我们想把两个结构体相加，那肯定是不能直接做到的。更常见的情况是排序，如果使用sort对结构体排序，一般必须使用cmp。但c++为我们提供了一个解决方法：运算符重载

格式如下：

返回类型 operator 运算符名称(形参列表){
        重载实体;
}

注：结构体内外都可以定义，但结构体外定义需要多加一个形参：const 结构体类型名称& 结构体类型变量名，如：const node& a

单纯看这个可能看不懂，下边来看一组示例：

#include<iostream>
using namespace std;
struct node{
    int x,y;
    node operator + (const node& tmp){
        node res;
        res.x=x+tmp.x;
        res.y=y+tmp.y;
        return res;
    }
};
int main(){
    node a{1,2},b{3,4};
    node ans=a+b;
    cout<<ans.x<<" "<<ans.y<<endl;
    return 0;
}

输出：

4 6

运算符重载更常用的范围是排序：

#include<iostream>
#include<algorithm>
using namespace std;
struct node{
    int x,y;
    bool operator < (const node& t){
        if(x==t.x){
            return y<t.y;
        }
        return x<t.x;
    }
}r[12];
int main(){
    for(int i=1;i<=10;i++){
        cin>>r[i].x>>r[i].y;
    }
    sort(r+1,r+10);
    for(int i=1;i<=10;i++){
        cout<<r[i].x<<" "<<r[i].y<<endl;
    }
    return 0;
}

输入：

1 2
5 2
4 5
2 8
1 3
1 5
1 4
2 9
3 4
5 4

 输出：

1 2
1 3
1 4
1 5
2 8
2 9
3 4
4 5
5 2
5 4
 

 2.随机数生成

常用于竞赛中的对拍。

①rand()

范围：1~32767

使用方法：

取范围[n,m]的数，写法为 rand()%(m-n+1)+n

#include<iostream>
#include<ctime>
using namespace std;
int main(){
    srand(unsigned(time(0)));
    int count1=rand()%3+1;  //范围：1~3
    int count2=rand()%3;    //范围：0~2
    cout<<count1<<endl<<count2;
    return 0;
}

②mt19937()

范围：无限制，可自己设定

使用方法：

无限制：

#include<iostream>
#include<chrono>
#include<random>
using namespace std;
int main(){
    //随机数种子
    unsigned seed=std::chrono::system_clock::now().time_since_epoch().count();
    mt19937 rand_num(seed);  //大随机数
    cout<<rand_num()<<endl;
    return 0;
}

手动设定范围：

#include<iostream>
#include<chrono>
#include<random>
using namespace std;
int main(){
    //随机数种子
    unsigned seed=std::chrono::system_clock::now().time_since_epoch().count();
    mt19937 rand_num(seed);  //大随机数
    uniform_int_distribution<long long> dist(0,1000000);//给定范围：0~1000000
    cout<<dist(rand_num)<<endl;
    return 0;
}

可以看出，mt19937()使用起来非常麻烦，因此建议用多个rand()函数的结果相乘，也可以生成较大的随机数，且使用起来非常简便。

二、STL库函数

1.algorithm

头文件：<algorithm>

用法1：排序（sort）

默认从小到大排序，如有其他需要可自行添加比较函数（cmp）

例（从大到小）：

#include<iostream>
#include<algorithm>
using namespace std;
int a[]={1,5,3,2,7,4};
bool cmp(int a,int b){
    return a>b;
}
int main(){
    sort(a,a+6,cmp);
    for(int i=0;i<6;i++){
        cout<<a[i]<<" ";
    }
    return 0;
}

输出：

7 5 4 3 2 1

用法2：去重（unique）

可以将有序数据中的重复元素去除

例：

#include<iostream>
#include<algorithm>
using namespace std;
int a[]={1,5,3,2,5,2};
int main(){
    sort(a,a+6);
    int len=unique(a,a+6)-a;
    cout<<len<<endl;
    for(int i=0;i<len;i++){
        cout<<a[i]<<" ";
    }
    return 0;
}

输出：

4

1 2 3 5

用法3：二分查找（lower_bound、upper_bound） 

二分查找有序数据中的元素

例：

#include<iostream>
#include<algorithm>
using namespace std;
int a[]={1,5,3,2,5,2};
int main(){
    /*
    二分查找num的位置
    lower_bound是查找第一个大于等于num的位置
    upper_bound是查找第一个大于num的位置，如果不存在就返回最后一个元素的后一位
    */
    sort(a,a+6);
    int num=3;
	int x=lower_bound(a,a+6,num)-a;
    int y=upper_bound(a,a+6,num)-a;
    cout<<x<<" "<<y;
    return 0;
}

输出：

3 4

用法4：全排列（next_permutation、prev_permutation）

将有序数据进行全排列

例：

#include<iostream>
#include<algorithm>
using namespace std;
int a[]={1,5,3,2,5,2};
int main(){
    /*
    next_permutation：求下一个全排列
    */
    sort(a,a+6);
    do{
        for(int i=0;i<6;i++){
            cout<<a[i]<<" ";
        }
        cout<<endl;
    }while(next_permutation(a,a+6));
    return 0;
}

 输出：

1 2 2 3 5 5 
1 2 2 5 3 5 
1 2 2 5 5 3 
1 2 3 2 5 5 
1 2 3 5 2 5 
1 2 3 5 5 2 
1 2 5 2 3 5 
1 2 5 2 5 3 
1 2 5 3 2 5 
1 2 5 3 5 2 
1 2 5 5 2 3 
1 2 5 5 3 2 
1 3 2 2 5 5 
1 3 2 5 2 5 
1 3 2 5 5 2 
1 3 5 2 2 5 
1 3 5 2 5 2 
1 3 5 5 2 2 
1 5 2 2 3 5 
1 5 2 2 5 3 
1 5 2 3 2 5 
1 5 2 3 5 2 
1 5 2 5 2 3 
1 5 2 5 3 2 
1 5 3 2 2 5 
1 5 3 2 5 2 
1 5 3 5 2 2 
1 5 5 2 2 3 
1 5 5 2 3 2 
1 5 5 3 2 2 
2 1 2 3 5 5 
2 1 2 5 3 5 
2 1 2 5 5 3 
2 1 3 2 5 5 
2 1 3 5 2 5 
2 1 3 5 5 2 
2 1 5 2 3 5 
2 1 5 2 5 3 
2 1 5 3 2 5 
2 1 5 3 5 2 
2 1 5 5 2 3 
2 1 5 5 3 2 
2 2 1 3 5 5 
2 2 1 5 3 5 
2 2 1 5 5 3 
2 2 3 1 5 5 
2 2 3 5 1 5 
2 2 3 5 5 1 
2 2 5 1 3 5 
2 2 5 1 5 3 
2 2 5 3 1 5 
2 2 5 3 5 1 
2 2 5 5 1 3 
2 2 5 5 3 1 
2 3 1 2 5 5 
2 3 1 5 2 5 
2 3 1 5 5 2 
2 3 2 1 5 5 
2 3 2 5 1 5 
2 3 2 5 5 1 
2 3 5 1 2 5 
2 3 5 1 5 2 
2 3 5 2 1 5 
2 3 5 2 5 1 
2 3 5 5 1 2 
2 3 5 5 2 1 
2 5 1 2 3 5 
2 5 1 2 5 3 
2 5 1 3 2 5 
2 5 1 3 5 2 
2 5 1 5 2 3 
2 5 1 5 3 2 
2 5 2 1 3 5 
2 5 2 1 5 3 
2 5 2 3 1 5 
2 5 2 3 5 1 
2 5 2 5 1 3 
2 5 2 5 3 1 
2 5 3 1 2 5 
2 5 3 1 5 2 
2 5 3 2 1 5 
2 5 3 2 5 1 
2 5 3 5 1 2 
2 5 3 5 2 1 
2 5 5 1 2 3 
2 5 5 1 3 2 
2 5 5 2 1 3 
2 5 5 2 3 1 
2 5 5 3 1 2 
2 5 5 3 2 1 
3 1 2 2 5 5 
3 1 2 5 2 5 
3 1 2 5 5 2 
3 1 5 2 2 5 
3 1 5 2 5 2 
3 1 5 5 2 2 
3 2 1 2 5 5 
3 2 1 5 2 5 
3 2 1 5 5 2 
3 2 2 1 5 5 
3 2 2 5 1 5 
3 2 2 5 5 1 
3 2 5 1 2 5 
3 2 5 1 5 2 
3 2 5 2 1 5 
3 2 5 2 5 1 
3 2 5 5 1 2 
3 2 5 5 2 1 
3 5 1 2 2 5 
3 5 1 2 5 2 
3 5 1 5 2 2 
3 5 2 1 2 5 
3 5 2 1 5 2 
3 5 2 2 1 5 
3 5 2 2 5 1 
3 5 2 5 1 2 
3 5 2 5 2 1 
3 5 5 1 2 2 
3 5 5 2 1 2 
3 5 5 2 2 1 
5 1 2 2 3 5 
5 1 2 2 5 3 
5 1 2 3 2 5 
5 1 2 3 5 2 
5 1 2 5 2 3 
5 1 2 5 3 2 
5 1 3 2 2 5 
5 1 3 2 5 2 
5 1 3 5 2 2 
5 1 5 2 2 3 
5 1 5 2 3 2 
5 1 5 3 2 2 
5 2 1 2 3 5 
5 2 1 2 5 3 
5 2 1 3 2 5 
5 2 1 3 5 2 
5 2 1 5 2 3 
5 2 1 5 3 2 
5 2 2 1 3 5 
5 2 2 1 5 3 
5 2 2 3 1 5 
5 2 2 3 5 1 
5 2 2 5 1 3 
5 2 2 5 3 1 
5 2 3 1 2 5 
5 2 3 1 5 2 
5 2 3 2 1 5 
5 2 3 2 5 1 
5 2 3 5 1 2 
5 2 3 5 2 1 
5 2 5 1 2 3 
5 2 5 1 3 2 
5 2 5 2 1 3 
5 2 5 2 3 1 
5 2 5 3 1 2 
5 2 5 3 2 1 
5 3 1 2 2 5 
5 3 1 2 5 2 
5 3 1 5 2 2 
5 3 2 1 2 5 
5 3 2 1 5 2 
5 3 2 2 1 5 
5 3 2 2 5 1 
5 3 2 5 1 2 
5 3 2 5 2 1 
5 3 5 1 2 2 
5 3 5 2 1 2 
5 3 5 2 2 1 
5 5 1 2 2 3 
5 5 1 2 3 2 
5 5 1 3 2 2 
5 5 2 1 2 3 
5 5 2 1 3 2 
5 5 2 2 1 3 
5 5 2 2 3 1 
5 5 2 3 1 2 
5 5 2 3 2 1 
5 5 3 1 2 2 
5 5 3 2 1 2 
5 5 3 2 2 1 
 

#include<iostream>
#include<algorithm>
using namespace std;
int a[]={1,5,3,2,5,2};
bool cmp(int a,int b){
    return a>b;
}
int main(){
    /*
    prev_permutation：求上一个全排列
    */
    sort(a,a+6,cmp);
    do{
        for(int i=0;i<6;i++){
            cout<<a[i]<<" ";
        }
        cout<<endl;
    }while(prev_permutation(a,a+6));
    return 0;
}

输出：

5 5 3 2 2 1 
5 5 3 2 1 2 
5 5 3 1 2 2 
5 5 2 3 2 1 
5 5 2 3 1 2 
5 5 2 2 3 1 
5 5 2 2 1 3 
5 5 2 1 3 2 
5 5 2 1 2 3 
5 5 1 3 2 2 
5 5 1 2 3 2 
5 5 1 2 2 3 
5 3 5 2 2 1 
5 3 5 2 1 2 
5 3 5 1 2 2 
5 3 2 5 2 1 
5 3 2 5 1 2 
5 3 2 2 5 1 
5 3 2 2 1 5 
5 3 2 1 5 2 
5 3 2 1 2 5 
5 3 1 5 2 2 
5 3 1 2 5 2 
5 3 1 2 2 5 
5 2 5 3 2 1 
5 2 5 3 1 2 
5 2 5 2 3 1 
5 2 5 2 1 3 
5 2 5 1 3 2 
5 2 5 1 2 3 
5 2 3 5 2 1 
5 2 3 5 1 2 
5 2 3 2 5 1 
5 2 3 2 1 5 
5 2 3 1 5 2 
5 2 3 1 2 5 
5 2 2 5 3 1 
5 2 2 5 1 3 
5 2 2 3 5 1 
5 2 2 3 1 5 
5 2 2 1 5 3 
5 2 2 1 3 5 
5 2 1 5 3 2 
5 2 1 5 2 3 
5 2 1 3 5 2 
5 2 1 3 2 5 
5 2 1 2 5 3 
5 2 1 2 3 5 
5 1 5 3 2 2 
5 1 5 2 3 2 
5 1 5 2 2 3 
5 1 3 5 2 2 
5 1 3 2 5 2 
5 1 3 2 2 5 
5 1 2 5 3 2 
5 1 2 5 2 3 
5 1 2 3 5 2 
5 1 2 3 2 5 
5 1 2 2 5 3 
5 1 2 2 3 5 
3 5 5 2 2 1 
3 5 5 2 1 2 
3 5 5 1 2 2 
3 5 2 5 2 1 
3 5 2 5 1 2 
3 5 2 2 5 1 
3 5 2 2 1 5 
3 5 2 1 5 2 
3 5 2 1 2 5 
3 5 1 5 2 2 
3 5 1 2 5 2 
3 5 1 2 2 5 
3 2 5 5 2 1 
3 2 5 5 1 2 
3 2 5 2 5 1 
3 2 5 2 1 5 
3 2 5 1 5 2 
3 2 5 1 2 5 
3 2 2 5 5 1 
3 2 2 5 1 5 
3 2 2 1 5 5 
3 2 1 5 5 2 
3 2 1 5 2 5 
3 2 1 2 5 5 
3 1 5 5 2 2 
3 1 5 2 5 2 
3 1 5 2 2 5 
3 1 2 5 5 2 
3 1 2 5 2 5 
3 1 2 2 5 5 
2 5 5 3 2 1 
2 5 5 3 1 2 
2 5 5 2 3 1 
2 5 5 2 1 3 
2 5 5 1 3 2 
2 5 5 1 2 3 
2 5 3 5 2 1 
2 5 3 5 1 2 
2 5 3 2 5 1 
2 5 3 2 1 5 
2 5 3 1 5 2 
2 5 3 1 2 5 
2 5 2 5 3 1 
2 5 2 5 1 3 
2 5 2 3 5 1 
2 5 2 3 1 5 
2 5 2 1 5 3 
2 5 2 1 3 5 
2 5 1 5 3 2 
2 5 1 5 2 3 
2 5 1 3 5 2 
2 5 1 3 2 5 
2 5 1 2 5 3 
2 5 1 2 3 5 
2 3 5 5 2 1 
2 3 5 5 1 2 
2 3 5 2 5 1 
2 3 5 2 1 5 
2 3 5 1 5 2 
2 3 5 1 2 5 
2 3 2 5 5 1 
2 3 2 5 1 5 
2 3 2 1 5 5 
2 3 1 5 5 2 
2 3 1 5 2 5 
2 3 1 2 5 5 
2 2 5 5 3 1 
2 2 5 5 1 3 
2 2 5 3 5 1 
2 2 5 3 1 5 
2 2 5 1 5 3 
2 2 5 1 3 5 
2 2 3 5 5 1 
2 2 3 5 1 5 
2 2 3 1 5 5 
2 2 1 5 5 3 
2 2 1 5 3 5 
2 2 1 3 5 5 
2 1 5 5 3 2 
2 1 5 5 2 3 
2 1 5 3 5 2 
2 1 5 3 2 5 
2 1 5 2 5 3 
2 1 5 2 3 5 
2 1 3 5 5 2 
2 1 3 5 2 5 
2 1 3 2 5 5 
2 1 2 5 5 3 
2 1 2 5 3 5 
2 1 2 3 5 5 
1 5 5 3 2 2 
1 5 5 2 3 2 
1 5 5 2 2 3 
1 5 3 5 2 2 
1 5 3 2 5 2 
1 5 3 2 2 5 
1 5 2 5 3 2 
1 5 2 5 2 3 
1 5 2 3 5 2 
1 5 2 3 2 5 
1 5 2 2 5 3 
1 5 2 2 3 5 
1 3 5 5 2 2 
1 3 5 2 5 2 
1 3 5 2 2 5 
1 3 2 5 5 2 
1 3 2 5 2 5 
1 3 2 2 5 5 
1 2 5 5 3 2 
1 2 5 5 2 3 
1 2 5 3 5 2 
1 2 5 3 2 5 
1 2 5 2 5 3 
1 2 5 2 3 5 
1 2 3 5 5 2 
1 2 3 5 2 5 
1 2 3 2 5 5 
1 2 2 5 5 3 
1 2 2 5 3 5 
1 2 2 3 5 5 
 

用法 5：最大、最小（max、min）


查找最大、最小

例：

#include<iostream>
#include<algorithm>
using namespace std;
int main(){
    /*
    max(a,b)查找a和b的最大值
    min(a,b)查找a和b的最小值
    */
    int a=1,b=2;
    cout<<max(a,b)<<endl;
    cout<<min(a,b);
    return 0;
}

输出：

2

1

用法6：交换（swap）


交换两个变量的值。 

例：

#include<iostream>
#include<algorithm>
using namespace std;
int main(){
    /*
    swap(a,b)交换a和b的值
    */
    int a=1,b=2;
    swap(a,b);
    cout<<a<<" "<<b;
    return 0;
}

用法7：查找（find） 

查找一个元素的位置。

例：

#include<iostream>
#include<algorithm>
using namespace std;
int a[]={3,1,4,1,7,9};
int main(){
    /*
    find(begin,end,value);
    返回区间中第一个元素值等于 value 的元素位置。
    find_if(begin,end,op);
    返回区间中第一个满足“op(elem)==true”的元素位置。
    如果没有找到匹配元素，则返回所传入的 end，不是 NULL！
    */
    int ans=find(a,a+6,7)-a;
    cout<<ans;
    return 0;
}

输出：

4 

2.stack（栈）

头文件<stack>

stack（栈）是 STL 实现的栈容器，可以实现栈的基本操作

以下所有操作时间复杂度为O(1)

stack<int> stk;常用函数功能
stk.push(x);将x入栈

stk.top();

获取栈顶元素
stk.pop();弹出栈顶元素
stk.empty();

判断栈是否为空

空返回true，不空返回false

stk.size();返回栈内元素个数

括号匹配

时间限制：1秒        内存限制：128M

题目描述

假设表达式中允许包含圆括号和方括号两种括号，其嵌套的顺序随意，如([]())或[([][])]等为正确的匹配，[(])或([]()或(()))均为错误的匹配 

本题的任务是检验一个给定的表达式中的括号是否匹配正确 

输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出“OK”，不匹配就输出“Wrong”

输入描述

一行字符，只含有圆括号和方括号，个数小于255

输出描述

匹配就输出一行文本“OK“，不匹配就输出一行文本”Wrong”

样例

输入

[(])

输出

Wrong

#include<iostream>
#include<stack>
using namespace std;
stack<char> stk;
bool check(string s){
    stk.push('#');
    for(int i=0;i<s.size();i++){
        char c=s[i];
        if(c==')'){
            if(stk.top()=='('){
                stk.pop();
            }
            else{
                return false;
            }
        }
        else if(c==']'){
            if(stk.top()=='['){
                stk.pop();
            }
            else{
                return false;
            }
        }
        else{
            stk.push(c);
        }
    }
    return stk.size()==1;
}
int main(){
    string s;
    cin>>s;
    if(check(s)){
        cout<<"OK";
    }
    else{
        cout<<"Wrong";
    }
    return 0;
}

 3.queue（队列）

头文件<queue>

queue（队列）是 STL 实现的队列容器，可以实现队列的基本操作

以下所有操作时间复杂度为O(1)

queue<int> q;常用函数操作
q.push(x);将x入队
q.front()，q.back()front()返回队首，back()返回队尾
q.pop();队首元素出队
q.empty();

判断队是否为空

空返回true，不空返回false

q.size();返回队内元素个数

priority_queue（优先队列）

头文件<queue>

优先队列，底层实现是堆，可将压入队内的元素自动排序

定义方法：
priority_queue<int>q; //默认降序优先队列
priority_queue<int, vector<int>, greater<int> >q; //升序优先队列
priority_queue<int, vector<int>, less<int> >q; //降序优先队列

priority_queue<int> q;常用函数操作
q.push(x);将x入队
q.top();返回队首元素
q.pop();队首元素出队
q.empty();

判断队是否为空

空返回true，不空返回false

q.size();返回队内元素个数

可插入运算符重载后的结构体或pair

deque（双端队列）

头文件<deque>

双端队列，队列两端都可以出队或入队

deque<int> q;常用函数操作
q.push_front(x);将x从队首入队
q.push_back(x);将x从队尾入队
q.front();返回队首元素
q.back();返回队尾元素
q.pop_front();队首元素出队
q.pop_back();队尾元素出队
q.empty();

判断队是否为空

空返回true，不空返回false

q.size();返回队内元素个数

周末舞会

时间限制：1秒        内存限制：128M

题目描述

假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。规定每个舞曲能有一对跳舞者。若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。现要求写一个程序，模拟上述舞伴配对问题。(0<m,n,k<1000)

输入描述

第一行男士人数m和女士人数n；
第二行舞曲的数目k。

输出描述

共k行，每行两个数，表示配对舞伴的序号，男士在前，女士在后。

样例

输入

2 4
6

输出

1 1
2 2
1 3
2 4
1 1
2 2

提示

显然，舞伴配对的顺序符合“先进先出”，所以用两个队列分别存放男士队伍和女士队伍，然后模拟k次配对：每次取各队队头元素“配对”输出，并进行“出队”和重新“入队”的操作

#include<iostream>
#include<queue>
using namespace std;
int main(){
    int n,m,k;
    cin>>n>>m>>k;
    queue<int> q1,q2;
    for(int i=1;i<=n;i++){
        q1.push(i);
    }
    for(int i=1;i<=m;i++){
        q2.push(i);
    }
    for(int i=1;i<=k;i++){
        cout<<q1.front()<<" "<<q2.front()<<endl;
        q1.push(q1.front());
        q1.pop();
        q2.push(q2.front());
        q2.pop();
    }
    return 0;
}

合并果子

时间限制：1秒        内存限制：128M

题目描述

        在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。 每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。          因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使多多耗费的体力最少，并输出这个最小的体力耗费值。          例如有3种果子，数目依次为1，2，9。可以先将1、2堆合并，新堆数目为3，耗费体力为3。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。 

输入描述

        输入包括两行，第一行是一个整数n(1< ＝n< =10000)，表示果子的种类数。第二行包含n个整数，用空格分隔，第i个整数ai(1< ＝ai< =20000)是第i种果子的数目。 

输出描述

        输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。输入数据保证这个值小于2^31。 

样例

输入

3 
1 2 9

输出

15

提示

对于30％的数据，保证有n< =1000：  对于50％的数据，保证有n< =5000；  对于全部的数据，保证有n< =10000。 

#include<iostream>
#include<queue>
using namespace std;
priority_queue<int,vector<int>,greater<int> >q;
int n,x,ans;
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>x;
        q.push(x);
    }
    while(q.size()>=2){
        int a=q.top();
        q.pop();
        int b=q.top();
        q.pop();
        ans+=(a+b);
        q.push(a+b);
    }
    cout<<ans;
    return 0;
}

4.vector（向量）

头文件<vector>

本质是一个动态大小的数组，可存放任意类型的对象。

操作及时间复杂度：

vector<int> a(10); 

定义了 10 个整型元素的向量

（尖括号中为元素类型名，它可以是任何合法的数据类型），但没有给出初值，其值是不确定的

O(n)
vector<int> a(10,1); 定义了 10 个整型元素的向量,且元素的初值都为 1O(n)
vector<int> a(b); 用 b 向量来创建 a 向量，整体复制性赋值O(n)
vector<int>a(b.begin(),b.begin+3);a 的初值为向量 b 的前三个值O(n)

int b[7]={1,2,3,4,5,9,8};

vector<int> a(b,b+7);

从数组中获得初值O(n)
v[i];以下标方式访问元素O(1)
v.push_back(x);往尾部插入元素 x (常用）O(1)
v.insert(it, x); 向迭代器 it 指向的位置插入 x,原位置后移O(n)
v.size();返回表长,注意是 unsigned 类型O(1)
v.front();取首元素的值O(1)
v.back();取尾元素的值O(1)
v.empty(); 表为空返回true，否则返回falseO(1)
v.clear();清空表O(1)
v.pop_back();删除表尾元素O(1)
v.erase(it);删除迭代器 it 指向的元素O(n)

vector迭代器

类似于指针，用于访问元素

例：

vector<int>::iterator it;
for(it=v.begin();it!=v.end();it++){  //begin()表示首元素位置，end()表尾元素位置
    cout<<*it<<endl;
}

5.map（映射）

头文件<map>

可以简单理解为下标可以是任何类型的数组，可用于解释函数

操作：

m.find(x)查找x是否存在
m.count(x)键为 x 的数量(等同于查找 x 是否存在）
m.empty()判断是否为空
m.size()返回容器内元素数量
m.insert(x)

插入x，x 必须为对的形式。

可以为 pair 的形式，通过 make_pair 创建。

m.erase(x)将键值为 x 的元素删除。
m.clear()清空 map

map 的底层是红黑树，所以查找、插入、删除、访问的时间复杂度都是 log 级。

map迭代器

与vector迭代器类似，有以下区别：

  1. map是有序的，根据第一关键字自动排序
  2. map迭代器取值不用*，而用 ->first 取第一关键字， ->second 取第二关键字
  3. map 的迭代器只能++,--，不能+-数值

unordered_map
头文件<unordered_map> 

与map几乎完全一样，区别在于unordered_map是无序的，其操作速度比map稍快一点。

multimap
头文件<map>

同样与map几乎完全一样，但可以保存重复元素。

查字典

时间限制：1秒        内存限制：128M

题目描述

全国英语四级考试就这样如期到来了，可是小Y依然没有做好充分的准备。为了能够大学毕业，可怜的小Y决定作弊。（太胆大妄为了，不怕被学校开除！！）

 小Y费尽心机，在考试的时候夹带了一本字典进考场。但是现在的问题是，考试的时候可能有很多单词要查，小Y能不能来得及呢。

输入描述

第一行一个整数N，表示字典中一共有多少单词（N<=10000）。 

接下来每两行表示一个单词，其中： 第一行是一个长度<=100的字符串，表示这个单词，全部小写字母，单词不会重复。 

第二行是一个整数，表示这个单词在字典中的页码。 

接下来一行是一个整数M，表示要查的单词数(M<=10000)。 

接下来M行，每行一个字符串，表示要查的单词，保证在字典中存在。

输出描述

M行，每行一个整数，表示第i个单词在字典中的页数。

样例

输入

2
scan
10
word
15
2
scan
word

输出

10
15
#include<iostream>
#include<map>
using namespace std;
int main(){
    map<string,int> m;
    int n;
    cin>>n;
    string t;
    for(int i=0;i<n;i++){
        cin>>t;
        cin>>m[t];
    }
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>t;
        cout<<m[t]<<endl;
    }
    return 0;
}

 6.set（集合）

头文件<set>

去重，可以自动升序排序

set<T> s;常用函数操作
s.insert(x);插入x
s.erase(x);删除x
s.count(x);查找x，存在返回1，不存在返回0
s.clear();清空

unordered_set
头文件<unordered_set>

和set类似，去重但无序。

multiset
头文件<set>

和set类似，有序但不去重。

集合的并

时间限制：1秒        内存限制：128M

题目描述

现在有两个集合，计算两个集合的并，即{A}+{B}。

注：{A}+{B}中不允许出现重复元素，但是{A}与{B}之间可能存在相同元素。

输入描述

多组测试数据。

每组数据包含三行。

第一行为两个正整数n,m。分别表示两个集合的元素数量。

第二行为第一个集合元素、第三行为第二个集合元素。

输出描述

输出两个集合并后的元素。

样例

输入

1 2
1
2 3
1 2
1
1 2

输出

1 2 3
1 2

提示

A集合与B集合内部元素可能会出现重复。

n，m不超过10000.

集合内元素最大不超过int的最大值。

#include<iostream>
#include<set>
using namespace std;
set<int> se;
int main(){
    int n,m,x;
    while(cin>>n>>m){
        se.clear();
        for(int i=1;i<=n;i++){
            cin>>x;
            se.insert(x);
        }
        for(int i=1;i<=m;i++){
            cin>>x;
            se.insert(x);
        }
        while((int)se.size()){
            cout<<*se.begin()<<" ";
            se.erase(se.begin());
        }
        cout<<endl;
    }
    return 0;
}

 7.memset（填充）

头文件<cstring>

格式：memset(数组名,值,sizeof(数组名));

作用：将数组全部赋值。

注意：建议赋值时只赋值0，-1，0x3f.

8.pair（对）

包含两个数据值，两数据类型可不同。

初始化：pair<类型1,类型2> 名称

可在定义时直接赋值，如pair<string,string> a("CS","DN");x

用法：第一个元素为a.first，第二个元素为b.second.

用已有的两个元素生成pair，可用make_pair()，如make_pair(1,"CSDN");

9.万能头文件

#include<bits/stdc++.h>

一个几乎万能的头文件，包含所有可用到的C++库函数。

优点：

节约时间，减少工作量。

缺点：

增加编译时间，个别在线评测系统不兼容。

--------------------------------------------end--------------------------------------------

ps：后续还可能会不断完善，感谢支持！ 

YMQyanmingqian
关注
c++ STL与常用库函数
weixin_51008024的博客
11-22 601
c++ STL与常用库函数vector(变长数组)queue(队列)stack(栈)deque(双端队列)setmapinclude位运算常用方法常用库函数 vector(变长数组) 变长数组，支持随机访问，不支持在任意位置O(1)插入。为了保证效率，元素的增删一般应该在末尾进行 #include<vector> //头文件 vector<int> a; //相当于一个长度动态变化的int 数组 vector<int> b[233]; //相当于第一维长
c++常用的库函数 stl
RenWeitao的博客
02-01 712
①find()函数 1.通用std::find 函数 std::find函数的确有很好的通用性，但是也有很大的缺点，就是算法的效率不高，算法的复杂度为O(n)。 2.特定容器的find 函数 当数据量是百万或者千万级的时候，std::find的O(n)算法就让程序感到销魂了。 这时候我们可以考虑使用map或者set的算法。是的，这里的find，是map和set的一个成员函数，map和set中的fi...
C++常用STL及常用库函数
weixin_42638946的博客
02-21 1263
C++常用STL及常用库函数 vector #include <iostream> #include <vector> using namespace std; int main() { // 定义vector vector<int> a; // 定义一个空vector vector<int> b(3); // 定义一个长度为3，值全为0的vector vector<int> c({1, 2, 3}); /
C++ 语法基础课8 —— STL/位运算和常用库函数
qq_42731062的博客
01-17 1212
STL、位运算和常用库函数
C++算法刷题常用库函数
Daisy_Qw的博客
05-18 2004
常用库： #include<iostream> #include<sstream> #include<vector> #include<string> #include<stack> #include<queue> #include<map> #include<set> #include<algorithm> 1.<iostream><sstream> 见：牛客网输入
c++ 库函数（全）
11-14
C++的标准库，通常称为STL（Standard Template Library），包含了许多库函数，为开发人员提供了极大的便利。本资源"cppreference-doxygen-local.tag.xml"和"reference"文件，似乎是一个离线版的C++参考文档，特别...
C++ STL库函数学习
weixin_43234021的博客
09-20 593
C++ STL库学习一、模板1. 函数模板1.1 函数模板和普通函数的区别1.2 C++函数模板机制剖析1.3 函数模板案例—char、int类型数组排序2. 类模板2.1 类模板基本语法2.2 类模板案例—类模板派生普通类2.3 类模板案例—类模板派生类模板3. 普通类.h 与 .cpp分离编写方式 一、模板 1. 函数模板 #include <iostream> using namespace std; //模板技术：类型参数化，编写代码可以忽略类型 //为了让编译器区分普通函数 模板函
C/C++ 标准库函数 (中文版)
05-05
C/C++标准库函数手册是C/C++程序员必备的参考资料，它详细地介绍了C/C++语言中各种标准库函数的用途、语法和使用方式。标准库中包含了输入输出处理、字符串操作、数学计算、时间日期处理、内存管理等函数，此外C++...
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 165
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++与QML的数据交互
qq_50679120的博客
09-11 512
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
CF C. Nikita and LCM
qq_74190237的博客
09-13 258
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C和指针：标准函数库
暮色年华的博客
09-11 675
longjmp 函数:一旦在程序的其他部分遇到了 longjmp 调用，并且传入了之前 setjmp 初始化的 jmp_buf 数组以及一个非零值作为跳转值，那么程序的控制就会立即跳回到与那个 jmp_buf 关联的 setjmp 处。setjmp 函数：一个函数中调用 setjmp 并传递一个类型为 jmp_buf 的数组作为参数时，setjmp 将会保存当前程序执行环境的一个快照（包括处理器寄存器和程序计数器等状态信息）到这个 jmp_buf 数组中。如果在某个低层的函数中检测到一个错误，你可以立。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 467
继续学习头文件的数学函数。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 904
set、map仿STL模拟实现
【C++ && Qt day11】
wzj46的博客
09-11 273
2、头文件窗口文件。
C++ Qt开发：运用QJSON模块解析数据
qq_35662333的博客
09-11 1059
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
C++ lambda闭包消除类成员变量
随手写下笔记和感悟
09-11 450
消除了——通过将它们闭包到lambda表达式中，然后将这个lambda存起来重复使用。如果用引用捕获，栈变量会释放导致非法访存；可以借助函数式编程思想，来消除一些不必要的类成员变量。拿到一个类，一看成员变量好几十个，就问你怕不怕？在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。就无法修改值捕获的变量。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值