蓝桥杯备赛（C/C++组）

shekongdexiaomei_

已于 2024-04-12 21:42:43 修改

阅读量2.3k

点赞数 24

文章标签：蓝桥杯

于 2024-04-12 13:31:43 首次发布

本文链接：https://blog.csdn.net/wuhu_czy/article/details/134126855

版权

README：

本笔记是自己的备考笔记，按照官网提纲进行复习！适合有基础，复习用。

一、总考点

试题考查选手解决实际问题的能力，对于结果填空题，选手可以使用手算、软件、编程等方法解决，对于编程大题，选手只能使用编程解决。选手可在 C 语言程序中使用标准 C 的库函数，在 C++语言程序中使用标准 C++的库函数（包括 C 库、STL 等）。

考查范围( 计算机算法 )包括：

枚举、排序、搜索、计数、贪心、动态规划、图论、数论、博弈论* 、概率论 * 、计算几何* 、字符串算法等。数据结构：数组、对象/ 结构、字符串、队列、栈、树、图、堆、平衡树 / 线段树、复杂数据结构 * 、嵌套数据结构*等。（标*的部分只限于 C/C++研究生组、C/C++大学 A 组）

二、分模块(可略过)

1.枚举

我们学习过单例模式，即一个类只有一个实例。而枚举其实就是多例，一个类有多个实例，但实例的个数不是无穷的，是有限个数的。例如开车的方向有几种：前、后、左、右。我们称呼枚举类中实例为枚举项！

做题思路：使用枚举的方法得到所有满足要求的表达式，计算每一个表达式的结果并选出结果。

2.排序

见另一个博客：算法设计与分析（实验一）-CSDN博客

3.搜索(bfs，dfs)

宽度优先搜索：BFS宽度优先搜索例题（蓝桥杯）——逃跑的牛-CSDN博客

深度优先搜索：

4.贪心（顾名思义）

5.模拟

6.二分

7.DP(普通一维问题)

dp:动态规划，下面这个博主写的非常好！

算法之动态规划总结（11种DP类型，70道全部搞懂）-CSDN博客

（经典dp题）最长增序列问题思路：

首先初始化dp[]=1；

从第一个元素遍历i，第二层循环该元素之前的元素j，若存在某两个i,j 存在递增关系，则dp[i]=max（dp[j]+1,dp[1]）；

8.高精度

算法讲解之高精度算法 - 知乎

三、速成课笔记

蓝桥杯速成课链接：bilibili

1.头文件

万能头文件：

#include<bits/stdc++.h>
using namespace std；

注：C＋＋标准程序库中的所有标识符都被定义于一个名为std的namespace中。

2.vector向量

（0）头文件

#include<algorithm>
//#include<bits/stdc++.h>

（1）定义

//  vector<type> VectorName;
    vector<int> vi;
    vector<char> vc;

（2）存储

//错误存储方法：vi[i]=i;（此时vi[i]为空）
 vi.push_back(i);

（3）访问

    // VectorName[index] 坐标从0开始
    cout<<"vi[0]="<<vi[0]<<endl;

    //迭代器
    vector<int>::iterator it=vi.begin();
    for(;it!=vi.end();it++)
        cout<<*it<<" ";

（4）操作

返回最后一个元素：

vi.back();

返回第一个元素

vi.front();

清空向量

vi.clear();

判空

vi.empty(); //空则返回ture(cout结果为1),不空则返回false(0)

插入

vi.insert(vi.begin()+1,5);

元素个数

 vi.size();

当前容量

  vi.capacity(); //返回a在内存中总共可以容纳的元素个数

（如图所示：当插入一个元素时，若容器的容量不够，则自动增加一个容量，若删除一个元素，容量大小不变。）

删除

vi.pop_back();//删除最后一个元素

vi.erase(it);//删除指定迭代器位置元素

更详细的vector用法：C++ vector的用法（整理）-CSDN博客

3.set容器

特点：自动排序,元素不重复

（0）头文件

#include<set>

（1）定义

//set<type> SetName;
  set<int> si;

（2）访问

不能通过下标访问！用迭代器访问（迭代器在后面中讲到）

cout<<"set 中的第一个元素是 ："<<*s.begin()<<endl;

（3）最大容量

s.max_size();

最大容量大小与硬件有关（增删不变）。

（4）存储

s.insert(i);

（5）操作

清空向量

s.clear();

判空

s.empty(); //空则返回ture(cout结果为1),不空则返回false(0)

元素个数

s.size();

find（）

    set<int> s;
    if(s.begin()==s.end())
        cout<<"s.begin()==s.end()"<<endl; //------(1)
    cout<<*s.begin()<<" "<<*s.end()<<endl;//------(2)
    s.insert(1);
    s.insert(2);
    s.insert(3);
    s.insert(4);

    cout<<*s.begin()<<" "<<*s.end()<<endl;//------(3)
    cout<<*s.find(0)<<endl;               //------(4)

在上面这个代码钟，，输出结果如下：

（1）s.begin()==s.end()

（2）0 0

（3）1 4 //注意！这里的4不是最后一个元素的4，而是容器元素个数4

（4）4 //因为没有找到0元素，故返回的是迭代器：s.end() 而这个位置存储的是元素个数4

更多内容见：set容器迭代器及find（）函数

对比set和vector的用法

两个stl的语法对照
	vector	set
添加	v.push_back()	s.insert()
删除	v.pop_back() 或 v.erase()	s.erase(it)
第一个元素	v.front() 或 *s.begin()	*s.begin()
最后一个元素	v.back() 或 *s.end()	*s.end()
数量	size()
判空	empty()

注意：

容器存入数据时相当于复制，不是引用。

4.队列

（bfs常用到）

push() 在队尾插入一个元素
pop() 删除队列第一个元素
size() 返回队列中元素个数
empty() 如果队列空则返回true
front() 返回队列中的第一个元素
back() 返回队列中最后一个元素

5.string

（1）按char访问

string str="about";
cout<<str[0]<<endl; //输出a
cout<<str[1]<<endl; //输出a

（2）加

string str2="abc"，str3="efg";
cout<<str2+str3; //abcefg

加法=拼接操作

（3）另一种拼接——append（）

string s1="abc"
string s2="123"

1. s1.append(s2,2)
结果：abc3  [这里的2是pos下标从0开始]
2. s1.append("123",2)
结果： abc12  [这里的2指的是从坐标0开始的两个字符]
3. s1.append("123")
结果： abc123

（4）

子串：需要连续，如{abdgfr}的子串有abd,dgfr等
子序列：不需要连续，只需要保持元素间相对有序。如 {abdgfr}的子序列有adf,bgf等

6.树

先序遍历、中序、后序方法：递归or栈

赫夫曼编码：

加权路径长度WPL：

7.图

四、常用知识❤

1、万能头文件

#include<bits/stdc++.h>

2 、取消同步

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

3、数据类型

4、去尾

cout<<int(6.8);
结果：6

5、输出（C）

printf（"%m.nf"，num）：输出浮点数，m为宽度，n为小数点右边数位

6、排序

（1）sort

sort(begin,end,cmp);

其中：
begin为指向待排序的数组的第一个元素的指针
end为指向待排序的数组的最后一个元素的下一位置的指针
cmp为可选参数（默认升序）

降序：

（2）类对象排序sort

《重载运算符》

class Student{
        //类对象排序函数
        friend bool operator <(Student &a,Student &b)
        {
            return a.score!=b.score?a.score<b.score:a.score>b.score;
        } 
};


sort(stu,stu+n);  //执行排序操作

类对象排序：

class item
{
public:
	int type_A;//类成员参数A
	int type_B;//类成员参数B
};

bool cmpA(const item& x,const item& y)
{
	return x.type_A < y.type_A;
}

bool cmpB(const item& x, const item& y)
{
	return x.type_B < y.type_B;
}