2016年第七届蓝桥杯c c++B组

此为博主为记录刷题过程的代码，修正并且都是正确答案，如果你需要具体解析，请在下方留言，我将会在赛后修改回答你的问题！

煤球数目

题目描述

有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
…
如果一共有100层，共有多少个煤球？

请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
答案： 171700

代码

#include
#include
using namespace std;

#define _for_(i, a, b) for (int i = (a); i <= (b); ++i)

int main() {
     
	int ans = 1, cur = 1;
	_for_(i, 2, 100) {
     
		cur = 1;
		_for_(j, 2, i) cur += j;
		ans += cur;
	}
	cout << ans << endl;
	return 0;
}

生日蜡烛

题目描述

某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。

现在算起来，他一共吹熄了236根蜡烛。

请问，他从多少岁开始过生日party的？

请填写他开始过生日party的年龄数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

答案：26

代码

#include
using namespace std;

int main() {
     
	for (int i = 1; i <= 100; ++i)
		for (int j = i + 1; j <= 100; ++j)
			if (j * (j + 1) - i * (i - 1) == 236 * 2) cout << i << endl;
	return 0;
}

凑算式

题目描述

这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。

比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。

这个算式一共有多少种解法？

注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。

答案：29

代码

#include
#include
using namespace std;

int main() {
     
	int num[] = {
      1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int ans = 0;
	do {
     
		int a = num[0], b = num[1], c = num[2];
		int d = num[3] * 100 + num[4] * 10 + num[5], e = num[6] * 100 + num[7] * 10 + num[8];
		if (a * c * e + b * e + d * c == 10 * e * c) ans++;
	} while (next_permutation(num, num + 9));
	cout << ans << endl;
	return 0;
}

快速排序

题目描述

排序在各种场合经常被用到。
快速排序是十分常用的高效率的算法。

其思想是：先选一个“标尺”，
用它把整个队列过一遍筛子，
以保证：其左边的元素都不大于它，其右边的元素都不小于它。

这样，排序问题就被分割为两个子区间。
再分别对子区间排序就可以了。

下面的代码是一种实现，请分析并填写划线部分缺少的代码。

#include 

void swap(int a[], int i, int j)
{
     
	int t = a[i];
	a[i] = a[j];
	a[j] = t;
}

int partition(int a[], int p, int r)
{
     
    int i = p;
    int j = r + 1;
    int x = a[p];
    while(1){
     
        while(i<r && a[++i]<x);
        while(a[--j]>x);
        if(i>=j) break;
        swap(a,i,j);
    }
	______________________;
    return j;
}

void quicksort(int a[], int p, int r)
{
     
    if(p<r){
     
        int q = partition(a,p,r);
        quicksort(a,p,q-1);
        quicksort(a,q+1,r);
    }
}
    
int main()
{
     
	int i;
	int a[] = {
     5,13,6,24,2,8,19,27,6,12,1,17};
	int N = 12;
	
	quicksort(a, 0, N-1);
	
	for(i=0; i<N; i++) printf("%d ", a[i]);
	printf("\n");
	
	return 0;
}

注意：只填写缺少的内容，不要书写任何题面已有代码或说明性文字。

答案

    swap(a, p, j);

抽签

题目描述

X星球要派出一个5人组成的观察团前往W星。
其中：
A国最多可以派出4人。
B国最多可以派出2人。
C国最多可以派出2人。
…

那么最终派往W星的观察团会有多少种国别的不同组合呢？

下面的程序解决了这个问题。
数组a[] 中既是每个国家可以派出的最多的名额。
程序执行结果为：
DEFFF
CEFFF
CDFFF
CDEFF
CCFFF
CCEFF
CCDFF
CCDEF
BEFFF
BDFFF
BDEFF
BCFFF
BCEFF
BCDFF
BCDEF
…
(以下省略，总共101行)

#include 
#define N 6
#define M 5
#define BUF 1024

void f(int a[], int k, int m, char b[])
{
     
	int i,j;
	
	if(k==N){
      
		b[M] = 0;
		if(m==0) printf("%s\n",b);
		return;
	}
	
	for(i=0; i<=a[k]; i++){
     
		for(j=0; j<i; j++) b[M-m+j] = k+'A';
		______________________;  //填空位置
	}
}
int main()
{
     	
	int  a[N] = {
     4,2,2,1,1,3};
	char b[BUF];
	f(a,0,M,b);
	return 0;
}

仔细阅读代码，填写划线部分缺少的内容。

注意：不要填写任何已有内容或说明性文字。

答案

f(a, k + 1, m - i, b);

方格填数

题目描述

如下的10个格子

填入0~9的数字。要求：连续的两个数字不能相邻。
（左右、上下、对角都算相邻）

一共有多少种可能的填数方案？

请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

答案： 1580

代码

#include
#include
#include
using namespace std;

int a[] = {
      0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

inline bool judge(int x, int y) {
     
	return abs(a[y] - a[x]) != 1;
}

int main() {
     
	int ans = 0;
	do {
     
		if (judge(0, 1) && judge(0, 3) && judge(0, 4) && judge(0, 5) && judge(1, 2) && judge(1, 4) && judge(1, 5) && judge(1, 6) && judge(2, 5) && judge(2, 6) && judge(3, 4) && judge(3, 7) && judge(3, 8) && judge(4, 5) && judge(4, 7) && judge(4, 8) && judge(4, 9) && judge(5, 6) && judge(5, 8) && judge(5, 9) && judge(6, 9) && judge(7, 8) && judge(8, 9))
			ans++;
	} while (next_permutation(a, a + 10));
	cout << ans << endl;
	return 0;
}

剪邮票

题目描述

有12张连在一起的12生肖的邮票。
现在你要从中剪下5张来，要求必须是连着的。
（仅仅连接一个角不算相连）
比如，

中，粉红色所示部分就是合格的剪取。

请你计算，一共有多少种不同的剪取方法。

请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
答案：116

代码

#include
#include
using namespace std;

#define _for(i, a, b) for(int i = (a); i < (b); ++i)

int a[] = {
      0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1 };
int g[3][4], dx[] = {
      1, 0, 0, -1 }, dy[] = {
     0, -1, 1, 0};

inline bool inside(int x, int y) {
     
	return x >= 0 && x < 3 && y >= 0 && y < 4;
}

void dfs(int x, int y) {
     
	g[x][y] = 0;
	_for(i, 0, 4) {
     
		int p = x + dx[i], q = y + dy[i];
		if (inside(p, q) && g[p][q]) dfs(p, q);
	}
}

int main() {
     
	int ans = 0;
	do {
     
		_for(i, 0, 3)  _for(j, 0, 4)
				if (a[i * 4 + j]) g[i][j] = 1;
		 
		int cnt = 0;
		_for(i, 0, 3)  _for(j, 0, 4) if (g[i][j]) dfs(i, j), cnt++;
		if (cnt == 1)  ans++;
	} while (next_permutation(a, a + 12));
	cout << ans << endl;
	return 0;
}

四平方和

题目描述

四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多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

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

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

提交时，注意选择所期望的编译器类型。

代码

#include
#include
#include
using namespace std;

const int N = 5000010;
struct SUM {
     
	int s, c, d;

	bool operator < (const SUM& a) const {
     
		if (s != a.s) return s < a.s;
		if (c != a.c) return c < a.c;
		return d < a.d;
	}

}sum[N];


int main() {
     
	int n; 
	scanf("%d", &n);

	int k = 0;
	for (int i = 0; i * i <= n; ++i)
		for (int j = i; j * j + i * i <= n; ++j)
			sum[k++] = {
      i * i + j * j, i, j };

	sort(sum, sum + k);
	for (int i = 0; i * i <= n; ++i)
		for (int j = i; j * j <= n; ++j) {
     
			int t = n - i * i - j * j;
			int l = 0, r = k - 1;
			while (l < r) {
     
				int m = l + r >> 1;
				if (sum[m].s >= t) r = m;
				else l = m + 1;
			}

			if (sum[l].s == t) {
     
				printf("%d %d %d %d\n", i, j, sum[l].c, sum[l].d);
				return 0;
			}

		}
}

交换瓶子

题目描述

有N个瓶子，编号 1 ~ N，放在架子上。

比如有5个瓶子：
2 1 3 5 4

要求每次拿起2个瓶子，交换它们的位置。
经过若干次后，使得瓶子的序号为：
1 2 3 4 5

对于这么简单的情况，显然，至少需要交换2次就可以复位。

如果瓶子更多呢？你可以通过编程来解决。

输入格式为两行：
第一行: 一个正整数N（N<10000）, 表示瓶子的数目
第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。

输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。

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

程序应该输出：
3

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

程序应该输出：
2

资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

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

提交时，注意选择所期望的编译器类型。

#include
using namespace std;
const int N = 10000 + 10;
int a[N];
int main() {
     
	int n, sum = 0;
	scanf("%d", &n);
	for (int i = 1;i <= n;i++) scanf("%d", &a[i]);
	for (int i = 1;i <= n;)
		if (a[i] != i) {
     
			swap(a[a[i]], a[i]);
			sum++;
		}
		else i++;
	printf("%d\n", sum);
	return 0;
}

最大比例

题目描述

X星球的某个大奖赛设了M级奖励。每个级别的奖金是一个正整数。
并且，相邻的两个级别间的比例是个固定值。
也就是说：所有级别的奖金数构成了一个等比数列。比如：
16,24,36,54
其等比值为：3/2

现在，我们随机调查了一些获奖者的奖金数。
请你据此推算可能的最大的等比值。

输入格式：
第一行为数字 N (0 第二行N个正整数Xi(Xi<1 000 000 000 000)，用空格分开。每个整数表示调查到的某人的奖金数额

要求输出：
一个形如A/B的分数，要求A、B互质。表示可能的最大比例系数

测试数据保证了输入格式正确，并且最大比例是存在的。

例如，输入：
3
1250 200 32

程序应该输出：
25/4

再例如，输入：
4
3125 32 32 200

程序应该输出：
5/2

再例如，输入：
3
549755813888 524288 2

程序应该输出：
4/1

资源约定：
峰值内存消耗 < 256M
CPU消耗 < 3000ms

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

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

提交时，注意选择所期望的编译器类型。

代码

#include
#include
#include
using namespace std;

typedef long long LL;
const int N = 110;
LL num[N], a[N], b[N];

LL gcd(LL a, LL b) {
     
	return b ? gcd(b, a % b) : a;
}

LL gcd_sub(LL a, LL b) {
     
	if (a < b) swap(a, b); 
	if (b == 1) return a;
	return gcd_sub(b, a / b);
}

int main() {
     
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; ++i) scanf("%lld", &num[i]);

	sort(num, num + n);
	int cnt = 0;
	for (int i = 1; i < n; ++i) if (num[i] != num[i - 1]) {
     
		LL d = gcd(num[i], num[0]);
		a[cnt] = num[i] / d;
		b[cnt++] = num[0] / d;
	}

	LL up = a[0], down = b[0];
	for (int i = 1; i < cnt; ++i) {
     
		up = gcd_sub(up, a[i]);
		down = gcd_sub(down, b[i]);
	}

	printf("%lld/%lld\n", up, down);
	return 0;
}