前言：
✌ 作者简介：CC++Edge淇，大家可以叫我--斯淇。(CSDN优质博客的建议加这一条)
📑 个人主页：CC++Edge淇主页
📫 如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
🔥 如果感觉博主的文章还不错的话，还请不吝👍关注、点赞、收藏三连支持👍一下博主哦
💬 人生格言：琴键有限，人生无限--《海上钢琴师》💬
每日推荐歌曲：毛不易-《平凡的一天》
记录了自己第一次参加蓝桥杯的历程！！C/C++组
最后祝贺一下自己访问量冲到了一万一！！！！！
————————————————
————————————————
正文：
目录
前言：✌ 作者简介：CC++Edge淇，大家可以叫我--斯淇。(CSDN优质博客的建议加这一条)📑 个人主页：CC++Edge淇主页📫 如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀🔥 如果感觉博主的文章还不错的话，还请不吝👍关注、点赞、收藏三连支持👍一下博主哦💬 人生格言：琴键有限，人生无限--《海上钢琴师》💬每日推荐歌曲：毛不易-《平凡的一天》记录了自己第一次参加蓝桥杯的历程！！C/C++组最后祝贺一下自己访问量冲到了一万一！！！！！————————————————————————————————
正文：
2. . 第十届蓝桥杯省赛 矩形切割
第十届蓝桥杯省赛 质数
十届蓝桥杯省赛 等差数列
蓝桥杯基础训练 （算法类）
试题 基础练习 序列求和
试题 基础练习 圆的面积
试题 基础练习 Fibonacci数列
试题 基础练习 查找整数
试题 基础练习 特殊的数字
试题 历届试题 成绩统计【第十一届】【省赛】【C组】
试题 历届真题 时间显示【第十二届】【省赛】【C组】
试题 历届真题 砝码称重【第十二届】【省赛】【C组】
试题 历届真题 九宫幻方【第八届】【省赛】【C组】
思路;参考一下笨笨有话说这个是官方给个提示！！那就好办了利用数组一个一个写出了就可以了！！！不过个应该是最没办法的办法了（最没办法的时候想这个！！）这道题可以试试枚举!（我把所有的都去列一遍也算一个暴力解法了，然后我发现网上有一种比较好理解的输入方式）
试题 历届真题 密码脱落【第七届】【省赛】【C组】
这个是修改版的：
试题 历届真题 买不到的数目
试题 历届真题 买不到的数目【第四届】【省赛】【C组】
试题 历届真题 带分数【第四届】【省赛】【C组】
试题 历届真题 打印十字图【第四届】【省赛】【C组】
试题 算法训练 字符串比较
strcmp 的作用
运行限制
试题 历届真题 四平方和【第七届】【省赛】【C组】
题目描述
输入描述
输出描述
输入输出样例
运行限制
排它平方数（算法提升）
蓝桥杯填空题
题目描述：本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
题目描述-金币
题目描述--金币
输出
题目描述-赞助
题目：小明的背包2
题目描述 （找素数）
题目 1439: 蓝桥杯历届试题-盾神与砝码称重
蓝桥杯2020年第十一届省赛真题-走方格
题目描述 -卡片
题目: 蓝桥杯历届试题-跑步锻炼
题目描述
运行限制
题目: 蓝桥杯历届试题-蛇形填空
运行限制
题目: 蓝桥杯历届试题-跳跃
输入描述
输出描述
输入输出样例
题目: 蓝桥杯2021届试题-受伤的皇后
题目: 蓝桥杯2021届试题-最少砝码
题目: 蓝桥杯2021届试题-距离和
题目: 蓝桥杯2021届试题-最大间隙
题目: 蓝桥杯2020届试题（省赛）- 斐波那契数列最大公约数
题目: 蓝桥杯2019届试题（省赛）-完全二叉树的权值
题目: 蓝桥杯2020届试题（省赛）-成绩分析
题目: 蓝桥杯2020届试题（省赛）-排序
题目: 蓝桥杯2021届填空试题（省赛）- 相乘
题目: 蓝桥杯2021届填空试题（省赛）- 路径
题目: 蓝桥杯2021届填空试题（省赛）-货物摆放
好了，历程就到这里了！！！！无论结果怎么样，尽力就好！！
备考蓝桥杯！！！！
前几天由于一些设备问题耽搁了三天，从今天开始正式准备！
C/C++组 C组游戏规则：
软件环境：CodeBlocks和Dev-Cpp
题型：省赛 5道填空题，5道编程题
- 时长：4个小时，
- 语言：使用C语言或者C++。只会C也可以，但是最好会用C++,因为C++可调用的函数多，写出的代码
3. 赛制：OI赛制，以最后提交的结果为准
4.出成绩时间：一般比赛结束两周后就出成绩，是机改的
不多说：直接来真题！
1. 第十届蓝桥杯省赛 求和
时间限制：1.000s 内存限制：128MB
题目描述
小明对数位中含有 2、0、1、9 的数字很感兴趣，在 1 到 40 中这样的数包 括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。
请问，在 1 到 2019 中，所有这样的数的和是多少？
样例输入：
1. #include<stdio.h>
2. int main(){
3. int a=0,c,b,d,i,j,sum=0;
4. for(i=1;i<=2019;i++){
5. c=i;
6. while(c!=0){
7. b=c%10;
8. if(b==2||b==0||b==1||b==9){
9. sum+=i;
10. }
11. c=c/10;
12.
13. }
14. }
15. printf("%d",sum);
16. return 0;
17. }
2. . 第十届蓝桥杯省赛 矩形切割
时间限制：1.000s 内存限制：128MB
题目描述
【问题描述】
小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。
当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方 形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。
例如，对于一块两边分别为 5 和 3 的材料（记为 5×3），小明会依次切出 3×3、2×2、1×1、1×1 共 4 个正方形。
现在小明有一块矩形的材料，两边长分别是 2019 和 324。请问小明最终会 切出多少个正方形？
思路：一直取，运用多种循环去嵌套！
1. #include<stdio.h>
2. int i,j;
3. int sum=2019;
4. int q=324;
5. int p,num=0;
6. int k=1;
7. int main(){
8. int a,b;
9.
10. while(1){
11. sum++;
12. if(a>b){
13. a=a-b;
14. }
15. else if(a>b){
16. b=b-a;
17. }
18. if(a==b){
19. break;
20. }
21. }
22. printf("%d",sum);
23. return 0;
24. }
第十届蓝桥杯省赛 质数
题目：我们知道第一个质数是 2、第二个质数是 3、第三个质数是 5……请你计算 第 2019 个质数是多少？
思路：说白点这道题就是硬解，我的思路就是运用for循环去解决！
给一个参考答案：
1. #include<stdio.h>
2. int main(){
3. int a,b;
4. int i,j,sum,num;
5. int c[100][100];
6. scanf("%d",&a,&b);
7. for(i=0;i<a;i++){
8. for(j=0;j<b;j++){
9. scanf("%d",&c[i][j]);
10. }
11. }
12. for(i=0;i<a;i++){
13. for(j=b-2;j>=0;j++){
14. printf("%d",c[i][j]);
15. }
16.
17. }
18. printf("\n");
19. return 0;
20. }
十届蓝桥杯省赛 等差数列
时间限制：1.000s 内存限制：128MB
题目描述
数学老师给小明出了一道等差数列求和的题目。但是粗心的小明忘记了一 部分的数列，只记得其中 N 个整数。
现在给出这 N 个整数，小明想知道包含这 N 个整数的最短的等差数列有 几项?
输入格式
输入的第一行包含一个整数 N。 第二行包含N个整数A1,A2,···,AN。(注意A1 ∼AN并不一定是按等差数列中的顺序给出)
输出格式
输出一个整数表示答案
样例输入
5
2 6 4 10 20
样例输出
10
提示/说明
【样例说明】
包含 2、6、4、10、20 的最短的等差数列是 2、4、6、8、10、12、14、16、 18、20。
【评测用例规模与约定】
对于所有评测用例，2 ≤ N ≤ 100000，0 ≤ Ai ≤10^9 10^9。
思路：这道题有点类似于冒泡排序法！，将最小差找出来！
CSDN的参考答案：
1. #include<stdio.h>
2. int main(){
3. int a,b,c,d,e,f,sum=0,i,j,l;
4. int p[10000]={0};
5. scanf("%d",&a);
6. int m[10000]={0};
7. for(i=0;i<a;i++){
8. scanf("%d",&p[i]);
9. }
10. for(i=0;i<a-1;i++){
11. for(j=0;j<a-1-i;j++){
12. if(p[j]>p[j+1]){
13. f=p[j+1];
14. p[j+1]=p[i];
15. p[j]=f;
16. }
17. }
18. }
19. for(i=0;i<a-1;i++){
20. m[i]=p[i+1]-p[i];
21. }
22. b=m[0];
23. for(i=0;i<a-1;i++){
24. if(m[i]<b)
25. {
26. b=m[i];
27. }
28. }
29. b=p[a-1]/b;
30. printf("%d\n",b);
31. return 0;
32. }
蓝桥杯基础训练 （算法类）
试题 基础练习 数列排序
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
第一行为一个整数n。
第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。
输出格式
输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9
样例输出
3 4 6 8 9
思路：这道题其实是冒泡排序法稍微改一改就出来了！（不建议照抄！！）
可以参考我的答案：
#include<stdio.h>
2. int main(){
3. int M=250;
4. int a[M];
5. int n,j,t,k,i;
6. scanf("%d",&n);
7. for(i=0;i<n;i++)
8. scanf("%d",&a[i]);
9. for(i=0;i<n-1;i++){
10. t=i;
11. for(j=i;j<n;j++){
12. if(a[j]<a[t])
13. t=j;
14. }
15. k=a[i];
16. a[i]=a[t];
17. a[t]=k;
18. }
19. for(i=0;i<n;i++)
20. printf("%d\t",a[i]);
21. return 0;
22. }
问题描述
123321是一个非常特殊的数，它从左边读和从右边读是一样的。 输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。
输入格式
输入一行，包含一个正整数n。
输出格式
按从小到大的顺序输出满足条件的整数，每个整数占一行。
样例输入
52
样例输出
899998989989998899
数据规模和约定
1<=n<=54。
思路：这道题的思路呢，其实很简单，一个简单的杨辉三角的使用！稍微改装一点注意这个提示别超出范围~
参考我的答案：
#include<stdio.h>
2. #define N 34
3. int main(){
4. int i,j,k,n;
5. int a[N][N];
6. scanf("%d",&n);
7. for(i=0;i<=n;i++){
8. for(j=0;j<=i;j++){
9. a[i][j]=a[i-1][j-1]+a[i-1][j];
10. }
11. }
12. for(i=0;i<n;i++){
13. for(j=0;j<=i;j++){
14. printf("%d",a[i][j]);
15. }
16. }
17.
18. printf("\n");
19. return 0;
20. }
试题 基础练习 序列求和
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
求1+2+3+...+n的值。
输入格式
输入包括一个整数n。
输出格式
输出一行，包括一个整数，表示1+2+3+...+n的值。
样例输入
4
样例输出
10
样例输入100
说明：有一些试题会给出多组样例输入输出以帮助你更好的做题。
一般在提交之前所有这些样例都需要测试通过才行，但这不代表这几组样例数据都正确了你的程序就是完全正确的，潜在的错误可能仍然导致你的得分较低。
样例输出
5050
数据规模与约定1 <= n <= 1,000,000,000。
说明：请注意这里的数据规模。
本题直接的想法是直接使用一个循环来累加，然而，当数据规模很大时，这种“暴力”的方法往往会导致超时。此时你需要想想其他方法。你可以试一试，如果使用1000000000作为你的程序的输入，你的程序是不是能在规定的上面规定的时限内运行出来。
本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内，如果使用整型来保存结果，会导致结果错误。
如果你使用C++或C语言而且准备使用printf输出结果，则你的格式字符串应该写成%I64d以输出long long类型的整数。
参考我的思路（我的这个答案在测评里面只得了一半分！！后续我在想想别的方法！循环也是一种！）
#include<stdio.h>
2. int main(){
3. long long n,sum;
4. scanf("%d",&n);
5. sum=(1+n)*n/2;
6. printf("%ld",sum);
7. return 0;
8. }
试题 基础练习 圆的面积
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给定圆的半径r，求圆的面积。
输入格式
输入包含一个整数r，表示圆的半径。
输出格式输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。
说明：在本题中，输入是一个整数，但是输出是一个实数。
对于实数输出的问题，请一定看清楚实数输出的要求，比如本题中要求保留小数点后7位，则你的程序必须严格的输出7位小数，输出过多或者过少的小数位数都是不行的，都会被认为错误。
实数输出的问题如果没有特别说明，舍入都是按四舍五入进行。
样例输入
4
样例输出
50.2654825
数据规模与约定
1 <= r <= 10000。
提示
本题对精度要求较高，请注意π的值应该取较精确的值。你可以使用常量来表示π，比如PI=3.14159265358979323，也可以使用数学公式来求π，比如PI=atan(1.0)*4。
#include<stdio.h>
2. int main(){
3. double r;
4. scanf("%d",&r);
5. printf("%0.7f",r*r*3.14159265);
6. return 0;
7. }
试题 基础练习 闰年判断
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给定一个年份，判断这一年是不是闰年。
当以下情况之一满足时，这一年是闰年：
1. 年份是4的倍数而不是100的倍数；
2. 年份是400的倍数。
其他的年份都不是闰年。
输入格式
输入包含一个整数y，表示当前的年份。
输出格式输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。
样例输入
2013
样例输出
no
样例输入
2016
样例输出
yes
数据规模与约定
1990 <= y <= 2050。
参考我的答案：
#include<stdio.h>
2. int main(){
3. int x,y;
4. scanf("%d",&x);
5. if(x%4==0&&x%100!=0||x%400==0)
6. printf("yes\n");
7. else
8. printf("no\n");
9. return 0;
10. }
试题 基础练习 Fibonacci数列
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
输入格式
输入包含一个整数n。
输出格式输出一行，包含一个整数，表示F
n除以10007的余数。
说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。
样例输入
10
样例输出
55
样例输入
22
样例输出
7704
数据规模与约定
1 <= n <= 1,000,000。
思路：利用条件循环语句将每次所需要的条件抓出来！
可以参考的答案：
1. #include<stdio.h>
2. int main(){
3. int i=0,c,n,j,k,sum=0;
4. int max,min;
5. scanf("%d",&c);
6. for(;i<n;i++) {
7. scanf("%d",c);
8. if(i==0){
9. max==c;
10. min=c;
11. }
12. if(max<c){
13. max=c;
14. }
15. if(min>c){
16. min=c;
17. }
18. sum+=c;
19. }
20. printf("%d\n%d\n%d\n",max,min,sum);
21. return 0;
22. }
试题 基础练习 查找整数
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。
输入格式
第一行包含一个整数n。
第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。
第三行包含一个整数a，为待查找的数。
输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
61 9 4 8 3 99
样例输出
2
数据规模与约定
1 <= n <= 1000
思路：利用循环让输进去的每个数值进
#include<stdio.h>
2. #define N 1003
3. int main(){
4. int n,i,m,k,l;
5. int a[N];
6. scanf("%d",&n);
7. for(i=1;i<=n;i++)
8. scanf("%d",&m);
9. for(i=1;i<=n;i++){
10. if(a[i]==m){
11. k=i;
12. break;
13. }
14. else {
15. k=0;
16. }
17. if(k==0){
18. printf("%d\n");
19. }
20. else {
21. printf("%d\n",k);
22. }
23. }
24. return 0;
25. }
试题 基础练习 特殊的数字
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
153是一个非常特殊的数，它等于它的每位数字的立方和，即153=1*1*1+5*5*5+3*3*3。编程求所有满足这种条件的三位十进制数。
输出格式
按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。
这里注意一点哈！你要输出的三位数，printf里面里面要输出三个数，不然练习检测系统不会让你过！！！
说一说这里的思路：这道题是水仙花数的一道练习题不过这道题他是最后需要输出三位十进制的数
参考答案：
1. #include<stdio.h>
2. int main(){
3. int i,j,sum,num,n,m;
4. for(n=100;n<999;n++){
5. i=n/100;
6. j=(n-i*100)/10;
7. sum=(n-i*100-j*10);
8.
9. if(n==i*i*i+j*j*j+sum*sum*sum)
10. printf("%d\n",n);
11. }
12. return 0;
13. }
试题 历届试题 成绩统计【第十一届】【省赛】【C组】
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
小蓝给学生们组织了一场考试，卷面总分为 100 分，每个学生的得分都是一个 0 到 100 的整数。
如果得分至少是 60 分，则称为及格。如果得分至少为 85 分，则称为优秀。
请计算及格率和优秀率，用百分数表示，百分号前的部分四舍五入保留整数。
输入格式
输入的第一行包含一个整数 n，表示考试人数。
接下来 n 行，每行包含一个 0 至 100 的整数，表示一个学生的得分。
输出格式
输出两行，每行一个百分数，分别表示及格率和优秀率。百分号前的部分四舍五入保留整数。
样例输入
7
80
92
56
74
88
100
0
样例输出
71%
43%
思路：这道省赛题我想起了课堂上老师教的例题就是时间时间转换那一道题，加上一点循环打印的知识将打印的时间进行转换！但是你要注意数值的超出，这里需要考虑double这个关键字！！！
1. #include<stdio.h>
2. int main()
3. {
4. double a1=0,a2=0;
5. int n,i;
6. scanf("%d",&n);
7. for(i=0;i<n;i++){
8. int s;
9. scanf("%d",&s);
10. if(s>=60) a1++;
11. if(s>=85) a2++;
12. }
13. a1=(a1/n+0.005)*100;
14. a2=(a2/n+0.005)*100;
15. printf("%d%%\n%d%%",(int)a1,(int)a2);
16. return 0;
17. }
试题 历届真题 时间显示【第十二届】【省赛】【C组】
资源限制
时间限制：1.0s 内存限制：256.0MB
思路：常规的时间转化题目，得想清楚打印出来的时间转化位数就行！
1. #include<stdio.h>
2. int main (void){
3. int HH,MM,SS;
4. long long sj;
5. scanf("%lld",&sj);
6. sj/=1000;
7. SS=sj%60LL;
8. sj/=60;
9. MM=sj%60LL;
10. sj/=60;
11. HH=sj%24LL;
12. printf("%02d:%02d:%02d\n",HH,MM,SS);
13. return 0;
14. }
试题 历届真题 砝码称重【第十二届】【省赛】【C组】
资源限制
时间限制：1.0s 内存限制：256.0MB
思路：（这道题我发不出来，所以就借助了CSDN大神的思路自己稍加更改了下）： 假设法码个数为n，所能称的最大重量为w，建立一个大小为（n+1）*(w+1)的二维数组。初始化的值都为零。
dp[i][j],代表当有i个法码时是否能称出重量为j的物品，如果能，则令dp[i][j] = 1。
状态转移方程：
if dp[i-1][j]:
dp[i][j] = 1 #第i个法码不放
dp[i][j+m[i]] #第i个法码放在法码盘
if j > m[i]:
dp[i][j-m[i]] #第i个法码放在物品盘
最后计算sum（dp[n]）即可。
1. #include<stdio.h>
2. #include<stdlib.h>
3. int main(){
4. int i,m,j,sum,num,n,k=1;
5. int a[100][100];
6. int p[50];
7. scanf("%d",&n);
8. for(i=1;i<=n;i++){
9. scanf("%d",&p[i]);
10. sum=sum+p[i];
11. a[0][1]=1;
12. }
13. for(i=1;i<=n;i++){
14. for(j=0;j<=sum;j++){
15. a[i][j+1]=a[i-1][j+1];
16. if(j-p[i]==-1){
17. a[i][j+1]=a[i+1][j]-p[i];
18. if(j+p[i]==sum){
19. a[i][j+1]=a[i-1][j]+p[i];
20. }
21. }
22. }
23. }
24. int q=0;
25. for(i=1;i<=sum;i++)
26. {
27. if(a[n][j+1]){
28. q++;
29. }
30.
31. }
32. printf("%d",q);
33. }
试题 历届真题 九宫幻方【第八届】【省赛】【C组】
资源限制
时间限制：1.0s 内存限制：256.0MB
小明最近在教邻居家的小朋友小学奥数，而最近正好讲述到了三阶幻方这个部分，三阶幻方指的是将1~9不重复的填入一个3*3的矩阵当中，使得每一行、每一列和每一条对角线的和都是相同的。
三阶幻方又被称作九宫格，在小学奥数里有一句非常有名的口诀：“二四为肩，六八为足，左三右七，戴九履一，五居其中”，通过这样的一句口诀就能够非常完美的构造出一个九宫格来。
4 9 2
3 5 7
8 1 6
有意思的是，所有的三阶幻方，都可以通过这样一个九宫格进行若干镜像和旋转操作之后得到。现在小明准备将一个三阶幻方（不一定是上图中的那个）中的一些数抹掉，交给邻居家的小朋友来进行还原，并且希望她能够判断出究竟是不是只有一个解。
而你呢，也被小明交付了同样的任务，但是不同的是，你需要写一个程序~
输入格式
输入仅包含单组测试数据。
每组测试数据为一个3*3的矩阵，其中为0的部分表示被小明抹去的部分。
对于100%的数据，满足给出的矩阵至少能还原出一组可行的三阶幻方。
输出格式
如果仅能还原出一组可行的三阶幻方，则将其输出，否则输出“Too Many”（不包含引号）。
样例输入
0 7 2
0 5 0
0 3 0
样例输出
6 7 2
1 5 9
8 3 4
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
--------------
笨笨有话说：
我最喜欢这类题目了。既然九宫幻方一共也没有多少，我就不辞辛劳地一个一个写出来好了。
也不能太过分，好歹用个数组。
思路;参考一下笨笨有话说这个是官方给个提示！！那就好办了利用数组一个一个写出了就可以了！！！不过个应该是最没办法的办法了（最没办法的时候想这个！！）这道题可以试试枚举!（我把所有的都去列一遍也算一个暴力解法了，然后我发现网上有一种比较好理解的输入方式）
1. #include<stdio.h>
2. int show(int *str,int *ch)
3. {
4. int j;
5. for(j=0;j<9;j++)
6. {
7. if(str[j]==ch[j])continue;
8. if(ch[j]==0)continue;
9. if(str[j]!=ch[j])return 0;
10. }
11. return 1;
12. }
13. int main()
14. {
15. int i,k,sun,j;
16. int str[][9]={
17. {6,7,2,1,5,9,8,3,4},
18. {8,3,4,1,5,9,6,7,2},
19. {2,9,4,7,5,3,6,1,8},
20. {6,1,8,7,5,3,2,9,4},
21. {2,7,6,9,5,1,4,3,8},
22. {4,3,8,9,5,1,2,7,6},
23. {4,9,2,3,5,7,8,1,6},
24. {8,1,6,3,5,7,4,9,2},
25. };
26. int ch[9];
27. for( i=0;i<3;i++)
28. {
29. for(j=0;j<3;j++)
30. scanf("%d",&ch[i*3+j]);
31. }
32. int tmp=0;
33. for(k=0;k<8;k++)
34. {
35. if(show(str[k],ch))
36. {
37. tmp+=1;
38. if(tmp==1)i=k;
39. }
40. }
41. if(tmp==1)
42. for( j=0;j<9;j++)
43. {
44. if(j!=0 &&j%3==0)
45. printf("\n");
46. printf("%d ",str[i][j]);
47. }
48. else{
49. printf("Too Many");
50. }
51. return 0;
52. }
这种是我当时的想法（当时测不过）也当参考了
1. #include<stdio.h>
2. int test(char s[],char p[])
3. {
4. int i;
5. for(i=0;i<9;i++)
6. {
7. if(s[i]=='0')
8. continue;
9. if(s[i]==p[i])
10. continue;
11. return 0;
12. }
13. return 1;
14. }
15. int main()
16. {
17. int i,j,flag=1;
18. char s[9];
19. for(i=0;i<9;i++)
20. {
21. int num;
22. scanf("%d",&num);
23. s[i]='0'+num;
24. }
25. char p[8][10]={
26. {"492357816"},
27. {"438951276"},
28. {"294753618"},
29. {"276951438"},
30. {"672159834"},
31. {"618753294"},
32. {"834159672"},
33. {"816357492"}};
34.
35. for(i=0;i<8;i++)
36. {
37. if(test(s,p[i]))
38. {
39. printf("\n");
40. flag=0;
41. for(j=0;j<9;j++)
42. {
43. printf("%c ",p[i][j]);
44. if((j+1)%3==0)
45. {
46. printf("\n");
47. }
48. }
49.
50. }
51. }
52.
53. if(flag)
54. {
55. printf("Too Many");
56. }
57.
58. return 0;
59. }
试题 历届真题 密码脱落【第七届】【省赛】【C组】
资源限制
时间限制：1.0s 内存限制：256.0MB
X星球的考古学家发现了一批古代留下来的密码。
这些密码是由A、B、C、D 四种植物的种子串成的序列。
仔细分析发现，这些密码串当初应该是前后对称的（也就是我们说的镜像串）。
由于年代久远，其中许多种子脱落了，因而可能会失去镜像的特征。
你的任务是：
给定一个现在看到的密码串，计算一下从当初的状态，它要至少脱落多少个种子，才可能会变成现在的样子。
输入一行，表示现在看到的密码串（长度不大于1000）
要求输出一个正整数，表示至少脱落了多少个种子。
例如，输入：
ABCBA
则程序应该输出：
0
再例如，输入：
ABECDCBABC
则程序应该输出：
3
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
思路：
先看看我的初步思路（好像不太行，能过一点分！）
#include<stdio.h>
2. #include<string.h>
3. int main(){
4. int i,j,m,sum=0,num=0,n;
5. char a[100];
6. char p[50][100];
7. int k=strlen(a);
8. for(i=1;i<=n;i++){
9. scanf("%d",&a);
10. }
11. for(i=0;i<k;i++){
12. for(j=0;j<k;j++){
13. if(a[i]==a[k-j-1]){
14. p[i+1][j+1]=p[i][j]+1;
15. }
16. else {
17. p[i+1][j+1]=p[i+1][j+1];
18. }
19. }
20. }
21.
22. printf("%d",p[1][0]);
}
这个是修改版的：
试题 历届真题 买不到的数目
#include<stdio.h>
2. int main(){
3. int i,j,n,sum,num,m;
4. scanf("%d%d",&n,&m);
5. sum=n*m;
6. while(1){
7. num=1;
8. for(i=0;i<=n;i++){
9. for(j=0;j<=m;j++){
10. if(sum%n==0||sum%m==0||i*m+j*n==sum){
11. sum--;
12. num=0;
13. break;
14. }
15. }
16. }
17. if(num==1)
18. break;
19. }
20. printf("%d",sum);
21. }
试题 历届真题 买不到的数目【第四届】【省赛】【C组】
资源限制
时间限制：1.0s 内存限制：256.0MB
小明开了一家糖果店。他别出心裁：把水果糖包成4颗一包和7颗一包的两种。糖果不能拆包卖。
小朋友来买糖的时候，他就用这两种包装来组合。当然有些糖果数目是无法组合出来的，比如要买 10 颗糖。
你可以用计算机测试一下，在这种包装情况下，最大不能买到的数量是17。大于17的任何数字都可以用4和7组合出来。
本题的要求就是在已知两个包装的数量时，求最大不能组合出的数字。
输入格式
两个正整数，表示每种包装中糖的颗数(都不多于1000)
要求输出：
一个正整数，表示最大不能买到的糖数
例如：
用户输入：
4 7
程序应该输出：
17
再例如：
用户输入：
3 5
程序应该输出：
7
资源约定：
峰值内存消耗 < 64M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
思路：在while循环里面应用if去卡这个条件（说的官方一点就是枚举，然后从两个数的乘积去递减就可以找出的这个的答案！！！）
1. #include<stdio.h>
2. int main(){
3. int i,j,n,sum,num,m;
4. scanf("%d%d",&n,&m);
5. sum=n*m;
6. while(1){
7. num=1;
8. for(i=0;i<=n;i++){
9. for(j=0;j<=m;j++){
10. if(sum%n==0||sum%m==0||i*m+j*n==sum){
11. sum--;
12. num=0;
13. break;
14. }
15. }
16. }
17. if(num==1)
18. break;
19. }
20. printf("%d",sum);
21. }
试题 历届真题 带分数【第四届】【省赛】【C组】
资源限制
时间限制：1.0s 内存限制：256.0MB
100 可以表示为带分数的形式：100 = 3 + 69258 / 714
还可以表示为：100 = 82 + 3546 / 197
注意特征：带分数中，数字1~9分别出现且只出现一次（不包含0）。
类似这样的带分数，100 有 11 种表示法。
题目要求：
从标准输入读入一个正整数N (N<1000*1000)
程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。
注意：不要求输出每个表示，只统计有多少表示法！
例如：
用户输入：
100
程序输出：
11
再例如：
用户输入：
105
程序输出：
6
资源约定：
峰值内存消耗 < 64M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
思路：去遍历123456789到987654321的排列，然后每一个排列进行判断,去卡这个条件列入输入的数字满不满足条件继续，满足就就跳出，里面有些数字计算的时候记得用double类型！
提一提枚举法！！
- 枚举：将问题一一列举出来，依据要求判断，最后找到问题的解答！
- 枚举算法的优点：得到的结果一定是正确！
- 枚举算法的缺点：效率比较低！
- 方法：循环（嵌套）
例题：N根火柴棍，你可以拼出多少个如”A+B=C”的等式？等式中的A,B,C是用火柴棍拼出的整数（若该数非零，则最高位不能是0）。用火柴棍拼数字0-9的拼法
注意：1.加号与等号各自需要两根大火柴.
- 如果A不等于B,则A+B=C与B+A=C视为不同的等式（A,B,C>=0）
- N根火柴必须全部用上！
枚举的思路：确定所在的集合，确定所在的参数范围
- 对解的每个参数的数据范围采用循环语句一一枚举，然后根据给定的条件判断是否解，是否最优解！
试题 历届真题 打印十字图【第四届】【省赛】【C组】
时间限制：1.0s 内存限制：256.0MB
小明为某机构设计了一个十字型的徽标（并非红十字会啊），如下所示(可参见图片)
$
$ $
$$$
$ $ $ $
$ $$$ $
$ $ $ $ $ $
$ $ $$$ $ $
$ $ $ $ $ $ $
$ $ $ $ $ $ $
$ $ $ $ $ $ $
$ $ $$$ $ $
$ $ $ $ $ $
$ $$$ $
$ $ $ $
$$$
$ $
$
对方同时也需要在电脑dos窗口中以字符的形式输出该标志，并能任意控制层数。
为了能准确比对空白的数量，程序要求对行中的空白以句点（.）代替。
输入格式
一个正整数 n (n<30) 表示要求打印图形的层数
输出格式
对应包围层数的该标志。
例如：
用户输入：
1
程序应该输出：
..$..
..$...$..
$.$.$
$...$...$
$.$.$
$...$...$
$.$.$
..$...$..
..$..
再例如：
用户输入：
3
程序应该输出：
..$..
..$...........$..
$.$.$
$...$.......$...$
$.$.$.$.$
$.$...$...$...$.$
$.$.$.$.$.$.$
$.$.$...$...$.$.$
$.$.$.$.$.$.$
$.$.$...$...$.$.$
$.$.$.$.$.$.$
$.$...$...$...$.$
$.$.$.$.$
$...$.......$...$
$.$.$
..$...........$..
..$..
请仔细观察样例，尤其要注意句点的数量和输出位置。
资源约定：
峰值内存消耗 < 64M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
思路：！！！！！
仔细看看A区域你会发现他是（1.3.5.7）排列，中间是一个十字，外层是一个个圈圈包围起来的！如果不清楚可以多加几个线圈这样看起来更加直观！
- 先有一个初始化白色区域然后在想办法将红色的打印出红色的格子！
- 确定中心坐标（横纵相等），然后将四个方向初始化，进行增减填充处理，最后一步将其打印出来！
参考代码!
1. #include<stdio.h>
2. int main(){
3. char a[130][130];
4. int df[4][2]={{-1,1},{1,1},{1,-1},{-1,-1}};
5. //第一个数是行偏移值 第二个是列偏移值 右上 右下 左下 左上
6. int i,n,x,x1,x2,y1,k,j; //x是中心位置 x1 x2是偏移量
7. scanf("%d",&n);
8. x=(n*4+5)/2 +1; //计算中心点的坐标 (横纵相等)
9. for(i=x-2;i<=x+2;i++)
10. a[x][i]='$',a[i][x]='$';
11. for(i=1,x1=x+4,x2=x-4;i<=n;i++,x1+=2,x2-=2) //x1 x2是按照每次增加或减少两种
12. for(k=x-i*2;k<=x+i*2;k++){ //对相连$部分处进行填充
13. a[x1][k]='$'; a[k][x1]='$';
14. a[x2][k]='$'; a[k][x2]='$';
15. }
16. for(i=0;i<4;i++){ //四个方向
17. x1=x+df[i][0]*2; y1=x+df[i][1]*2; //初始化某方向上的起始点
18. for(j=1;j<=n;j++){
19. a[x1][y1]='$';
20. a[x1+df[i][0]][y1]='$'; a[x1][y1+df[i][1]]='$';
21. x1=x1+df[i][0]*2; y1=y1+df[i][1]*2;
22. }
23. }
24. for( i=1;i<=n*4+5;i++){ //打印
25. for(j=1;j<=n*4+5;j++)
26. if(a[i][j]=='$') printf("%c",a[i][j]);
27. else printf(".");
28. printf("\n");
29. }
30. return 0;
31. }
试题 算法训练 字符串比较
题目描述
编程实现两个字符串s1和s2的字典序比较。。若s1和s2相等，输出0；若它们不相等，则指出其第一个不同字符的ASCII码的差值：如果s1> s2，则差值为正；如果s1< s2，则差值为负。
输入
输入两个字符串，空格隔开（保证每一个字符串不是另一个的前缀，且长度在100以内）
输出
他们比较后的值
样例输入复制
java basic
样例输出复制
8
思路：需要查一下书这里他需要去调用一个头文件去用这个strcmp函数(我也是上百度查的)！然后创建数组去用好这个条件!
strcmp 的作用
思路：通过枚举来去找这个答案的所有结果（你可让枚举出六位数字进行重复的列举这个问题所需要的条件）
运行限制
思路：这道题看起来用for循环就直接可以解决问题，其实不然使用for就直接超时，根本过不了检测，所有考虑用深搜(不了解深度搜索的可以看啊哈！算法这本算法书里面就清晰介绍了深度搜索的知识点！)
- 比较两个字符串的顺序是否完全一致
- 注意 ：完全一致的意思是字符串里的每个字符，顺序都一致
-
• #include<stdio.h> • #include<string.h> • int main(){ • char a[100],c[100]; • int i,j,k,l,sum,num,n; • scanf("%s%s",&a,&c); • if(strcmp(a,c)==0) • printf("0"); • else • for(i=0;i<100;i++) • if(a[i]-c[i]!=0){ • printf("%d",a[i]-c[i]); • break; • } • return 0; • }试题 历届真题 四平方和【第七届】【省赛】【C组】
-
资源限制
时间限制：1.0s 内存限制：256.0MB
四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多4个正整数的平方和。
如果把0包括进去，就正好可以表示为4个数的平方和。
比如：
5 = 0^2 + 0^2 + 1^2 + 2^2
7 = 1^2 + 1^2 + 1^2 + 2^2
（^符号表示乘方的意思）
对于一个给定的正整数，可能存在多种平方和的表示法。
要求你对4个数排序：
0 <= a <= b <= c <= d
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法
程序输入为一个正整数N (N<5000000)
要求输出4个非负整数，按从小到大排序，中间用空格分开
例如，输入：
5
则程序应该输出：
0 0 1 2
再例如，输入：
12
则程序应该输出：
0 2 2 2
再例如，输入：
773535
则程序应该输出：
1 1 267 838
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。思路：利用for循环将数值带进去判断是是否符合每个正整数都可以表示为至多4个正整数的平方和条件（if条件语句），这里需要考虑最后一个条件，需要取平方去解决得调用一个头文件<math.h>去使用sqrt函数。也可以在里面是试试交换解决数值！后续需要去注意一下这个return的返回值使用！
参考代码：
1. #include<stdio.h> 2. #include<math.h> 3. int main(){ 4. int temp ,c; 5. int n,sum,num,k,i,p,l,b; 6. scanf("%d",&n); 7. for(b=0;b<n;b++){ 8. for(l=b;l<n;l++){ 9. for(k=l;k<n;k++){ 10. p=sqrt(n-b*b-l*l-k*k); 11. if(n==b*b+l*l+k*k+p*p){ 12. printf("%d %d %d %d",b,l,k,p); 13. return 0; 14. } 15. } 16. } 17. 18. } 19. return 0; 20. }题目描述
小蓝负责花园的灌溉工作。
花园可以看成一个 nn 行 mm 列的方格图形。中间有一部分位置上安装有出水管。
小蓝可以控制一个按钮同时打开所有的出水管，打开时，有出水管的位置可以被认为已经灌溉好。
每经过一分钟，水就会向四面扩展一个方格，被扩展到的方格可以被认为已经灌溉好。即如果前一分钟某一个方格被灌溉好，则下一分钟它上下左右的四个方格也被灌溉好。
给定花园水管的位置，请问 kk 分钟后，有多少个方格被灌溉好？
输入描述
输入的第一行包含两个整数 n, mn,m。
第二行包含一个整数 tt，表示出水管的数量。
接下来 tt 行描述出水管的位置，其中第 ii 行包含两个数 r, cr,c 表示第 rr 行第 cc 列有一个排水管。
接下来一行包含一个整数 kk。
其中，1 \leq n, m \leq 100, 1 \leq t \leq 10, 1 \leq k \leq 1001≤n,m≤100,1≤t≤10,1≤k≤100。
输出描述
输出一个整数，表示答案。
输入输出样例
示例 1
输入
3 622 23 41出9运行限制
- 最大运行时间：1s
- 最大运行内存: 128M
-
• #include<stdio.h> • int main(){ • int i,n,m,sum,num,p,j,q,w,e,b; • int a[100][50],k[100][50],y[50]; • scanf("%d%d%d",&q,&w,&e); • for(i=1;i<p;i++){ • scanf("%d%d",&n,&m); • a[n][m]=1; • k[n][m]=1; • } • scanf("%d",&b); • while(b>1){ • for(i=1;i<q;i++){ • for(j=1;j<w;j++){ • for(sum=1;i<e;i++){ • if(a[n][m]==1){ • num++; • } • } • } • } • } • printf("%d",num); • return 0; • • }排它平方数（算法提升）
小明正看着 2110 这个数字发呆。
原来，203879 * 203879 = 41566646641203879∗203879=41566646641。
这有什么神奇呢？仔细观察，203879203879 是个 66 位数，并且它的每个数位上的数字都是不同的，并且它平方后的所有数位上都不出现组成它自身的数字。
具有这样特点的 66 位数还有一个，请你找出它！
再归纳一下筛选要求：
- 66 位正整数；
- 每个数位上的数字不同；
- 其平方数的每个数位不含原数字的任何组成数位。
- 最大运行时间：1s
- 最大运行内存: 128M
-
思路：通过枚举来去找这个答案的所有结果（你可让枚举出六位数字进行重复的列举这个问题所需要的条件）
-
1. #include <stdio.h> 2. #include <stdlib.h> 3. 4. int main(int argc, char *argv[]) 5. { 6. for(long long i=123456;i<=987654;i++) 7. { 8. int a[10]={0}; 9. if(i!=203879) 10. { 11. long long t=i; 12. while(t) 13. { 14. a[t%10]=1; 15. t/=10; 16. } 17. long long x=i*i; 18. while(x) 19. { 20. a[x%10]=0; 21. x/=10; 22. } 23. int count=0; 24. for(int p=0;p<10;p++) 25. count+=a[p]; 26. if(count==6) 27. { 28. printf("%lld",i); 29. break; 30. } 31. } 32. } 33. return 0; 34. }蓝桥杯填空题
-
题目描述：本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
-
(□□□□-□□□□)*□□=900
其中的小方块代表 00 ~ 99 的数字，这 1010 个方块刚好包含了 00 ~ 99 中的所有数字。 注意：00 不能作为某个数字的首位。
小明经过几天的努力，终于做出了答案！如下：
(5012-4987)*36=900
用计算机搜索后，发现还有另外一个解，本题的任务就是：请你算出这另外的一个解。
注意：输出格式需要与示例严格一致； 括号及运算符号不要用中文输入法； 整个算式中不能包含空格。
运行限制：
- 最大：运行时间：1s
- 最大运行内存: 128M
-
思路：这道题看起来用for循环就直接可以解决问题，其实不然使用for就直接超时，根本过不了检测，所有考虑用深搜(不了解深度搜索的可以看啊哈！算法这本算法书里面就清晰介绍了深度搜索的知识点！)
1. #include<stdio.h>
2. int ans[10];
3. int mid[10]={0,1,2,3,4,5,6,7,8,9};
4. int book[10]={0};
5.
6. void dfs(int step)
7. {
8. int i;
9. int a,b,c;
10. if(step==10)
11. {
12. if(ans[0]!=0&&ans[4]!=0&&ans[8]!=0)
13. {
14. a=ans[0]*1000+ans[1]*100+ans[2]*10+ans[3];
15. b=ans[4]*1000+ans[5]*100+ans[6]*10+ans[7];
16. c=ans[8]*10+ans[9];
17. if((a-b)*c==900)
18. {
19. printf("(%d-%d)*%d=900\n",a,b,c);
20. }
21. }
22. }
23. for(i=0;i<10;i++)
24. {
25. if(book[i]==0)
26. {
27. ans[step]=mid[i];
28. book[i]=1;
29. dfs(step+1);
30. book[i]=0;
31. }
32. }
33.
34. }
35. int main()
36. {
37. dfs(0);
38. return 0;
39. }
第二种思路即使用暴力破解即可（暴力破解也是作为一种重要手段）
题目描述-金币
在很久很久以前，有 nn 个部落居住在平原上，依次编号为 11 到 nn。第 ii 个部落的人数为 t_iti。
有一年发生了灾荒。年轻的政治家小蓝想要说服所有部落一同应对灾荒，他能通过谈判来说服部落进行联合。
每次谈判，小蓝只能邀请两个部落参加，花费的金币数量为两个部落的人数之和，谈判的效果是两个部落联合成一个部落（人数为原来两个部落的人数之和）。
输入描述
输入的第一行包含一个整数 nn，表示部落的数量。
第二行包含 nn 个正整数，依次表示每个部落的人数。
其中
输出描述
输出一个整数，表示最小花费。
输入输出样例
示例 1输入
49 1 3 5输出
31运行限制
- 最大运行时间：1s
- 最大运行内存: 128M
思路：通过for循环去找这个最小值，通过最小值来讲所有的解列出，中间看好条件的需要，将条件设计成问题所需要的条件，进行最后一步输出，但是要注意这里J需要自减，最后一步需要从1开始循环，不然最终会输出33这个答案！
1. #include<stdio.h>
2. int main(){
3. int i,j,sum,num,a[1001],k;
4. int n,m;
5. scanf("%d",&n);
6. for(i=0;i<n;i++)
7. scanf("%d",&a[i]);
8. for(i=0;i<n;i++){
9. for(j=0;j<n-1;j++){
10. if(a[i]>a[j+1]){
11. k=a[j];
12. a[j]=a[j+1];
13. a[j+1]=k;
14. }
15. }
16. }
17. j=n-1;
18. k=(a[0]+a[1])*j;
19. j--;
20. for(i=1;i<n;i++){
21. k+=(a[i]*j);
22. j--;
23. }
24. printf("%d",k);
25. return 0;
26. }
题目描述--金币
国王将金币作为工资，发放给忠诚的骑士。第一天，骑士收到一枚金币；之后两天（第二天和第三天），每天收到两枚金币；之后三天（第四、五、六天），每天收到三枚金币；之后四天（第七、八、九、十天），每天收到四枚金币......；这种工资发放模式会一直这样延续下去：当连续 NN 天每天收到 NN 枚金币后，骑士会在之后的连续 N+1N+1 天里，每天收到 N+1N+1 枚金币。
请计算在前 KK 天里，骑士一共获得了多少金币。
输出
输入只有 1 行，包含一个正整数 K\ （1 \leq K \leq 10^4）K （1≤K≤104），表示发放金币的天数。
示例 1
6
输出
14
OK测试可以通过，先上代码！
1. #include<stdio.h>
2. int main(){
3. int i,j,k,sum=0,n,num=0,ans=0;
4. scanf("%d",&n);
5. for(i=1;i<=n;i++){
6. for(j=1;j<=i;j++){
7. num+=i;
8. sum++;
9. if(sum==n){
10. printf("%d",num);
11. return 0;
12. }
13. }
14. }
15. return 0;
16. }
题目描述-赞助
某小学最近得到了一笔赞助，打算拿出其中一部分为学习成绩优秀的前 5 名学生发奖学金。期末，每个学生都有 3 门课的成绩：语文、数学、英语。先按总分从高到低排序，如果两个同学总分相同，再按语文成绩从高到低排序，如果两个同学总分和语文成绩都相同，那么规定学号小的同学排在前面，这样，每个学生的排序是唯一确定的。
任务：先根据输入的 3 门课的成绩计算总分，然后按上述规则排序，最后按排名顺序输出前 5 名学生的学号和总分。注意，在前 5 名同学中，每个人的奖学金都不相同，因此，你必须严格按上述规则排序。例如，在某个正确答案中，如果前两行的输出数据（每行输出两个数：学号、总分）是：
7 279
5 279
这两行数据的含义是：总分最高的两个同学的学号依次是 7 号、5 号。这两名同学的总分都是 279 （总分等于输入的语文、数学、英语三科成绩之和），但学号为 7 的学生语文成绩更高一些。如果你的前两名的输出数据是：
5 279
7 279
则按输出错误处理，不能得分
输入描述
第 11 行为一个正整数 n\ (6 \leq n \leq 300)n (6≤n≤300)，表示该校参加评选的学生人数。
第 22 到 n+1n+1 行，每行有 33 个用空格隔开的数字，每个数字都在 00 到 100100 之间。第 jj 行的 33 个数字依次表示学号为 j-1j−1 的学生的语文、数学、英语的成绩。每个学生的学号按照输入顺序编号为 11 ~ nn（恰好是输入数据的行号减 11）。
所给的数据都是正确的，不必检验。
输出描述
输出共有 55 行，每行是两个用空格隔开的正整数, 依次表示前 55 名学生的学号和总分。
输入输出样例：
6
90 67 80
87 66 91
78 89 91
88 99 77
67 89 64
78 89 98
输出
6 265
4 264
3 258
2 244
1 237
1. #include <stdio.h>
2. #include <stdlib.h>
3. typedef struct {
4. int stu_number;
5. int Chinese;
6. int Math;
7. int English;
8. int all_sorce;
9. }stu_score;
10. stu_score stu[300];
11. int main(int argc, char* argv[])
12. {
13. // 请在此输入您的代码
14. int stu_num;
15. scanf("%d", &stu_num);
16. for (int i = 0; i < stu_num; i++) {
17. stu[i].stu_number = i + 1;
18. scanf("%d", &stu[i].Chinese);
19. scanf("%d", &stu[i].Math);
20. scanf("%d", &stu[i].English);
21. stu[i].all_sorce = stu[i].Chinese + stu[i].English + stu[i].Math;
22. }
23. for (int i = 1; i < stu_num; i++) {
24. if (stu[i].all_sorce >= stu[i - 1].all_sorce) {
25. stu_score now_stu = stu[i];
26. int j;
27. for (j = i - 1; stu[j].all_sorce <= now_stu.all_sorce && j >= 0; j--) {
28. if (stu[j].all_sorce < now_stu.all_sorce) {
29. stu[j + 1] = stu[j];
30. }
31. else if (stu[j].Chinese < now_stu.Chinese) {
32. stu[j + 1] = stu[j];
33. }
34. else if (stu[j].stu_number > now_stu.stu_number) {
35. stu[j + 1] = stu[j];
36. }
37. else {
38. break;
39. }
40.
41. }
42. stu[j + 1] = now_stu;
43. }
44. }
45. for (int i = 0; i < 5 && stu[i].stu_number != NULL; i++) {
46. printf("%d %d\n", stu[i].stu_number, stu[i].all_sorce);
47. }
48. return 0;
49. }
测试可以通过！！！
题目：小明的背包2
小明有一个容量为 VV 的背包。
这天他去商场购物，商场一共有 NN 种物品，第 ii 种物品的体积为 w_iwi，价值为 v_ivi，每种物品都有无限多个。
小明想知道在购买的物品总体积不超过 VV 的情况下所能获得的最大价值为多少，请你帮他算算。
输入描述：
输入第 11 行包含两个正整数 N,VN,V，表示商场物品的数量和小明的背包容量。
第 2\sim N+12∼N+1 行包含 22 个正整数 w,vw,v，表示物品的体积和价值。
输出一行整数表示小明所能获得的最大价值。
输入
5 201 62 53 85 153 3 输出
120限制：- 最大运行时间：1s
- 最大运行内存: 256M
思路：难度: 简单 标签: DP, 背包, 完全背包！！！（简单的动态规划问题）(DP动态规划一般大多数是模板，你会发现这道题其实就是完全按DP模板就写出来，但是在最后一步是要想清楚是装不下的时候该怎么办，所以你会需要一个函数MAX去调用这个（称为最优路径的话语），然后将for循环将他嵌套进去！注意不要超时！！
1. #include<stdio.h>
2. int max(int x,int y){
3. if(x>y){
4. return x;
5. }else{
6. return y;
7. }
8. }
9. int main(){
10. int i,j,m,sum,num,n,p[1005]={0};
11. int w[1005]={0};
12. int dp[1005][1005]={0};
13. scanf("%d%d",&n,&m);
14. for(i=1;i<n;i++)
15. scanf("%d%d",&p[i],&w[i]);
16. for(i=1;i<=n;i++){
17. for(j=1;j<=m;j++){
18. if(p[i]>j){
19. dp[i][j]=dp[i-1][j];
20. }
21. else
22. dp[i][j]=max(dp[i-1][j],dp[i][j-p[i]]+w[i]);
23. }
24. }
25. printf("%d",dp[n][m]);
26. return 0;
27. }
题目描述 （找素数）
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
素数就是不能再进行等分的整数。比如：7，117，11。而 99 不是素数，因为它可以平分为 33 等份。一般认为最小的素数是22，接着是 3，5，...3，5，...
请问，第 100002(十万零二)个素数是多少？
请注意：“2”“2” 是第一素数，“3”“3” 是第二个素数，依此类推。
1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <math.h>
4. int main(int argc, char *argv[])
5. {
6. int i,n,sum,p[100][100],o;
7. int num=100002;
8. for(i=2;;i++){
9. sum=1;
10. for(n=2;n<=sqrt(i);n++){
11. if(i%n==0){
12. sum=0;
13. break;
14. }
15. }
16. if(sum==1){
17. o++;
18. }
19. if(o==100002){
20. printf("%d",i);
21. break;
22. }
23. }
24. return 0;
25. }
思路（暴力破解+上枚举思想，但是注意优化代码别超时！！）
题目 1439: 蓝桥杯历届试题-盾神与砝码称重
题目描述
有一天，他在宿舍里无意中发现了一个天平！这 个天平很奇怪，有n个完好的砝码，但是没有游码。盾神为他的发现兴奋不已！于是他准备去称一称自己的东西。他准备好了m种物品去称。神奇的是，盾神一早就 知道这m种物品的重量，他现在是想看看这个天平能不能称出这些物品出来。但是盾神稍微想了1秒钟以后就觉得这个问题太无聊了，于是就丢给了你。
输入
第一行为两个数，n和m。
第二行为n个数，表示这n个砝码的重量。
第三行为m个数，表示这m个物品的重量。
数据规模和约定
1< =n< =24, 1< =m< =10.
输出
输出m行，对于第i行，如果第i个物品能被称出，输出YES否则输出NO。
样例输入复制
4 2
1 2 4 8
15 16
样例输出复制
YES
NO
1. #include<stdio.h>
2. #include<string.h>
3. int n,m,way=0,a[30],b[30];
4. int panduan(int sum,int i)
5. {
6. if(sum==0)//当正好等于sum的重量时，可以成功，
7. {
8. way=1;
9. return 1;
10. }
11. if(i<0)//当数组遍历完的时候，结束
12. {
13. return 0;
14. }
15. panduan(sum-a[i],i-1);//将这块砝码放置在左边
16. panduan(sum,i-1);//不放置这块砝码
17. panduan(sum+a[i],i-1);//将这块砝码放置到右边
18. }
19. void main()
20. {
21. scanf("%d%d",&n,&m);
22. int i;
23. for(i=0;i<n;i++)//将砝码的重量存入数组a中
24. {
25. scanf("%d",a+i);
26. }
27. for(i=0;i<m;i++)//将每次测试的质量存入数组b中
28. {
29. scanf("%d",b+i);
30. }
31. for(i=0;i<m;i++)//将每次测试的质量存入数组b中
32. {
33. panduan(b[i],n-1);
34. if(way==1)
35. {
36. printf("YES\n");
37. }
38. else
39. {
40. printf("NO\n");
41. }
42. way=0;
43. }
44. }
蓝桥杯2020年第十一届省赛真题-走方格
题目描述
在平面上有一些二维的点阵。
这些点的编号就像二维数组的编号一样，从上到下依次为第 1 至第 行，从左到右依次为第 1 至第 列，每一个点可以用行号和列号来表示。
现在有个人站在第 1 行第 1 列，要走到第 行第 列。
只能向右或者向下走。
注意，如果行号和列数都是偶数，不能走入这一格中。
问有多少种方案。
输入
输入一行包含两个整数 。
输出
输出一个整数，表示答案。
样例输入复制
3 4
样例输出复制
2
思路（DP深搜打法，尝试一般深度搜索讲可能性走完，深度不到就回溯！！！上一道有知识点！！！）
1. #include<stdio.h>
2. int main(){
3. int i,j,k,sum,num,p[100][100],n,m;
4. scanf("%d%d",&n,&m);
5. p[1][1]=1;
6. for(i=0;i<=n;i++){
7. for(j=0;j<=m;j++){
8. if(i%2!=0||j%2!=0){
9. p[i][j]+=p[i-1][j]+p[i][j-1];
10. }
11. }
12. }
13. printf("%d",p[n][m]);
14. return 0;
15.
16. }
题目描述 -卡片
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
小蓝有很多数字卡片，每张卡片上都是数字 00 到 99。 小蓝准备用这些卡片来拼一些数，他想从 11 开始拼出正整数，每拼一个， 就保存起来，卡片就不能用来拼其它数了。 小蓝想知道自己能从 11 拼到多少。 例如，当小蓝有 3030 张卡片，其中 00 到 99 各 33 张，则小蓝可以拼出 11 到 1010， 但是拼 1111 时卡片 11 已经只有一张了，不够拼出 1111。 现在小蓝手里有 00 到 99 的卡片各 20212021 张，共 2021020210 张，请问小蓝可以从 11 拼到多少？
提示：建议使用计算机编程解决问题
运行限制
最大运行时间：1s
最大运行内存: 128M
• #include <stdio.h>
• #include <stdlib.h>
• int main(int argc, char *argv[])
• {
• //1消耗最快 把1弄完就ok了
• int i,j,count=0;
• for(i=1;i<15000;i++){
• for(j=i;j>0;j=j/10){
• if(j%10==1){
• count++;}
• if(count>2021){
• printf("%d",i-1);
• return 0;
• }
}
• }
• }
题目: 蓝桥杯历届试题-跑步锻炼
题目描述
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
小蓝每天都锻炼身体。
正常情况下，小蓝每天跑 11 千米。如果某天是周一或者月初（11 日），为了激励自己，小蓝要跑 22 千米。如果同时是周一或月初，小蓝也是跑 22 千米。
小蓝跑步已经坚持了很长时间，从 20002000 年 11 月 11 日周六（含）到 20202020 年 1010 月 11 日周四（含）。请问这段时间小蓝总共跑步多少千米？
运行限制
- 最大运行时间：1s
- 最大运行内存: 128M
-
• #include<stdio.h> • int main(){ • int months[13]={0,31,28,31,30,31,30,31,31,30,31,30,31}; • int i,j,k; • int num=0; • int sum=6; • for(i=2000;i<=2020;i++){ • if(i%4==0&&i%100!=0||i%400==0){ • months[2]=29; • } • else { • months[2]=28; • } • for(j=1;j<=12;j++){ • for(k=1;k<=months[j];k++){ • num++; • if(sum==8){ • sum=1; • } • if(sum==1||k==1){ • num++; • } • sum++; • if(i==2020&&j==10&&k==1){ • • printf("%d\n",num); • } • } • • } • } • • return 0; • }题目: 蓝桥杯历届试题-蛇形填空
-
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
如下图所示，小明用从 11 开始的正整数“蛇形”填充无限大的矩阵。
1 2 6 7 15 ...
3 5 8 14 ...
4 9 13 ...
10 12 ...
11 ...
...
容易看出矩阵第二行第二列中的数是 55。请你计算矩阵中第 2020 行第 2020 列的数是多少？
运行限制
- 最大运行时间：1s
- 最大运行内存: 128M
-
• #include<stdio.h> • int main(){ • int p[21]; • int i,k,sum,num=1,n; • for(i=0;i<20;i++){ • num=num+i*4; • } • printf("%d",num); • return 0; • }题目: 蓝桥杯历届试题-跳跃
小蓝在一个 nn 行 mm 列的方格图中玩一个游戏。
开始时，小蓝站在方格图的左上角，即第 11 行第 11 列。
小蓝可以在方格图上走动，走动时，如果当前在第 rr 行第 cc 列，他不能走到行号比 rr 小的行，也不能走到列号比 cc 小的列。同时，他一步走的直线距离不超过 33。
例如，如果当前小蓝在第 33 行第 55 列，他下一步可以走到第 33 行第 66 列、第 33 行第 77 列、第 33 行第 88 列、第 44 行第 55 列、第 44 行第 66 列、第 44 行第 77 列、第 55 行第 55 列、第 55 行第 66 列、第 66 行第 55 列之一。
小蓝最终要走到第 nn 行第 mm 列。
在图中，有的位置有奖励，走上去即可获得，有的位置有惩罚，走上去就要接受惩罚。奖励和惩罚最终抽象成一个权值，奖励为正，惩罚为负。
小蓝希望，从第 11 行第 11 列走到第 nn 行第 mm 列后，总的权值和最大。请问最大是多少？
输入描述
输入的第一行包含两个整数 n, mn,m，表示图的大小。
接下来 nn 行，每行 mm 个整数，表示方格图中每个点的权值。
其中，1 \leq n \leq 100，-10^4 \leq 权值 \leq 10^41≤n≤100，−104≤权值≤104。
输出描述
输出一个整数，表示最大权值和。
输入输出样例
示例 1
3 5
-4 -5 -10 -3 1
7 5 -9 3 -10
10 -2 6 -10 -4
输出：15
-
1. #include<stdio.h> 2. int p[120][120]; 3. int n,m,k; 4. int find(int x,int y){ 5. int i,j,sum,num=0; 6. int app=0; 7. for(i=x;i>=n;i--){ 8. for(j=y;j>=1;j--){ 9. if(!(x==i&&y==j)&&(x-i+y-j)<=3&&app<p[i][j]){ 10. app=p[i][j]; 11. } 12. } 13. } 14. return app; 15. } 16. int main(){ 17. int i,j,n,m; 18. scanf("%d %d",&n,&m); 19. for(i=1;i<=n;i++){ 20. for(j=1;j<=m;j++){ 21. scanf("%d",&p[i][j]); 22. } 23. } 24. for(i=1;i<=n;i++){ 25. for(j=1;j<=m;j++){ 26. p[i][j]+=find(i,j); 27. } 28. } 29. printf("%d\n",p[n][m]+p[1][2]+1); 30. return 0; 31. }思路（需要想好在开头定义一个函数，拿这个函数去让这个权值由下往上推动和右边往左边推动，但是不能比它这个r行号还小，也不能比列好C小，所以你需要三个条件去卡住它！并且这三个条件需要同时满足！1.不能再原地不动，需要去检测数组有遍历一遍；2.每次跳跃都需要在合理范围内3.当这个函数值更新时需要重新打上标签！！！
-
题目: 蓝桥杯2021届试题-受伤的皇后
-
有一个 n \times nn×n 的国际象棋棋盘（nn 行 nn 列的方格图），请在棋盘中摆放 nn 个受伤的国际象棋皇后，要求：
- 任何两个皇后不在同一行。
- 任何两个皇后不在同一列。
- 如果两个皇后在同一条 45 度角的斜线上，这两个皇后之间行号的差值至少为 3 。
-
请问一共有多少种摆放方案。
输入描述
输入的第一行包含一个整数 nn。
其中，1 \leq n \leq 101≤n≤10。
输出描述
输出一个整数，表示答案。
输入输出样例
示例 1
输入
4
输出
-
#include<stdio.h> 2. #include<math.h> 3. int p[12]; 4. int sum=0,num=1; 5. int k,j,i; 6. int fund(int j){ 7. if(j==sum){ 8. num++; 9. } 10. for(i=0;i<=sum;i++){ 11. for(k=0;k<j;k++){ 12. if(p[k]==i) 13. break; 14. if(j-k<3&&j-k==abs(i-p[k])) 15. break; 16. } 17. if(k==j){ 18. p[j]=i; 19. fund(j+1); 20. } 21. } 22. } 23. int main (){ 24. scanf("%d",&sum); 25. fund(0); 26. printf("%d",num); 27. return 0; 28. }题目: 蓝桥杯2021届试题-最少砝码
-
问题描述
你有一架天平。现在你要设计一套砝码，使得利用这些砝码可以称出任意 小于等于 NN 的正整数重量。
那么这套砝码最少需要包含多少个砝码？
注意砝码可以放在天平两边。
输入格式
输入包含一个正整数 N。
输出格式
输出一个整数代表答案。
样例输入
7
样例输出
3
样例说明
33 个砝码重量是 1、4、61、4、6，可以称出 11 至 77的所有重量。
1 = 1；1=1；
2 = 6 − 42=6−4(天平一边放 66，另一边放 44)；
3 = 4 − 1；3=4−1；
4 = 4；4=4；
5 = 6 − 1；5=6−1；
6 = 6；6=6；
7 = 1 + 6；7=1+6；
少于 33 个砝码不可能称出 11 至 77 的所有重量。
评测用例规模与约定
对于所有评测用例，1 ≤ N ≤ 10000000001≤N≤1000000000。
运行限制
最大运行时间：1s
最大运行内存: 512M
-
1. #include<stdio.h> 2. #include<math.h> 3. int main(){ 4. int i,j,sum=0,num=1,n,m=1; 5. scanf("%d",&n); 6. while(sum<n){ 7. num++; 8. m=m*3; 9. sum+=m; 10. } 11. printf("%d",num); 12. return 0; 13. 14. }题目: 蓝桥杯2021届试题-距离和
-
题目描述
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
两个字母之间的距离定义为它们在字母表中位置的距离。例如 AA 和 CC 的距离为 22，LL 和 QQ 的距离为 55。
对于一个字符串，我们称字符串中两两字符之间的距离之和为字符串的内部距离。
例如：
ZOO的内部距离为 2222，其中 ZZ 和 OO 的距离为 1111。请问，
LANQIAO的内部距离是多少？运行限制
最大运行时间：1s
最大运行内存: 128M
-
1. #include<stdio.h> 2. #include<string.h> 3. #include<string.h> 4. int main(){ 5. char a[7]={'L','A','N','Q','I','A','O'}; 6. int i,j,l,k,sum=0,num=0; 7. for(i=0;i<7;i++){ 8. for(j=i;j<7;j++){ 9. if(a[i]>a[j]){ 10. sum+=a[i]-a[j]; 11. } 12. else sum+=a[j]-a[i]; 13. } 14. } 15. printf("%d",sum); 16. return 0; 17. }题目: 蓝桥杯2021届试题-最大间隙
-
题目描述
给定一个序列 a_1, a_2, \cdots, a_na1,a2,⋯,an。其中 a_1 \leq a_2 \leq \cdots \leq a_na1≤a2≤⋯≤an。
相邻两个数之间的差（后一个数减前一个数）称为它们的间隙。
请问序列中最大的间隙值是多少？
输入描述
输入的第一行包含一个整数 nn，表示序列的长度。
第二行包含 nn 个正整数，为给定的序列。
其中，1 \leq n \leq 1000，1 \leq a_i \leq 10^51≤n≤1000，1≤ai≤105。
输出描述
输出一个整数，表示序列中最大的间隙值。
输入输出样例
示例 1
输入
5
1 3 8 9 12
输出
5
运行限制
最大运行时间：1s
最大运行内存: 128M
-
1. #include <stdio.h> 2. int main(){ 3. int num=0; 4. int i,j,sum,m,n; 5. scanf("%d",&n); 6. int a,b; 7. for(i=1;i<n;i++){ 8. if(i==0||i==1){ 9. scanf("%d",&a); 10. }else 11. a=b; 12. sum=b-a; 13. 14. if(num<sum) 15. num=sum; 16. } 17. printf("%d",num); 18. 19. return 0; 20. }题目: 蓝桥杯2020届试题（省赛）- 斐波那契数列最大公约数
-
题目描述
斐波那契数列满足 F1 = F2 = 1F1=F2=1，从 F3F3 开始有 Fn = Fn−1 +Fn−2Fn=Fn−1+Fn−2。
请你计算 GCD(F2020,F520)GCD(F2020,F520)，其中 GCD(A,B)GCD(A,B) 表示 AA 和 BB 的最大公约数。
输入描述
无。
输出描述
无。
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
运行限制
最大运行时间：1s
最大运行内存: 128M
（思路使用递归法，将所求的数值求出来，这道题考的是递归的思想）
-
#include <stdio.h> 2. int ged(int a,int b){ 3. if(a%b!=0) 4. return ged(a,a%b); 5. else 6. return b; 7. } 8. int fn(int x){ 9. if(x==1||x==2){ 10. return 1; 11. } 12. return fn(x-1)+fn(x-2); 13. } 14. int main() 15. { 16. printf("%d",fn(ged(2020,520))); 17. return 0; 18. }题目: 蓝桥杯2019届试题（省赛）-完全二叉树的权值
-
题目描述
给定一棵包含 NN 个节点的完全二叉树，树上每个节点都有一个权值，按从 上到下、从左到右的顺序依次是 A_1, A_2, ··· A_NA1,A2,⋅⋅⋅AN，如下图所示：
现在小明要把相同深度的节点的权值加在一起，他想知道哪个深度的节点 权值之和最大？如果有多个深度的权值和同为最大，请你输出其中最小的深度。
注：根的深度是 1。
输入描述
第一行包含一个整数 N（1 \leq N \leq 10^5）N（1≤N≤105）。
第二行包含 NN 个整数 A_1, A_2, ··· A_N （−10^5 \leq A_i \leq 10^5）A1,A2,⋅⋅⋅AN（−105≤Ai≤105）。
输出描述
输出一个整数代表答案。
输入输出样例
示例
输入
7
1 6 5 4 3 2 1
输出
2
运行限制
最大运行时间：1s
最大运行内存: 256M
思路：动态Dp的打法，每次找到最大值都保留下来，找好空针和空值的限制,不熟悉DP的去找找CSDNc/c++淇找到博客算法基础！！
1. #include <stdio.h> 2. #include <math.h> 3. int next(int x,int y){ 4. if(x<y){ 5. return y; 6. }else { 7. return x; 8. } 9. } 10. int main(){ 11. int i,j,sum,mum=0,n; 12. scanf("%d",&n); 13. int a[n][n]; 14. for(i=0;i<=n;i++){ 15. for(j=0;j<i+1;j++){ 16. scanf("%d",&a[i][j]); 17. } 18. } 19. for(i=0;i<=n;i++){ 20. for(j=0;j<i+1;j++) 21. { 22. if(i>=1){ 23. if(j==0){ 24. a[i][j]+=a[i-1][j]; 25. } 26. else if(j==i) 27. { 28. a[i][j]+=a[i-1][j-1]; 29. }else 30. { 31. mum=next(a[i-1][j-1],a[i-1][j]); 32. a[i][j]+=mum; 33. } 34. } 35. } 36. } 37. if(n%2==1) 38. printf("%d\n",a[n-1][(n-1)/2]); 39. else 40. printf("%d\n",next(a[n-1][(n-1)/2],a[n-1][(n-1)/2+1])); 41. return 0; 42. }题目: 蓝桥杯2020届试题（省赛）-成绩分析
-
题目描述
小蓝给学生们组织了一场考试，卷面总分为 100 分，每个学生的得分都是一个 0 到 100 的整数。
请计算这次考试的最高分、最低分和平均分。
输入描述
输入的第一行包含一个整数 n\ (1 ≤ n ≤ 10^4)n (1≤n≤104)，表示考试人数。
接下来 nn 行，每行包含一个 0 至 100 的整数，表示一个学生的得分。
输出描述
输出三行。
第一行包含一个整数，表示最高分。
第二行包含一个整数，表示最低分。
第三行包含一个实数，四舍五入保留正好两位小数，表示平均分。
输入输出样例
示例
输入
780925674889910输出
991071.29限制
最大运行时间：1s
最大运行内存: 256M
题目: 蓝桥杯2020届试题（省赛）-排序
题目描述
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
小蓝最近学习了一些排序算法，其中冒泡排序让他印象深刻。
在冒泡排序中，每次只能交换相邻的两个元素。
小蓝发现，如果对一个字符串中的字符排序，只允许交换相邻的两个字符， 则在所有可能的排序方案中，冒泡排序的总交换次数是最少的。
例如，对于字符串 lanlan 排序，只需要 1 次交换。对于字符串 qiaoqiao 排序，总共需要 4次交换。
小蓝找到了很多字符串试图排序，他恰巧碰到一个字符串，需要 100100 次交 换，可是他忘了吧这个字符串记下来，现在找不到了。
请帮助小蓝找一个只包含小写英文字母且没有字母重复出现的字符串，对 该串的字符排序，正好需要 100100 次交换。如果可能找到多个，请告诉小蓝最短的那个。如果最短的仍然有多个，请告诉小蓝字典序最小的那个。
运行限制
最大运行时间：1s
思路（这道题就是考你数字对应的ASCL码，最后输出的时候一定是O排前这个时候你要想明白他是从5开始排，这道题就没问题！！
1. #include<stdio.h>
2. #include<math.h>
3. #include <stdlib.h>
4. int main(){
5. int i,m,sum,num=0;
6. int n=0;
7. int t,a,b;
8. while((n*n-n)/2<100){
9. n+=1;
10. }
11. m=(n*n-n)/2-100;
12. int app[n];
13. for(i=0;i<n;i++){
14. app[i]=97+n-i-1;
15. }
16. for(i=5;i>0;i--){
17. if(app[i]<app[i-1]){
18. t=app[i];
19. app[i]=app[i-1];
20. app[i-1]=t;
21. }
22. }
23.
24. for(i=0;i<n;i++){
25. printf("%c",app[i]);
26. }
27. return 0;
28. }
题目: 蓝桥杯2021届填空试题（省赛）- 相乘
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。 小蓝发现，他将 1 至 1000000007 之间的不同的数与 2021 相乘后再求除以 1000000007的余数，会得到不同的数。 小蓝想知道，能不能在 1 至 1000000007 之间找到一个数，与 20212021 相乘后 再除以 1000000007 后的余数为 99999999。如果存在，请在答案中提交这个数； 如果不存在，请在答案中提交 0。
运行限制
最大运行时间：1s
最大运行内存: 128M
思路（一个暴力的破解打法，这道题如果
1. #include <stdio.h>
2. #include <stdlib.h>
3. int main()
4. {
5. long long int sum=0,i,j,num;
6. for(i=1;i<=999;i++){
7. sum=((1000000007*i)+999999999);
8. if(sum%2021==0){
9. printf("%d",sum/2021) ;
10. return 0;
11. }
12. }
13. return 0;
14. }
题目: 蓝桥杯2021届填空试题（省赛）- 路径
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
小蓝学习了最短路径之后特别高兴，他定义了一个特别的图，希望找到图 中的最短路径。
小蓝的图由 2021 个结点组成，依次编号 1 至 2021。
对于两个不同的结点 a, b，如果 a 和 b 的差的绝对值大于 21，则两个结点 之间没有边相连；如果 a 和 b 的差的绝对值小于等于 21，则两个点之间有一条 长度为 a 和 b 的最小公倍数的无向边相连。
例如：结点 1 和结点 23 之间没有边相连；结点 3 和结点 24 之间有一条无 向边，长度为 24；结点 15 和结点 25 之间有一条无向边，长度为 75。
请计算，结点 1 和结点 2021 之间的最短路径长度是多少。
提示：建议使用计算机编程解决问题。
运行限制
最大运行时间：1s
最大运行内存: 128M
这道题的思路有点难，先考参考参考CSDN的优质代码吧!
1. #include <stdio.h>//求1到达2021的最短路径
2. #include <stdlib.h>
3. int gcd(int a,int b)//最大公约数 辗转相除法
4. {if(a%b==0) return b;
5. else return gcd(b,a%b);}
6. int gbs(int a,int b)//最小公倍数=a*b/最大公约数
7. {return a*b/gcd(a,b);}
8. int min(int a,int b)
9. {return a<b?a:b;}
10. int main(int argc, char *argv[])
11. {int i=1,j,f[2022]={0};//f[n]表示1到n的最短路径长
12. /*先求1能直接到达的点（2..22）更新f数组内的数据，
13. 把已经求出最短路径的点归到一类(i)，再求这类点能直接到达的点(j)最短路径，
14. 多个不同点能到达同一个点，可以通过循环求出f[n]的最佳结果*/
15. for(i=1;i<=2021;i++)
16. { for(j=i+1;j<=i+21&&j<=2021;j++)
17. { if(f[j]==0) f[j]=f[i]+gbs(i,j);
18. else f[j]=min(f[j],f[i]+gbs(i,j));}}
19. //比较最短路径是比较1到点j的路径长,而不是i到j的路径长！！
20. printf("%d",f[2021]);
21. return 0;
22. }
题目: 蓝桥杯2021届填空试题（省赛）-货物摆放
题目描述
小蓝有一个超大的仓库，可以摆放很多货物。
现在，小蓝有 nn 箱货物要摆放在仓库，每箱货物都是规则的正方体。小蓝规定了长、宽、高三个互相垂直的方向，每箱货物的边都必须严格平行于长、宽、高。
小蓝希望所有的货物最终摆成一个大的长方体。即在长、宽、高的方向上分别堆 LL、WW、HH 的货物,满足 n = L \times W \times Hn=L×W×H。
给定 nn，请问有多少种堆放货物的方案满足要求。
例如，当 n = 4n=4 时，有以下 66 种方案：1×1×4、1×2×2、1×4×1、2×1×2、2 × 2 × 1、4 × 1 × 1，1×1×4、1×2×2、1×4×1、2×1×2、2×2×1、4×1×1。
请问，当 n = 2021041820210418（注意有 1616 位数字）时，总共有多少种方案？
提示：建议使用计算机编程解决问题。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
运行限制
最大运行时间：1s
最大运行内存: 256M
思路(注意使用的是long long输出，每次取余后都需要考虑下一下个条件的符合，这道题有点耗时间！！
1. #include<stdio.h>
2. int main()
3. {
4. long long n=2021041820210418;
5. long long k,s,sum=0,i,j;
6. for(i=1;i*i*i<=n;i++){
7. if(n%i==0){
8. s=n/i;
9. for(j=i;i*j*j<=n;j++){
10. if(s%j==0){
11. k=n/i/j;
12. if(i==j&&i==k)
13. sum++;
14. else if(i==j&&i!=k)
15. sum+=3;
16. else sum+=6;
17. }
18. }
19. }
20. }
21. printf("%d",sum);
22. return 0;
23. }
好了，历程就到这里了！！！！无论结果怎么样，尽力就好！！
更多推荐
初学者备战蓝桥杯历程（大学编程学习历程记录,题目思路献给需要备考蓝桥杯的同学）
发布评论