蓝桥杯手把手教你备战（C/C++ B组）（最全面！最知心！得当小白！） ...

比赛环境：网盘资源分享
通过网盘分享的文件：蓝桥杯比赛环境
链接: https://pan.baidu.com/s/1eh85AW-y83ibCmEo8ByBwA?pwd=1234 提取码: 1234
1 常见题目答疑

1.1 蓝桥杯含金量高不高？

提及蓝桥杯，不得不提ACM。
ACM是国际大门生程序计划比赛（ACM-ICPC），被誉为盘算机领域的“奥运会”，是世界上，规模最大、水平最高、最具影响力的国际大门生程序计划比赛。
ACM难度较高，当然含金量也更高， 那么蓝桥杯的含金量肯定比不过ACM，但是其具有独特的上风。
蓝桥杯难度更低，更易拿奖，同时在盘算机行业具有较高认可度。
ACM得当那些智商高或者编程经验丰富（学习算法1年以上）的选手参赛。而蓝桥杯得当小白，得当盼望快速得到编程领域一个认可证书而没有太多时间投入的参赛者。
1.2 获奖到底难不难？

蓝桥杯分为省赛和国赛。
省赛时：
与你竞争的是同省的人，以是获奖难度与你所在的省份有一定关系。
强省(指获奖难度较高的省份)：北京、四川、山东
弱省(指获奖难度较低的省份)：云南、甘肃、广西、青海、海南、贵州、宁夏、西藏
没有在上述行列的省份一律归为中省，不是太难，也不是很易。此处的判断依据是根据积年的国赛的奖杯属于哪省，还有该省的优质大学的数量。该省优质大学越多，和你同台竞争的人的水平越高，越难获奖。 省一获奖比例为占10%，省二占20%，省三占30%，加起来获奖比例为60%，不获奖比例为40%。
国赛时：
是所有省份的省一，同台竞争，此时只按照成绩排名，不分省份。获奖比例为，国一占5%，国二占20%，国三占35%，获奖比例为60%，不获奖比例为40%。
1.3 官网300报班值不值？

信赖不少小伙伴报名后会被焦虑裹挟，此时遇到官网宣传各种课程，大概会夷由要不要费钱，我的答案是不需要费钱。大概每个人的答案不同，我在此给出几点判断依据，你们可以根据自身情况判别。
①蓝桥杯B站官方
你们可以去B站官方听他们的一些直播公开课，你觉得他们的授课水平如何，自己判断。假如觉得讲的不错，那么你么可以思量买他们的课；假如觉得讲的不怎么地，那么请谨慎，因为你花300买的课大概率也是这种授课风格和水平。
②尝试自我学习
其实算法没有非常全面的课程，B站有很多优质的算法视频，但是都是散着的，很多人大概不适应，因为缺乏一个明白的学习方向，那么你可以根据下面我的一些分享，学习几天，假如找到了学习方向，那么就不需要费钱报班了。
1.4 现在学还来不来得及？

蓝桥杯的报名时间为12月份，省赛时间为4月份，大部分小白在学校报完名，大概率计划着寒假开始学。
但很大一部分人寒假学不了什么东西，因为寒假假期短，期间还穿插着春节，春节前几天帮着干家务，买新衣服，春节后几天，忙着和一年不见的亲朋挚友聚餐、谈笑等等。总之，一开学，一堆人才发急忙慌的开始学习算法。
实不相瞒，我本人，双非一本，大二上学期报名蓝桥杯，以此激励自己寒假学习。其实起了一定效果，我寒假试着自律：打开一道算法题--------不会写--------翻题解--------看不明白题解--------找视频--------看几遍视频看明白了--------再看题解--------看了好几遍好像看懂了--------试着自己写--------照旧不会写。 算法有着一种天生让人放弃的能力。初碰算法，一道题大概使你研讨一天也研讨不明白，这时请不要猜疑自己的智商，请不要猜疑自己是不是不得当盘算机专业。寒假在家，本来不强的自制力在云云强大的对手面前，真的招架不住。
以上，总结为假如寒假真的没学，或者学了好像觉得什么也没学明白，请不要焦虑，请不要放弃，我也是二月尾开学后真正开始沉下心来研讨的，末了拿到了河北赛区C/C++B组省级一等奖。 我不是什么智商超高的人，否则也不会在双非上学，我可以，那么你们也可以。
1.5什么是ACM、OI、IOI赛制？

现在算法比赛常用的赛制是ACM赛制、OI赛制、IOI赛制，那么这些赛制分别代表什么意思呢？

这块我参考了这篇博文，ACM、OI、IOI编程比赛模式介绍，想了解更多信息的可以跳转检察。
2 主要算法（纯小白指南）

2.1 算法知识图谱

这里的算法比力全面，考试范围一般不凌驾图上的内容，但是有些考试概率很低，以是该图只作学习参考即可，不必全部学完。

2.2 必考算法

这里推荐的算法一定会考，是你备考路上最先、最该、最明智的学习选择。
2.2.1 回溯法

推荐学习视频---------------------------------代码随想录–回溯法
算法模板

1. void backTracking(参数){
2.         if(终止条件){
3.                 收集结果 ;
4.                 return;
5.         }
6.         for(集合的元素集){
7.                 处理结点;
8.                 backTracking(结点);
9.                 回溯;
10.         }       
11. }

复制代码

2.2.2 DFS算法

推荐学习视频-----------------------------DFS算法讲解
2.2.3 BFS算法

推荐学习视频---------------------------- BFS算法讲解
2.3 高频算法

这里的算法是大概率会考的，不敢说100%，但80%的概率。
2.3.1 图论

2.3.1.1最短路径

单源最短路径Dijistra视频求某一个顶点（源点）到各个顶点的最短距离
多源最短路径Floyed视频求任意一个顶点到各个顶点的最短距离
单源最短路径代码模板
两个本质头脑是一样的，只是存储方式不同。
邻接矩阵法存储是用e[N][N]存储，邻接表法存储是用vector v[N]存储。
算法头脑：
①从没有选中的点中找到最短路径，参加到选中点中
②更新选中点的临近点到原点距离
结束条件：当以上步骤实行n次后
初始化条件：visit=0;dis=0x3f3f3f3f;dis[1]=0;
目的：dis是原点到i点的最短路径

1. /*
2. 邻接矩阵版本
3. */
4. int n,m;//n顶点数，m边数
5. int visit[MAX];
6. int dis[MAX];
7. int e[MAX][MAX];//存储图
8. void DigkstraA(){
9.         //1初始化visit和dis数组
10.         memset(visit,0,sizeof(visit));
11.         memset(dis,0x3f,sizeof(dis));
12.         dis[1]=0;
13.         //2核心代码
14.         int u=0;//离1号顶点最近的顶点下标
15.         for(int k=1;k<=n;k++){
16.                 //①寻找dis最小值
17.                 int myMin=INF;
18.                 for(int j=1;j<=n;j++){
19.                         if(visit[j]==0&&dis[j]<myMin){
20.                                 myMin=dis[j];
21.                                 u=j;
22.                         }
23.                 }
24.                 //②更新
25.                 visit[u]=1;
26.                 for(int i=1;i<=n;i++){
27.                         if(visit[i]==0&&dis[i]>dis[u]+e[u][i]){
28.                                 dis[i]=dis[u]+e[u][i];
29.                         }
30.                 }
31.         }
32. }

复制代码

1. /*
2. 邻接表版本
3. */
4. int n,m;
5. int visit[MAX];
6. int dis[MAX];
7. struct Node{
8.         int index;
9.         int weight;
10. };
11. vector<Node> arr[MAX];
12. void DigkstraB(){
13.         //1初始化
14.         memset(visit,0,sizeof(visit));
15.         memset(dis,0x3f,sizeof(dis));
16.         dis[1]=0;
17.         //2核心代码
18.         //①寻找dis最小值
19.         int u=0;
20.         for(int k=1;k<=n;k++){
21.                 int myMin=INF;
22.                 for(int j=1;j<=n;j++){
23.                         if(visit[j]==0&&dis[j]<myMin){
24.                                 myMin=dis[j];
25.                                 u=j;
26.                         }
27.                 }
28.                 //②更新
29.                 visit[u]=1;
30.                 for(int i=0;i<arr[u].size();i++){
31.                         if(visit[arr[u][i].index]==0&&dis[arr[u][i].index]>dis[u]+arr[u][i].weight){
32.                                 dis[arr[u][i].index]=dis[u]+arr[u][i].weight;
33.                         }
34.                 }
35.         }
36.        
37. }

复制代码

多源最短路径
算法头脑：
通过三重for循环，k为中转点，i为起点，j为终点不断更新矩阵

2. int n,m;//n代表顶点数量，m表示边数量
3. int e[MAX][MAX];//存储数据
4. void Floyd(){
5.         for(int k=1;k<=n;k++){
6.                 for(int i=1;i<=n;i++){
7.                         for(int j=1;j<=n;j++){               
8.                                 e[i][j]=min(e[i][j],e[i][k]+e[k][j]);
9.                         }
10.                 }
11.         }
12. }

复制代码

2.3.1.2 最小生成树

最小生成树视频

1. /*
2. prim算法
3. ①选出dis中最短边
4. ②更新被选结点附近的结点的dis
5. 终止条件：当添加的边数量==n-1
6. 初始化条件：visit数组，判断是否已经被选；
7.                         dis数组存储未被选顶点到已被选顶点的最短距离
8.                         parent数组(选)
9. */
10. int n,m;//n顶点数，m边数
11. int visit[MAX];
12. int dis[MAX];
13. int parent[MAX];
14. void prim(){
15.         //1初始化
16.         memset(visit,0,sizeof(visit));
17.         memset(dis,0x3f,sizeof(dis));
18.         memset(parent,-1,sizeof(parent));
19.         dis[1]=0;
20.         //2核心代码
21.         int u=0;
22.         for(int i=1;i<=n-1;i++){
23.                 int myMin=INF;
24.                 for(int j=1;j<=n;j++){
25.                         if(dis[j]<myMin){
26.                                 myMin=dis[j];
27.                                 u=j;
28.                         }
29.                 }
30.                 visit[u]=1;
31.                 for(int k=1;k<=n;k++){
32.                         if(visit[k]==0&&dis[k]>e[u][k]){
33.                                 dis[k]=e[u][k];
34.                         }
35.                 }
36.         }
37.        
38. }

复制代码

并查集教程

1. /*
2. 算法思想kruskal
3. ①把图中所有边取出，排序
4. ②取出top边，判断是否成环
5. 终止条件：当添加的边数量==n-1(有答案)或者遍历完了所有边(无答案)
6. 初始条件：fa数组
7. */
8. int n,m;//n顶点数，m边数
9. int sum=0;//存答案
10. int num=0;//存次数
11. struct edge{
12.         int u,v,w;
13. }a[MAX];//存储边
14. //这步不理解的，可以查看上面推荐的并查集教程
15. int findRoot(int t){
16.         if(fa[t]!=t)
17.                 fa[t]=findRoot(fa[t]);
18.         return fa[t];
19. }
20. bool cmp(edge a,edge b){
21.         return a.w<b.w;
22. }
24. int Kruskal(){
25.         //1初始化
26.         //并查集初始化
27.         int fa[MAX];        
28.         for(int i=1;i<=n;i++){
29.                 fa[i]=i;
30.         }
31.         //2算法核心
32.         //①排序
33.         sort(a+1,a+m+1,cmp);
34.         //②取边，并判断是否成环
35.         for(int i=1;i<=m;i++){
36.                 //如果不成环  
37.                 if(findRoot(a[i].u)!=findRoot(a[i].v)){
38.                         //合并祖先
39.                         fa[findRoot(a[i].u)]=findRoot(a[i].v)];
40.                         ans+=a[i].w;
41.                         num++;
42.                 }
43.                 if(num==n-1){
44.                         cout<<ans<<'\n';
45.                         return 0;
46.                 }
47.         }
48.         cout<<"error"<<'\n';
49.         return 0;
50. }

复制代码

2.3.2 前缀和差分

声明一下，前缀和、差分是两个算法
一维、二维的前缀和、差分讲授视频
2.3.3 二分法

二分法教程
2.4 中频算法

2.4.1 动态规划

之以是将动态规划划分到这里，是不想让你们死扣动态规划，动态规划观察的方法千变万化，很不轻易掌握， 大概你学了之后，考试考到了一个别的，你照旧不会，按照学习的性价比来说，动态规划的性价比没有前面的高。
动态规划有：线性DP，区间DP，背包题目，树形DP，数位DP，前三种相对于后两种来说，算是轻易的，后两种比力难，考试根本不考，考到了也需要很熟练才能拿分，故在此处不展开叙述。
2.4.1.1 线性DP

数字三角形

1. /*
2. dp[i][j]表示从顶部走到第i行第j列经过的数字最大和
3. dp[i][j]=max(dp[i-1][j-1],dp[i-1][j])+aij
4. 目标： dp[n][j]的最大值 (可以一维数组优化)
5. */
6. dp[1][1]=a[1][1];
7. for(int i=2;i<=n;i++){
8.                 for(int j=1;j<=i;j++){
9.                         dp[i][j]=max(dp[i-1][j-1],dp[i-1][j])+a[i][j];
10.                 }
11. }

复制代码

最大一连子段和

1. /*
2. 定义：dp[i]代表前i个元素的最大子段和的值
3. 转移：if(dp[i-1]>0) dp[i]=dp[i-1]+a[i]
4.           else        dp[i]=a[i]
5. 初始化:dp[i]=a[i];//可以优化a[i]
6. 目标：max(dp[i])
7. */

复制代码

最长公共子序列

1. /*
2. 给定两个序列x和y，求x和y的最长公共子序列的长度
3. 定义：dp[i][j]表示x[1~i]，y[1~j]的最长公共子序列长度
4. 转移：if(x[i]==y[j]) dp[i][j]=dp[i-1][j-1]+1
5.           else if(x[i]!=y[j]) dp[i][j]=max(dp[i][j-1],dp[i-1][j])
6. 初始化：dp[i][0]=0,dp[0][j]=0;
7. 目标： dp[n][m]
8. */
9. for(int i=0;i<=len1;i++)        dp[i][0]=0;
10. for(int j=0;j<=len2;j++)        dp[0][j]=0;
11. for(int i=1;i<=len1;i++){
12.         for(int j=1;j<=len2;j++){
13.                 if(s1[i-1]==s2[j-1]){
14.                         dp[i][j]=dp[i-1][j-1]+1;
15.                 }else{
16.                         dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
17.                 }
18.         }
19. }

复制代码

最长上升子序列

1. /*
2. 定义：dp[i]表示前i个元素中的最长上升子序列
3. 转移：if(a[i]>a[j]) dp[i]=max(dp[j]+1,dp[i]);
4. 初始化：dp[0]=0
5. 目标： max(dp[i])
6. */
7. for(int i=1;i<=n;i++){
8.                 dp[i]=1;
9.                 for(int j=1;j<i;j++){
10.                         if(a[j]<a[i]){
11.                                 dp[i]=max(dp[i],dp[j]+1);
12.                         }
13.                 }
14.                 if(dp[i]>MaxNum){
15.                         MaxNum=dp[i];
16.                 }
17. }

复制代码

2.4.1.2 区间DP

游艇租赁

1. /*
2. 定义：dp[i][j]表示第i个站点到第j个站点的最少租金
3. 转移：dp[i][j]=min( dp[i][k]+dp[k][j]  ,  dp[i][j]  )
4. 初始化：dp[i][j]=a[i][j]
5. 目标： dp[1][n]
6. */
7. for(int d=3;d<=n;d++){
8.         for(int i=1;i<=n-d+1;i++){
9.                 int j=i+d-1;
10.                 for(int k=i+1;k<j;k++){
11.                         if(dp[i][j]>dp[i][k]+dp[k][j]){
12.                                 dp[i][j]=dp[i][k]+dp[k][j];
13.                         }
14.                 }
15.         }
16. }

复制代码

回文题目
定义：dp[j]表示将字符串s的子区间[j]转化为回文串的最小成本
转移：if(s==s[j]), dp[j]=dp[i+1][j-1]
if(s!=s[j]),dp[j]=min(dp[i+1][j]+min(arr[0],arr[1]),dp[j-1]+min(arr[j][0],arr[j][1]))
初始化：dp[j]=0;
目的： dp[0][m-1]

括号匹配题目
定义：dp[j]表示字符串i到j区间的最长正则括号子序列的长度
转移：括号匹配分两种情况
情况①嵌套((()))
转移：if(s==s[j]) dp[j]=dp[i+1][j-1]+2;
else dp[j]=max(dp[i+1][j],dp[j-1]);
情况②拼接 ()()()
转移：if(s==s[j]) dp[j]=max(dp[k]+dp[k+1][j]); (k=i,i+1,…,j-1)
else dp[j]=max(dp[i+1][j],dp[j-1]);
初始化dp[j]=0
目的：dp[0][len-1]

2.4.1.3 背包题目

0-1背包题目：每个物品只有一个，只有放和不放两种大概
定义：dp[j]表示容量为j的背包放入前i种物品时的最大容量
转移：if(w<=j) dp[j]=max(dp[j],dp[j-w]+v);(倒推，因为需要用到上一行的旧数据)
初始化：dp[j]=0;
目的： dp[m]

完全背包：物品有无限多个，可以放入的数量不可估量
定义：dp[j]表示容量为j的背包放入前i种物品时的最大容量
转移：if(w<=j) dp[j]=max(dp[j],dp[j-w]+v);(正推，因为需要用到当前行的新数据)
初始化：dp[j]=0;
目的： dp[m]

多重背包：每个物品的数量有限

1. //思路：
2. //①暴力分解 转化成01背包 (容易超时n^3)
3. for(int i=1;i<=n;i++)
4.         for(int k=1;k<=c[i];k++)
5.                 for(int j=m;j>=w[i];j--)
6.                         dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
7. //②二进制分解 将ci个物品拆分成=2^0,2^1,2^2,2^3......+2^p,剩余部分为Ri=ci-(2^0+2^1+...+2^p) (logn^3)
8. for(int i=1;i<=n;i++){
9.                 if(d[i]*w[i]>=m){//转化成完全背包
10.                         for(int j=w[i];j<=m;j++){
11.                                 dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
12.                         }
13.                 }else{
14.                         for(int k=1;c[i]>0;k<<=1){//二进制拆分
15.                                 int x=min(c[i],k);
16.                                 c[i]-=x;
17.                                 for(int j=m;j>=w[i]*x;j--){//转化成01背包
18.                                         dp[j]=max(dp[j],dp[j-w[i]*x]+x*v[i]);
19.                                 }
20.                         }
21.                 }
22. }

复制代码

分组背包

1. /*
2. 定义：dp[j]表示将前i组物品放入容量为j的背包中可以获得的最大价值
3. 转移：dp[j]=max(dp[j],dp[j-w[i][k]]+v[i][k]);(倒推)
4. 初始化：dp[j]=0;
5. 目标： dp[m];
6. */
7. for(int i=1;i<=n;i++)//枚举组
8.         for(int j=m;j>=0;j--)//枚举背包容量（倒推）
9.                 for(int k=1;k<=c[i];k++)//枚举组内每个物品
10.                         if(j>w[i][k])
11.                                 dp[j]=max(dp[j-w[i][k]]+v[i][k],dp[j]);

复制代码

肴杂背包

1. //混合背包的模板
2. for(int i=1;i<=n;i++){
3.         if(//01背包问题){
4.                 ZeroOnePack(c[i],w[i]);
5.         }else if(//完全背包问题){
6.                 CompletePack(c[i],w[i])
7.         }else if(//多重背包问题){
8.                 MultiplePack(c[i],w[i],n[i])
9.         }
10. }

复制代码

3 辅助算法

这里的算法是不会单独观察的，而是穿插在其它算法里的一小步，掌握好辅助算法，可以帮助你快速做题。
3.1 排序

3.1.1 优先队列

1. //自定义类型
2. struct Node{
3.         int num;
4.         int mosst;
5. };
6. //重载自定义类型的比较运算符
7. //如果num相等，则mosst大的排前面；否则num大的排前面
8. struct cmpl{
9.         bool operator()(Node d1,Node d2){
10.                 if(d1.num==d2.num){
11.                         return d1.mosst>d2.mosst;
12.                 }else{
13.                         return d1.num>d2.num;
14.                 }
15.         }
16. };
17. //定义priority_queue<类型1，容器<类型1>，重载的比较运算符>
18. priority_queue<Node,vector<Node>,cmpl> q;
19. //存储(存储进去后，自动按照指定的排序规则排序)
20. Node temp;
21. q.push(temp);
22. //拿栈顶元素
23. q.top();
24. //弹出栈顶元素
25. q.pop();

复制代码

3.1.2 sort排序

①int数组

1. #include <algorithm>
2. #include <iostream>
3. using namespace std;
5. int main() {
6.     int arr[] = {5, 2, 9, 1, 5, 6};
7.     int n = sizeof(arr) / sizeof(arr[0]);
8.     sort(begin(arr),end(arr)); // 使用 begin 和 end 获取数组边界
9.     for (int i = 0; i < n; ++i)
10.        cout << arr[i] << " ";
11. }

复制代码

②vector类型

1. #include <vector>
2. #include <algorithm>
3. #include <iostream>
4. using namespace std;
6. int main() {
7.     vector<int> vec = {3, 1, 4, 1, 5, 9};
8.     sort(vec.begin(), vec.end());
9.     for (auto& v : vec)
10.         cout << v << " ";
11. }

复制代码

③自定义类型

1. #include <vector>
2. #include <algorithm>
3. #include <iostream>
4. #include <string>
5. using namespace std;
7. struct Person {
8.     string name;
9.     int age;
10.     // 构造函数
11.     Person(string n, int a) : name(n), age(a) {}
12. };
14. // 比较函数
15. bool compare_by_age(const Person &a, const Person &b) {
16.     return a.age < b.age;
17. }
19. int main() {
20.     vector<Person> people = {
21.         Person("Alice", 30),
22.         Person("Bob", 25),
23.         Person("Charlie", 35)
24.     };
26.     // 使用自定义比较函数排序
27.     sort(people.begin(), people.end(), compare_by_age);
29.     for (const auto& person : people)
30.         cout << person.name << " " << person.age << "\n";
31. }

复制代码

3.2 string 字符串使用

1. string s = "Hello World";
2. //求字符串长度
3. cout << "Size: " << s.size() << "\n"; // 或者使用 length()
4. //字符串判空
5. if (s.empty()) {
6.     cout << "String is empty\n";
7. }
8. //截取字符串
9. string sub = s.substr(0, 5); // 提取从索引0开始的5个字符
10. //查找子串位置
11. size_t pos = s.find("World"); // 查找 "World" 的位置
12. if (pos != string::npos) {
13.     cout << "Found at position: " << pos << "\n";
14. }
15. //插入字符串
16. s.insert(5, ", "); // 在索引5处插入 ", "
17. //比较字符串
18. string s1 = "Hello";
19. string s2 = "hello";
20. if (s1.compare(s2) == 0) {
21.     std::cout << "Strings are equal\n";
22. } else {
23.     std::cout << "Strings are not equal\n";
24. }

复制代码

4 训练网站推荐

4.1 边学边练

4.1.1蓝桥杯题库

①蓝桥杯 C/C++ 组历届真题合集
在这里你可以通过标签筛选训练题，来巩固你刚学过的算法

②蓝桥成套真题演练
在这里面，你可以找到成套真题，得当用作考前模拟题，考试时间为4小时，平时学习时，大概边查资料边写代码，导致做题速度较慢，这到考场是致命的伤，一定要提前模拟！！
遗憾的是，这个题目是真实比赛时的试卷，不能判断你写的对错，假如要知道对错，你需要复制题目，到蓝桥杯 C/C++ 组历届真题合集这里面搜索对应的题目，再将题解复制过去，检察对错。

4.1.2 leetcode题库

leetcode题库
在这里，你可以筛选题目难度，题目的签

每道题都有题解，可以选择题解的语言种别，检察大佬们的思路，从而充实自己的大脑，终有一天，你也可以发布题解，得到多人的点赞

4.2 小试牛刀

4.2.1 蓝桥算法双周赛等

一些同砚，大概觉得平常自己训练没有时间上的紧急感，这里推荐一些小比赛，可以自己参加试试。
蓝桥比赛这里面是蓝桥杯官方的一些比赛

4.2.2 leetcode比赛

leetcode比赛

4.2.3牛客比赛

牛客比赛，可以挑选赛制

4.3 其它

其实以上网站就充足你训练题目了，下面推荐的网站是几个也能练题的网站，学有余力可以做，但是假如你放弃上面三个做题网站，而选择下面几个，就是本末倒置了。
洛谷
码蹄集
C语言网包罗了很多题目集，也包罗蓝桥杯的。
有些人喜好在C语言网做蓝桥的题，可以参考这篇博文C语言网在ACM蓝桥杯等算法比赛的妙用
Virtual Judge支持多个国际知名的在线编程比赛平台，包罗了北京大学，PTA，洛谷等，剩下很多需要翻墙才能访问，我也没用过，感兴趣可以自己研究。

5 赛前须知

第16届蓝桥杯报名官网每一届报名网址都不一样，比如第15届的报名网址就不是这个，以是假如未来想找第17届，第18届的，自己百度搜索第某某届蓝桥杯报名官网就行。
报名官网上可以看到大赛的最新消息，要学会自己查大赛的规则。
蓝桥别—>关于大赛—>比赛大纲

点开比赛大纲，第十六届蓝桥杯大赛软件赛和电子赛比赛大纲，下载压缩包，检察大赛规则。
5.1 比赛要求（考前必看）

比赛时长： 4小时（一般是上午9点到下战书1点）
机器设置：
X86兼容机器，内存不小于4G，硬盘不小于60G。
操作系统：Windows7、Windows8、Windows10或Windows11
编程环境：
Dev-cpp 5.11(支持C++11标准)
C/C++ API 帮助文档
（建议大家平时训练时也使用这个环境，防止比赛时因为不熟悉而浪费时间）
5.2 Dev设置（考前必会）

一般学校机考，会给你下载好Dev和API帮助文档，但是全都是默认设置，需要你自己设置成自己习惯的使用方式。
5.2.1 设置为中文界面

https://blog.csdn.net/stone_fall/article/details/88820707
5.2.2 使用C++11新标准

Dev5.11默认是不开启C++11标准的，可以选择开启
https://blog.csdn.net/Aibiabcheng/article/details/104708516
这里记住自己使用的Dev是哪个标准的：
假如设置了C++11标准，代码运行正常，那么提交时也选择C++11。
假如没有设置C++11标准，且代码运行正常，那么提交时选择C++即可。
5.2.3 Dev-C++环境下的degug使用

真话实说：其实Dev-C++5.11的调试功能，有严厉的Debug。
经常在单步调试时，遇到卡住无法向下一步实行的题目。假如遇到了该题目，建议不要死磕，可以使用打印语句来模拟debug。
（我找过很多解决方案，有的建议把endl换成"\n"，但是调试时照旧会卡住，信赖我这个前人的话，不要死磕）
Dev-C++环境调试如何使用？
5.2.4 全能头文件

Dev中默认自带这个头文件，以是直接使用即可，无需设置

1. //加入这个头文件，就可以省去几乎所有你会用到的头文件了
2. //一些大佬不屑于使用这个头文件
3. //因为它包含了很多用不上的头文件，会稍稍影响编译性能
4. //但是我觉得对小白还是很友好的，我比赛时就一直使用的这个头文件，几乎没什么影响
5. #include<bits/stdc++.h>

复制代码

5.3 考试答疑

5.3.1 提交时如何选择编译环境？

官方提示！！！

如何知道自己平时训练时使用的环境呢？

平时蓝桥官网提交的C++(g++17)都是支持c++11的。由于蓝桥杯是OI赛制，即提交后不反馈分数，假如因为编译器选择错误，导致丢分，将非常可惜。为了十拿九稳，建议使用自己的Dev环境模拟比赛环境（上面5.2.2已经介绍）。
5.3.2 考试时可以上厕所吗？

可以的。征得监考老师同意就可以去，毕竟考试时长4小时，不大概不让你上厕所。
5.3.3 可以带纸和笔吗？

可以的，可以带上纸和笔。有的学校是自己发放草稿纸，这时只需带笔就行。
5.3.4 用谁的电脑？

一般是使用机房电脑，学校同一构造监考。
请注意：假如学校机房的电脑比力破旧，答题文件请保存在除了C盘以外的盘符，并实时保存。
（因为学校电脑破旧，以是大概会卡顿，蓝屏，这时就需要重启电脑，而我们学校的电脑是重启会自动清空C盘，只留操作系统，假如你的题目保留在C盘，那么恭喜你半途而废，重新开始答题）

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。