第八届蓝桥杯C/C++组程序设计大学生b组省赛

本文作者原创，转载请注明原创地址https://blog.csdn.net/coder_gxd/article/details/79685225

第一题 购物单

小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。
这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。
小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。
现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。
取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。
你的任务是计算出，小明最少需要取多少现金。
以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。
-----------------
****     180.90       88折
****      10.25       65折
****      56.14        9折
****     104.65        9折
****     100.30       88折
****     297.15        半价
****      26.75       65折
****     130.62        半价
****     240.28       58折
****     270.62        8折
****     115.87       88折
****     247.34       95折
****      73.21        9折
****     101.00        半价
****      79.54        半价
****     278.44        7折
****     199.26        半价
****      12.97        9折
****     166.30       78折
****     125.50       58折
****      84.98        9折
****     113.35       68折
****     166.57        半价
****      42.56        9折
****      81.90       95折
****     131.78        8折
****     255.89       78折
****     109.17        9折
****     146.69       68折
****     139.33       65折
****     141.16       78折
****     154.74        8折
****      59.42        8折
****      85.44       68折
****     293.70       88折
****     261.79       65折
****      11.30       88折
****     268.27       58折
****     128.29       88折
****     251.03        8折
****     208.39       75折
****     128.88       75折
****      62.06        9折
****     225.87       75折
****      12.89       75折
****      34.28       75折
****      62.16       58折
****     129.12        半价
****     218.37        半价
****     289.69        8折
--------------------
需要说明的是，88折指的是按标价的88%计算，而8折是按80%计算，余者类推。
特别地，半价是按50%计算。
请提交小明要从取款机上提取的金额，单位是元。
答案是一个整数，类似4300的样子，结尾必然是00，不要填写任何多余的内容。

特别提醒：不许携带计算器入场，也不能打开手机。

分析：该题没什么算法，送分题，建议使用EXCEL操作更快，不建议一点点敲程序，浪费时间、容易出错。

答案：5200元。

第二题：等差素数列

2,3,5,7,11,13,....是素数序列。
类似：7,37,67,97,127,157 这样完全由素数组成的等差数列，叫等差素数数列。
上边的数列公差为30，长度为6。
2004年，格林与华人陶哲轩合作证明了：存在任意长度的素数等差数列。这是数论领域一项惊人的成果！
有这一理论为基础，请你借助手中的计算机，满怀信心地搜索：长度为10的等差素数列，其公差最小值是多少？
注意：需要提交的是一个整数，不要填写任何多余的内容和说明文字。

分析：首先要掌握素数表的获取，我采用“Eratosthenes”筛法（埃氏筛法），时间复杂度为O(n log logn)。获得素数表后，采用暴力求解，公差1，2，3......遍历得到最小公差。

小技巧：1.等差素数数列的公差只能是偶数（为奇数时，数列中会出现若干偶数，不满足素数条件）。2.暴力时，数组不易开太大（<=10^5）,否则易报错，若所找数列太大，可分段寻找。

答案：210

#include <stdio.h>
#define N 100000
#define dmax 1000
int main(){
	//获取素数表 
	int sushu[N]={0},count = 0 ;
	int panduan[N]={0};
	for(int i=2;i<N;i++){
		if(panduan[i]==0){
			sushu[count++]=i;
			for(int j=i+i;j<N;j=j+i){
				panduan[j]=1;
			}
		}
	}
	//暴力求解最小公差 
	int d,a1;//d为公差，a1为首项 
	for(d=2;d<dmax;d=d+2){//公差不可能为奇数，仅遍历偶数即可。
		for(int i=0;i<1000;i++){
			a1=sushu[i];
			int temp=1;
			for(int j=2;j<=10;j++){
				int aj=a1+(j-1)*d;
				if(panduan[aj]==0)	temp++;
			}
			if(temp==10){
				printf("%d",d);
				return 0;
			}	
		}
	}
}

第三题：

金属材料被严格地堆放成金字塔形。
                             7 
                            5 8 
                           7 8 8 
                          9 2 7 2 
                         8 1 4 9 1 
                        8 1 8 8 4 1 
                       7 9 6 1 4 5 4 
                      5 6 5 5 6 9 5 6 
                     5 5 4 7 9 3 5 5 1 
                    7 5 7 9 7 4 7 3 3 1 
                   4 6 4 5 5 8 8 3 2 4 3 
                  1 1 3 3 1 6 6 5 5 4 4 2 
                 9 9 9 2 1 9 1 9 2 9 5 7 9 
                4 3 3 7 7 9 3 6 1 3 8 8 3 7 
               3 6 8 1 5 3 9 5 8 3 8 1 8 3 3 
              8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9 
             8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4 
            2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9 
           7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6 
          9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3 
         5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9 
        6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4 
       2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4 
      7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6 
     1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3 
    2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8 
   7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9 
  7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6 
 5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1 
X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X 
其中的数字代表金属块的重量（计量单位较大）。最下一层的X代表30台极高精度的电子秤。假设每块原料的重量都十分精确地平均落在下方的两个金属块上，最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。电子秤的计量单位很小，所以显示的数字很大。工作人员发现，其中读数最小的电子秤的示数为：2086458231请你推算出：读数最大的电子秤的示数为多少？
注意：需要提交的是一个整数，不要填写任何多余的内容。

分析：本题算法并不复杂，创建一个二维数组a[30][30]放原始数据，第i行数据放在第i行0-i位置，其余位置置0。创建一个二维数组b[30][30]（初始化化为0）计算重量，b[i][j]代表（i,j）位置承受的重量（不包括位置本身的重量）。

小技巧：在输入数据时，不必一个一个输入，耗时易错。可用ctrl+c（复制），ctrl+v（粘贴）。

当i=0,j=0时，b[0][0]=0;(b[i][j]不包括位置本身的重量,承重为0；)
当i！=0，j=0时，b[i][0]=a[i-1][0]*1.0/2.0+b[i-1][0]*1.0/2.0;
当i！=0，j！=0时， b[i][j]=a[i-1][j-1]*1.0/2.0+a[i-1][j]*1.0/2.0+b[i-1][j-1]*1.0/2.0+b[i-1][j]*1.0/2.0;

最后，找出最小承重的电子秤，其实际承重量/示数=转化率。承重最大的电子秤示数=实际承重量*转换率；

答案：72665192664

#include<stdio.h>
const long long min_shishu=2086458231;
int main ( ){
	int a[30][30]={0};
	double b[30][30]={0};
	for (int i=0;i<29;i++){//输入原始数据给 a[][] 
		for(int j=0;j<=i;j++){
			scanf("%d",&a[i][j]);
		}
	}
	for (int i=1;i<30;i++){//计算 b[][]各个位置承重 
		b[i][0]=a[i-1][0]*1.0/2.0+b[i-1][0]*1.0/2.0;
		for(int j=1;j<30;j++){
			double temp1=a[i-1][j-1]*1.0/2.0+a[i-1][j]*1.0/2.0;
			double temp2=b[i-1][j-1]*1.0/2.0+b[i-1][j]*1.0/2.0;
			b[i][j]=temp1+temp2;
		}
	}
	double min=b[29][0],max=b[29][0];
	for(int j=1;j<30;j++){//找出最大最小值 
		if(b[29][j]>max)	max=b[29][j];
		if(b[29][j]<min)	min=b[29][j];
	}
	double max_shishu=min_shishu/min*max;//转换单位 
	printf("%f",max_shishu);
	return 0;
} 

第四题 略

第五题：取数位

求1个整数的第k位数字有很多种方法。
以下的方法就是一种。
// 求x用10进制表示时的数位长度 
int len(int x){
if(x<10) return 1;
return len(x/10)+1;
}
// 取x的第k位数字
int f(int x, int k){
if(len(x)-k==0) return x%10;
return _____________________;  //填空
}
int main()
{
int x = 23574;
printf("%d\n", f(x,3));
return 0;
}
对于题目中的测试数据，应该打印5。
请仔细分析源码，并补充划线部分所缺少的代码。

注意：只提交缺失的代码，不要填写任何已有内容或说明性的文字。

分析：本题递归算法，
递归边界：if(len(x)-k==0) return x%10;

递归式：f(x,k)=f(x/10,k);

答案：f(x/10,k)

#include <stdio.h> 
// 求x用10进制表示时的数位长度 
int len(int x){
	if(x<10) return 1;
	return len(x/10)+1;
}
	
// 取x的第k位数字
int f(int x, int k){
	if(len(x)-k==0) return x%10;
	return f(x/10,k);  //填空
}
	
int main()
{
	int x = 23574;
	printf("%d\n", f(x,3));
	return 0;
}

第六题：最大公共子串

最大公共子串长度问题就是：求两个串的所有子串中能够匹配上的最大长度是多少。
比如："abcdkkk" 和 "baabcdadabc"，可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路，并补全划线部分缺失的代码。
#include <stdio.h>
#include <string.h>
#define N 256
int f(const char* s1, const char* s2)
{
int a[N][N];
int len1 = strlen(s1);
int len2 = strlen(s2);
int i,j;
memset(a,0,sizeof(int)*N*N);
int max = 0;
for(i=1; i<=len1; i++){
for(j=1; j<=len2; j++){
if(s1[i-1]==s2[j-1]) {
a[i][j] = __________________________;  //填空
if(a[i][j] > max) max = a[i][j];
}
}
}

return max;
}
int main()
{
printf("%d\n", f("abcdkkk", "baabcdadabc"));
return 0;
}
注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。

分析：最大公共子串问题，老生常谈，采用动态规划算法，a[i][j]d的意义是s1[i-1]==s2[j-1]时，以s1[i-1]和s2[j-1]为尾端的公共子串的长度。

答案：a[i-1][j-1]+1

#include <stdio.h>
#include <string.h>

#define N 256
int f(const char* s1, const char* s2)
{
	int a[N][N];
	int len1 = strlen(s1);
	int len2 = strlen(s2);
	int i,j;
	
	memset(a,0,sizeof(int)*N*N);
	int max = 0;
	for(i=1; i<=len1; i++){
		for(j=1; j<=len2; j++){
			if(s1[i-1]==s2[j-1]) {
				a[i][j] = a[i-1][j-1]+1;  //填空
				if(a[i][j] > max) max = a[i][j];
			}
		}
	}
	
	return max;
}

int main()
{
	printf("%d\n", f("abcdkkk", "baabcdadabc"));
	return 0;
}

第七题：日期问题

小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。  比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？
输入
----
一个日期，格式是"AA/BB/CC"。  (0 <= A, B, C <= 9)  
输入
----
输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列。  
样例输入
----
02/03/04  
样例输出
----
2002-03-04  
2004-02-03  
2004-03-02  

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。

分析：简单模拟，没什么算法。注意细节：1.区分大小月和闰年2月29日；2.月份要小于等于12；3.注意剔除重复日期4.排序可采用sort函数；

#include <stdio.h>
#include <algorithm>
using namespace std;
struct node{
	int year;
	int yue;
	int day;
}x[3];
bool cmp(node xx,node yy){
	if(xx.year!=yy.year)	return xx.year<yy.year;
	else if(xx.yue!=yy.yue)	return xx.yue<yy.yue;
	else	return xx.day<yy.day;
} 
int main (){
	int temp1,temp2,temp3;
	scanf("%d%*c%d%*c%d",&temp1,&temp2,&temp3);
	int count=0;//代表日期总数 
	int a,b,c;//分别代表年月日 
	/*年月日*/
	a=temp1,b=temp2,c=temp3;
	x[count].yue=b;
	x[count].day=c;
	if(a>=60)	x[count].year=a+1900;
	else	x[count].year=a+2000;
	 
	if((b==1||b==3||b==5||b==7||b==8||b==10||b==12)&&(c>=0&&c<=31)){count++;}
	else if((b==4||b==6||b==9||b==11)&&(c>=0&&c<=30)){count++;}
	else if(b==2){
		if(c>=0&&c<=28)	count++;
		else if(a%4==0&&a%100!=0)	count++;
		else if(a%100==0&&a%400==0)	count++;
	}			
	/*月日年,重复上面模板，将 a,b,c 的值更改即可 */
	a=temp3;b=temp1;c=temp2;
	x[count].yue=b;
	x[count].day=c;
	if(a>=60)	x[count].year=a+1900;
	else	x[count].year=a+2000;
	
	if((b==1||b==3||b==5||b==7||b==8||b==10||b==12)&&(c>=0&&c<=31)){count++;}
	else if((b==4||b==6||b==9||b==11)&&(c>=0&&c<=30)){count++;}
	else if(b==2){
		if(c>=0&&c<=28)	count++;
		else if(a%4==0&&a%100!=0)	count++;
		else if(a%100==0&&a%400==0)	count++;
	}
	/*日月年,重复上面模板，将 a,b,c 的值更改即可*/
	 a=temp3;b=temp2;c=temp1;
	x[count].yue=b;
	x[count].day=c;
	if(a>=60)	x[count].year=a+1900;
	else	x[count].year=a+2000;
	
	if((b==1||b==3||b==5||b==7||b==8||b==10||b==12)&&(c>=0&&c<=31)){count++;}
	else if((b==4||b==6||b==9||b==11)&&(c>=0&&c<=30)){count++;}
	else if(b==2){
		if(c>=0&&c<=28)	count++;
		else if(a%4==0&&a%100!=0)	count++;
		else if(a%100==0&&a%400==0)	count++;
	}
	
	/*去除相同*/
	if(temp1==temp2&&temp1==temp3)	count=count-2;
	if(temp1==temp2&&temp1!=temp3)	count=count-1;
	sort(x,x+count,cmp);//排序 
	for(int i=0;i<count;i++){//按格式打印 
		printf("%04d-%02d-%02d\n",x[i].year,x[i].yue,x[i].day);
	}
	return 0;
} 

第八题：包子凑数

小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼，其中第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼，可以认为是无限笼。每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有X个包子。比如一共有3种蒸笼，分别能放3、4和5个包子。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个的再加2笼4个的）。当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能放4、5和6个包子。而顾客想买7个包子时，大叔就凑不出来了。小明想知道一共有多少种数目是包子大叔凑不出来的。
输入
----
第一行包含一个整数N。(1 <= N <= 100)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100)  
输出
----
一个整数代表答案。如果凑不出的数目有无限多个，输出INF。

例如，
输入：
2  
4  
5   
程序应该输出：
6  
再例如，
输入：
2  
4  
6    
程序应该输出：
INF
样例解释：
对于样例1，凑不出的数目包括：1, 2, 3, 6, 7, 11。  
对于样例2，所有奇数都凑不出来，所以有无限多个。  
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms

分析：根据 扩展欧几里得定理算法，当所有包子数目的最大公约数为1时，则有无数种情况无法覆盖，最大公约数不唯一时，则有有限种情况不能被覆盖。本题先求出所有种类包子的最大公约数，若不为1，则用 背包算法遍历；若为1，则输出INF。

#include <stdio.h>
const int maxn=10010;
int gcd(int x,int y){//求最大公约数
	if(y==0)	return x;
	return gcd(y,x%y);
}
int main(){
	int N;
	scanf("%d",&N);
	int a[N];
	for(int i=0;i<N;i++)	scanf("%d",&a[i]);
	int yueshu=a[0];
	for(int i=1;i<N;i++){
		yueshu=gcd(yueshu,a[i]);
	}
	
	if(yueshu!=1)	printf("INF");
	else{//背包法 
		bool b[maxn]={0};
		b[0]=true;
		for(int i=0;i<N;i++){
			for(int j=0;j+a[i]<maxn;j++){
				if(b[j]==true)	b[j+a[i]]=true;
			}
		}
		int count=0;
		for(int i=0;i<maxn;i++){
			if(b[i]==false)	count++;
		}
		printf("%d",count);
	}
	return 0; 
}