2017年第八届蓝桥杯C/C++ B组省赛历年真题及解析

1. 默认阅读的你具备c/c++基本语法，作者对每一题点明需要掌握的算法策略或思想，并进行简单注释解释；
2. 该博客的正确食用方式：简单了解点明的算法思想和策略，再自行思索之后自己写代码，提交不过再看看别人的代码怎么实现，是否漏掉边界，特殊情况，或者错误理解算法策略、思想；
3. 模拟即带细节暴力。

01 小明买东西【模拟】

标题： 购物单

小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。

这不，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，不要填写任何多余的内容。

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

解析：

很简单的签到题，就是数据处理会比较麻烦。

#include 
using namespace std;
double price[50] = {180.90,10.25,56.14,104.65,
100.30,297.15,26.75,130.62,240.28,270.62,115.87,
247.34,73.21,101.00,79.54,278.44,199.26,12.97,
166.30,125.50,84.98,113.35,166.57,42.56,81.90,131.78,
255.89,109.17,146.69,139.33,141.16,154.74,59.42,
85.44,293.70,261.79,11.30,268.27,128.29,251.03,
208.39,128.88,62.06,225.87,12.89,34.28,62.16,129.12,
218.37,289.69};

double discount[50] = {88,65,90,90,88,50,65,50,58,
80,88,95,90,50,50,70,50,90,78,58,90,68,50,
90,95,80,78,90,68,65,78,80,80,68,88,65,88,58,88,80,
75,75,90,75,75,75,58,50,50,80};

int main(){
	double ans = 0.0;
	double tmp = 0.0;
	for(int i = 0;i < 50;i++){
		ans += price[i]*discount[i]*0.01;//打折后的价格，因为打折都被我处理成两位数了需要*0.01 
		tmp += price[i];//未打折的价格，看一下心理有底 
	}
//	cout << tmp << endl;
	cout << ans << endl;
	//5136.86
	//所以答案是5200 
}

02 等差素数列【素数筛、等差数列】

标题：等差素数列

2,3,5,7,11,13,…是素数序列。 类似：7,37,67,97,127,157 这样完全由素数组成的等差数列，叫等差素数数列。
上边的数列公差为30，长度为6。

2004年，格林与华人陶哲轩合作证明了：存在任意长度的素数等差数列。 这是数论领域一项惊人的成果！

有这一理论为基础，请你借助手中的计算机，满怀信心地搜索：

长度为10的等差素数列，其公差最小值是多少？

注意：需要提交的是一个整数，不要填写任何多余的内容和说明文字。

解析：

首先先用素数筛筛出10e6以内的素数。

素数筛的知识可以自行谷歌一下，很多博客都说得很好

void init(){
	ic[0] = ic[1] = 1;//个人习惯，默认0，1是合数，这里有无都不受影响
	for(int i = 2;i < N;i++){
		if(!ic[i]){
			prime[++prime[0]] = i;//记录素数
			for(int j = i<<1;j < N;j += i) ic[j] = 1;
		}
	}
}

然后就是写一个判断函数，符合条件返回公差，不符合返回-1

int search(int star,int step){
	bool flag = true;
	int end = star+step*9;//数列末项 
	if(end > N) return -1;//这里是防止越界，越界ans永远为2 
	for(int i = star;i <= end;i+=step){
		flag = flag&&(!ic[i]);//标记，当此数列中有一个为合数，会立刻退出 
		if(!flag) return -1;
	}
	if(flag) return step;//都是素数，返回步长	
}

最后暴力枚举

void solve(){
	init();
	int ans,pri;
	for(int i = 2;i <= 400;i++){//枚举公差 
		for(int j = 1;j <= prime[0];j++){//枚举首项 
			ans = search(prime[j],i);
			if(ans!=-1){
				pri = prime[j];break;
			}
		}
		if(ans!=-1) break;
	}
	cout << ans << endl;
	//210 
	//	cout << pri << endl;
	//看首项是什么，心里有底 
 
}

完整代码：

#include 
#include 
using namespace std;
const int N = 1e7+5;
bool ic[N];
int prime[N];

void init(){
	ic[0] = ic[1] = 1;
	for(int i = 2;i < N;i++){
		if(!ic[i]){
			prime[++prime[0]] = i;
			for(int j = i<<1;j < N;j += i) ic[j] = 1;
		}
	}
}
//stat是数列首项，step是公差 
int search(int star,int step){
	bool flag = true;
	int end = star+step*9;//数列末项 
	if(end > N) return -1;//这里是防止越界，越界ans永远为2 
	for(int i = star;i <= end;i+=step){
		flag = flag&&(!ic[i]);//标记，当此数列中有一个为合数，会立刻退出 
		if(!flag) return -1;
	}
	if(flag) return step;//都是素数，返回步长	
}

void solve(){
	init();
	int ans,pri;
	for(int i = 2;i <= 400;i++){//枚举公差 
		for(int j = 1;j <= prime[0];j++){//枚举首项 
			ans = search(prime[j],i);
			if(ans!=-1){
				pri = prime[j];break;
			}
		}
		if(ans!=-1) break;
	}
	cout << ans << endl;
	//210 
	//	cout << pri << endl;
	//看首项是什么，心里有底 
 
}
int main(){
	solve();
	return 0;
}

03 承压计算【排序、sort()】

标题：承压计算

X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。

每块金属原料的外形、尺寸完全一致，但重量不同。 金属材料被严格地堆放成金字塔形。

其中的数字代表金属块的重量（计量单位较大）。 最下一层的X代表30台极高精度的电子秤。

假设每块原料的重量都十分精确地平均落在下方的两个金属块上， 最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。

工作人员发现，其中读数最小的电子秤的示数为：2086458231

请你推算出：读数最大的电子秤的示数为多少？

注意：需要提交的是一个整数，不要填写任何多余的内容。

解析：

实力拒绝这种处理一大堆数字的 = L =
推荐各种顺便学一下c/c++的文件处理，和别人拼罚时
画图发现，每一层的第一块和最后一块都是只承担了上面一层的第一块和最后一块的重量，其他的都承受了上面一层两块的重量

#include 
#include 
using namespace std;
double a[30][30];
const double MIN = 2086458231;

void solve(){
	for(int i = 0;i < 29;i++){
		for(int j = 0;j < i+1;j++){
			cin >> a[i][j];
		}
	}	
	for(int i = 1;i < 30;i++){
		for(int j = 0;j < i+1;j++){
			if(j==0){//第一块
				a[i][j] += a[i-1][0]/2.0;
			}
			else if(j == i){//最后一块
				a[i][j] += a[i-1][j-1]/2.0; 
			}
			else{//其他块
				a[i][j] += a[i-1][j]/2.0;
				a[i][j] += a[i-1][j-1]/2.0;
			}	
		}
	}
	sort(a[29],a[29]+30);	
	printf("%.0lf\n",MIN*a[29][29]/a[29][0]);
	//72665192664	
}

int main(){
	solve();
	return 0;
}

04

05 取数位【推理】

标题：取数位

求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。

请仔细分析源码，并补充划线部分所缺少的代码。

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

解析：

直接按他取数位长度的代码类比推理一下就得出答案了。

return f(x/10,k);  //填空

06 最大公共子串【动态规划之最长公共子序列】

标题：最大公共子串

最大公共子串长度问题就是： 求两个串的所有子串中能够匹配上的最大长度是多少。

比如：“abcdkkk” 和 “baabcdadabc”， 可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。

下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。

请分析该解法的思路，并补全划线部分缺失的代码。

#include
#include

#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)NN); 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] = a[i-1][j-1]+1;  //填空

07 日期问题【运算符重载（可不掌握），结构体（可不掌握），unique()函数、sort()函数】

标题：日期问题

小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在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 不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

解析：

完完全全的细节问题，我会在代码备注出需要注意的细节；
提交了n多遍，一直不注意一些细节，注意不是简单的a,b,c三个数字全排列，因为b这个数字只会是月份或日号

#include 
#include 
using namespace std;
const int year1 = 1900;
const int year2 = 2000;
int mo[13] = {0,31,29,31,30,31,30,31,31,30,31,30,31};
struct node{
	int year,month,day;
	bool operator == (const node& d)
      {
      	if(year==d.year && month==d.month && day==d.day) return true;
      	else return false;
      }
} data[10];
int cnt,a,b,c;
string str;

bool cmp(node n1,node n2){
	if(n1.year == n2.year){
		if(n1.month == n2.month){
			return n1.day < n2.day;
		}
		else return n1.month < n2.month;
	}
	else return n1.year < n2.year;
}

void judgeSave(int y,int m,int d){//判断并保存 
	if(y < 1960 || y > 2059) return;//年份
	
	if(m < 1 || m > 12) return;//月份
	 
	//平年 2月不超过29 
	if(y%4!=0 || (y%4==0&&y%100==0&&y%400!=0)){
		if(m==2 && d >= 29) return;    
	} 
	//对应月份的天数不对 
	if(d > mo[m] ||d < 1) return;
	
	//save
	data[cnt].year = y,data[cnt].month = m,data[cnt++].day = d;	
}

void solve(){
	cin >> str;
	for(int i = 0;i < 2;i++) a = a*10+str[i]-'0';
	for(int i = 3;i < 5;i++) b = b*10+str[i]-'0';
	for(int i = 6;i < 8;i++) c = c*10+str[i]-'0'; 
	judgeSave(a+year1,b,c);
	judgeSave(c+year1,b,a);
	judgeSave(c+year1,a,b);
	judgeSave(a+year2,b,c);
	judgeSave(c+year2,b,a);
	judgeSave(c+year2,a,b);
	
	sort(data,data+cnt,cmp);//排序
	int fcnt = unique(data,data+cnt)-data;//去重
//	cout << fcnt << endl;
	for(int i = 0;i < fcnt;i++){
		printf("%d-%02d-%02d\n",data[i].year,data[i].month,data[i].day);
	}
}

int main(){
	solve();
	return 0;
}
 

08 包子凑数【欧几里得变形】【递推】

标题：包子凑数

小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有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

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

注意： main函数需要返回0; 只使用ANSI C/ANSI C++ 标准; 不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include 不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

解析：

欧几里得变形，如果所有a[i]的最大公约数不为1，那么一定有无数个数凑不出来
如果为1，则用递推的方法推出在1e4范围内可以凑出来的数
https://www.cnblogs.com/w-like-code/p/13028180.html
这篇博客讲得很清楚

我一开始的想法是，将ai排序后，相邻两个数只要差是1就可以凑数，至于凑不出多少数就用递推推出来，当然是不对的，提交也只错了一个样例，可见蓝桥杯数据的水分，所以参加蓝桥杯的小伙伴要有信心，果断就会白给。

#include 
#include 
#include 
using namespace std;
const int N = 1e4+5;
int a[110],n;
int gcd = 0;
bool dp[N];
//dp[i]表示i这个数可以凑出来 

void solve(){
	cin >> n;
	for(int i = 0;i < n;i++){
		cin >> a[i];
	}
	gcd = a[0];
	for(int i = 1;i < n;i++){
		gcd = __gcd(a[i],gcd);
	}
	if(gcd != 1) cout << "INF" << endl;
	else{
		dp[0] = 1;
		for(int i = 0;i < n;i++){
			for(int j = 0;j+a[i] < N;j++){
				if(dp[j]) //如果dp[j]可以凑出来，那么加上a[i]这笼包子，j+a[i]也可以凑出来 
					dp[j+a[i]] = true;
			}
		}
		int cnt = 0;
		for(int i = 0;i < N;i++){
			if(!dp[i]) cnt++;
		}
		cout << cnt << endl;
	}
}

int main(){
	solve();
	return 0;
}

09 分巧克力【二分】

标题： 分巧克力

儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。

为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：

1. 形状是正方形，边长是整数  
2. 大小相同  

例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。

当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？

输入 第一行包含两个整数N和K。(1 <= N, K <= 100000) 以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi
<= 100000) 输入保证每位小朋友至少能获得一块1x1的巧克力。

输出 输出切出的正方形巧克力最大可能的边长。

样例输入： 2 10 6 5 5 6

样例输出： 2

资源约定： 峰值内存消耗（含虚拟机） < 256M CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

注意： main函数需要返回0; 只使用ANSI C/ANSI C++ 标准; 不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include 不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

解析：

二分法，分出来的巧克力越大，能分出来的巧克力块数越小，具有单调性，使用二分法；
推荐二分r = 1e9+7，一个很大的数，多大随便，卡边界太容易出错了

#include 
#include 
#include 
using namespace std;
const int N = 1e5+5;
int n,k,ans = 0;
int h[N],w[N];

bool judge(int x){
	double len = x*1.0;
	int tmp = 0;
	for(int i = 0;i < n;i++){
		tmp += floor(h[i]/len)*floor(w[i]/len);
	}
	return (tmp>=k);
}

void solve(){
	scanf("%d%d",&n,&k);
	for(int i = 0;i < n;i++) scanf("%d%d",&h[i],&w[i]);
	int l = 1,r = 1e9+7;
	while(l <= r){
		int mid = l+r>>1;
		if(judge(mid)){
			ans = max(ans,mid);
			l = mid+1;
		}else{
			r = mid - 1;
		}	
	}
	cout << ans << endl;
}

int main(){
	solve();
	return 0;
}

10 k倍区间【前缀和、取余】

标题： k倍区间

给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i <=
j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。

你能求出数列中总共有多少个K倍区间吗？

输入
----- 第一行包含两个整数N和K。(1 <= N, K <= 100000) 以下N行每行包含一个整数Ai。(1 <= Ai <= 100000)

输出
----- 输出一个整数，代表K倍区间的数目。

例如， 输入： 5 2 1 2 3 4 5

程序应该输出： 6

资源约定： 峰值内存消耗（含虚拟机） < 256M CPU消耗 < 2000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

注意： main函数需要返回0; 只使用ANSI C/ANSI C++ 标准; 不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include 不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

算是最难的题。
首先，最暴力的想法就是三重循环：

1. 第一层，枚举区间长度 l ，从1~n；
2. 第二层，枚举开始的位置 i ，从1~n；
3. 第三层，累加[i,i+l-1]区间和，判断%k==0；

现在我们来化掉第三层循环，使用前缀和；

有关前缀和的思想自行谷歌

那么区间[i,i+l-1] 的结果就变成了sum[i+l-1]-sum[i-1],第三层循环没啦！

现在回归到问题，问题问的是，区间[i,i+l-1] 的和 res%k==0，即变成了 (sum[i+l-1]-sum[i-1]) % k == 0; == 注意 == ，为了方便，以下用区间[ l, r ]代替区间[i,i+l-1] 。

（sum[r]-sum[l-1]）%k = = 0，又可以化成 ,sum[r]%k = = sum[l-1]%k

我对这里简单解释一下：

1. （sum[r]-sum[l-1]）%k = = 0，则 要么 sum[r] = =sum[l-1]，要么 sum[r] - sum[l-1] = k的整数倍
2. 如果 sum[r] = =sum[l-1]，那么 sum[r]%k = = sum[l-1]%k = = 同一个数
3. 如果 sum[r] - sum[l-1] = k的整数倍，那么 显而易见。

所以问题就转换成了，对于每一个sum[ r ]，有多少个 sum[ l - 1 ] 和他的余数相同。
幸运的是，处理到sum [ r ] 的时候，我们已经通过一种巧妙的方法，记录下前面的sum[ index ]的余数为 几 的个数和了。
这就可以用O(n)的方法做出来了。

#include 
#include 
using namespace std;
typedef long long ll;
const int N = 1e5+5;
ll n,k;
ll a[N],sum[N],cnt[N];

void solve(){
	scanf("%lld%lld",&n,&k);
	for(int i = 1;i <= n;i++) {
		scanf("%lld",&a[i]);
		sum[i] = sum[i-1]+a[i];
	}
	ll res = 0;
	cnt[0] = 1; //余数为0初始化为1，不然第一个k倍区间的res会等于0 
	for(int i = 1;i <= n;i++){
		res += cnt[sum[i]%k];
		cnt[sum[i]%k] ++;
	}
	cout << res << endl;
}

int main(){
	solve();
	return 0;
}