2016年第七届C/C++ B组蓝桥杯省赛真题

• • 真题
  • • • 第一题：煤球数目
      • 第二题：生日蜡烛
      • 第三题：凑算式
      • 第四题：快速排序
      • 第五题：抽签
      • 第六题：方格填数
      • 第七题：剪邮票
      • 第八题：四平方和
      • 第九题：交换瓶子
      • 第十题：最大比例
  • 题解
  • • • 第一题：煤球数目
      • 第二题：生日蜡烛
      • 第三题：凑算式
      • 第四题：快速排序
      • 第五题：抽签
      • 第六题：方格填数
      • 第七题：剪邮票
      • 第八题：四平方和
      • 第九题：交换瓶子
      • 第十题：最大比例

题目描述
有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），…
如果一共有100层，共有多少个煤球？
请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

题目描述
某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。
现在算起来，他一共吹熄了236根蜡烛。
请问，他从多少岁开始过生日party的？
请填写他开始过生日party的年龄数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

题目描述

       B       DEF
A +    —    +  ——— = 10
       C       GHI

这个算式中AI代表19的数字，不同的字母代表不同的数字。
比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。

这个算式一共有多少种解法？
注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。

题目描述
排序在各种场合经常被用到。
快速排序是十分常用的高效率的算法。
其思想是：先选一个“标尺”，
用它把整个队列过一遍筛子，
以保证：其左边的元素都不大于它，其右边的元素都不小于它。
这样，排序问题就被分割为两个子区间。
再分别对子区间排序就可以了。
下面的代码是一种实现，请分析并填写划线部分缺少的代码。

#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(ix);
		if(i>=j) break;
		swap(a,i,j);
	}
	______________________;//填空
	return j;
}
void quicksort(int a[], int p, int r)
{
	if(p
		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 
第五题：抽签 
题目描述
 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("%sn",b);
		return;
	}
	for(i=0; i<=a[k]; i++)
	{
		for(j=0; j
	int a[N] = {4,2,2,1,1,3};
	char b[BUF];
	f(a,0,M,b);
	return 0;
}


 
第六题：方格填数 
题目描述
 如下的10个格子填入0~9的数字。要求：连续的两个数字不能相邻。
 （左右、上下、对角都算相邻）
 一共有多少种可能的填数方案？
 请填写表示方案数目的整数。
 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
 
 
第七题：剪邮票 
题目描述
 如【图1.jpg】, 有12张连在一起的12生肖的邮票。
 现在你要从中剪下5张来，要求必须是连着的。
 （仅仅连接一个角不算相连）
 比如，【图2.jpg】，【图3.jpg】中，粉红色所示部分就是合格的剪取。
 请你计算，一共有多少种不同的剪取方法。
 请填写表示方案数目的整数。
 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
 
 
 
 
第八题：四平方和 
题目描述
 四平方和定理，又称为拉格朗日定理：
 每个正整数都可以表示为至多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
 
第九题：交换瓶子 
题目描述
 有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
 
第十题：最大比例 
题目描述
 X星球的某个大奖赛设了M级奖励。每个级别的奖金是一个正整数。
 并且，相邻的两个级别间的比例是个固定值。
 也就是说：所有级别的奖金数构成了一个等比数列。比如：
 16,24,36,54
 其等比值为：3/2
 
现在，我们随机调查了一些获奖者的奖金数。
 请你据此推算可能的最大的等比值。
 
输入格式：
 第一行为数字N，表示接下的一行包含N个正整数
 第二行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
 
题解 
第一题：煤球数目 
分析
 模拟
 我是模拟三棱锥的形状dp，其实能找到规律就直接写也行
 代码
 
int main()
{
	vector dp = {1, 3, 6, 10 };

	for (int i = 4; i != 100; i++){
		int temp = dp[i - 3] + 3 * (i+1) - 3;
		dp.push_back(temp);
	}
	
	int ans = 0;
	
	for (auto d : dp)
		ans += d;
	
	cout << ans << endl;

	return 0;
}
ans  171700
 
第二题：生日蜡烛 
分析
 枚举
 代码
 
int main()
{
	for (int i = 0; i != 100; i++){
		int temp = i;
		for (int j = i+1; j != 150; j++){
			temp += j;
			if (temp == 236){
				cout << i << endl;
			}
			else if(temp>236){
				break;
			}
		}
	}

	return 0;
}
ans  26

 
第三题：凑算式 
分析
 暴力就ok，需要注意的是判断的时候不能直接按照原式，因为整形类型进行除法可能会有精度缺失，就算用float也可能产生误差
 转换为乘法：(10 - a)cghi == bghi + defc;
 代码
 
int ans = 0;

bool isok(vector& arr){
	int a = arr[0];
	int b = arr[1];
	int c = arr[2];
	int def = arr[3] * 100 + arr[4] * 10 + arr[5];
	int ghi = arr[6] * 100 + arr[7] * 10 + arr[8];
	

	return (10 - a)*c*ghi == b*ghi + def*c;


}

void dfs(int i, vector& arr, vector& sign){
	if (i == 9){
		if (isok(arr)){
			ans++;
		}
		return;
	}

	for (int j = 1; j <= 9; j++){
		if (sign[j]){
			sign[j] = 0;
			arr[i] = j;
			dfs(i + 1, arr, sign);
			sign[j] = 1;
		}
	}
}


int main()
{
	vector sign(10, 1);
	vector arr(9);
	dfs(0, arr, sign);
	cout << ans << endl;

	system("pause");
	return 0;
}
ans  29


 
第四题：快速排序 
分析
 快排
 代码
 
#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 (ix);
		if (i >= j) break;
		swap(a, i, j);
	}
	swap(a, p, j);//填空
	return j;
}
void quicksort(int a[], int p, int r)
{
	if (p
		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 
第五题：抽签 
分析
 递归
 分析各个参数的含义，结合代码
 代码
 
void f(int a[], int k, int m, char b[])
{
	int i, j;
	if (k == N)
	{
		b[M] = 0;
		if (m == 0) printf("%sn", b);
		return;
	}
	for (i = 0; i <= a[k]; i++)
	{
		for (j = 0; j
	int a[N] = { 4, 2, 2, 1, 1, 3 };
	char b[BUF];
	f(a, 0, M, b);
	return 0;
}

ans ： f(a,k+1,m-i,b); 
 
第六题：方格填数 
分析
 我刚开始写的用时非常长，我还想着有什么别的方法，后来发现一个写的很好的代码，很快就得到答案了。
 比我优在两处：1.用二维数组去填，方便检查周围 2.剪枝，在填数字的过程中检查是否可行
 代码
 
#include 
#include 
#include 
int chess[8][8],sum=0;//sum代表方案的总数 
bool vis[20];
int dx[8]={-1,-1,-1,0,0,1,1,1};
int dy[8]={-1,0,1,-1,1,-1,0,1}; 
bool check(int k,int x,int y)//对他相邻的8个方格进行比较 
{
	int i,j;
	for(i=0;i<8;++i)
	{
		int ex = x + dx[i];
		int ey = y + dy[i];
		if(chess[ex][ey]!=-1&&(ex!=1||ey!=1)&&(ex!=3||ey!=4)&&ex>=1&&ex<4&&ey>0&&ey<5)
		{
			if(abs(chess[ex][ey]-k)==1)
				return false; 
		} 
	} 
	return true;
} 
void dfs(int sx,int sy)//sx,sy代表初始坐标 
{
	for(int k=0;k<10;++k)
	{
		if(!vis[k]&&check(k,sx,sy))
		{
			if(sx==3&&sy==3)//这个 是终点坐标，最后一个数没有必要进行标记 
			{				//直接回溯就行了 
				++sum;
				return ;
			} 
			chess[sx][sy]=k;
			vis[k]=true;
			if(sy==4)//如果到达了，最后一列就进行下一行的填数 
				dfs(sx+1,1);
			else
				dfs(sx,sy+1);
			vis[k]=false;
			chess[sx][sy]=-1; 
		} 
	} 
} 
 
int main()
{
	memset(chess,-1,sizeof(chess));
	memset(vis,false,sizeof(vis)); 
	dfs(1,2);//0代表已经填写了多少个数，1，2代表开始的坐标
	printf("%dn",sum); 
	return 0;
} 
 
第七题：剪邮票 
分析
 dfs
 需要注意的是，这道题目最后需要加2，因为有两个十字形状的情况是没法通过递归找到的
 
代码
 
int dx[] = { 0, 0, 1, -1 };
int dy[] = { 1, -1, 0, 0 };



int ans = 0;

void dfs(vector>& arr,int i,int j,int n){
	if (n == 5){
		ans++;
		return;
	}

	for (int k = 0; k != 4; k++){
		int x, y;
		x = dx[k] + i;
		y = dy[k] + j;
		if (x >= 0 && x < 3 && y >= 0 && y < 4 && arr[x][y] == 1){
			arr[x][y] = 0;
			dfs(arr, x, y, n + 1);
			arr[x][y] = 1;
		}

	}


}


int main()
{
	vector> arr(3, vector(4, 1));

	for (int i = 0; i != 3; i++){
		for (int j = 0; j != 4; j++){
			arr[i][j] = 0;
			dfs(arr, i, j, 1);
		}
	}

	cout << ans + 2 << endl;

	return 0;
}
68
 
第八题：四平方和 
分析
 这道题真是做的难受 并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法完全不知道啥意思，总和最小？并不是，无语了，看了各路题解也没有人说这里。
 最后看着通过的代码我才能勉强给这句话翻译过来，他意思是说a,b,c,d都尽可能小，并且越靠前的位置优先级越大，举个例子，假设两个答案 a1 b1 c1 d1 ,a2 b2 c2 d2,他俩比较的方式为：先比较a，如果a相等再比较b，b相等再比较c，c相等比较d，这也就解释了为啥得到第一个答案就能return
 代码就是多重循环加优化，这题目是真不做人啊。
 代码
 
int main()
{
	int n;
	cin >> n;
	unordered_map map;
	for (int i = 0; i*i < n; i++)
		for (int j = i; j*j + i*i <= n; j++)
			if (map.find(i*i + j*j) != map.end())
				map[i*i + j*j] = i;
		
	

	for (int i = 0; i < 3000; i++){
		for (int j = i; j < 3000; j++){
			if (map.find(n - i*i - j*j) != map.end()){
				int a = map[n - i*i - j*j];
				int b = sqrt(n - i*i - j*j - a*a);
				cout << i << " " << j << " " << a << " " << b << endl;
				return 0;
			}

		}
	}

	return 0;
}

 
第九题：交换瓶子 
分析
 贪心+递归
 对于每一步交换我都想让一个瓶子交换到他自己的位置且另一个瓶子也尽量到自己的位置。
 具体做法：我们新建一个长度为n+1的数组来存放原来的状态，然后遍历一遍，在遍历的过程中，发现不符合位置的情况，就把该位置花瓶拟放到他的位置p，并把他位置p上原来的那个花瓶放到他应该放的位置i，再把i放到他应该放的地方…直至遇到第一个空位。
 代码
 
int sign = -1;
int ans = 0;

void dfs(int n, vector& arr){
	if (arr[n] == sign){
		arr[n] = n;
		return;
	}
	else{
		ans++;
		int temp = arr[n];
		arr[n] = n;
		dfs(temp, arr);
	}
}


int main()
{
	int n;
	cin >> n;
	vector arr(1, 0);
	for (int i = 0; i != n; i++){
		int temp;
		cin >> temp;
		arr.push_back(temp);
	}

	for (int i = 1; i != n + 1; i++){
		if (arr[i] != i){
			int temp = arr[i];
			arr[i] = sign;
			dfs(temp, arr);
		}

	}
	cout << ans << endl;

	return 0;
}


 
第十题：最大比例 
分析
 辗转相除法
 将奖金数从小到大排列arr[n]
 设p/q为答案,则 arr[i]/arr[i-1]=pk/qk(k为正整数，0 则题目可以转换为求 arr[i]/arr[i-1] (0 辗转相除法 是用来求最大公因子的。
 下面代码实现时将arr[i] ,arr [i-1] 放在两个数组中。
 
#include
#include
using namespace std;
 
typedef long long ll;

ll a[105], b[105], x[105];
 
ll gcd(ll a, ll b)
{
  return (!b)?a:gcd(b, a%b);
}
 
int main()
{
    int n;
    while(cin >> n)
    {
      for(int i = 1; i <= n; i++) cin >> x[i];
      sort(x+1, x+1+n);
      int cnt = 0;
      for(int i = 2; i <= n; i++)
      {
      	//去重
        if(x[i] != x[i-1])
        {
          cnt++;
          //化简
          ll tmp = gcd(x[i], x[i-1]);
          a[cnt] = x[i-1] / tmp;
          b[cnt] = x[i] / tmp;
        }
      }
 
      ll q = a[1], p = b[1];
      for(int i = 2; i <= cnt; i++)
      {
        q = gcd(q, a[i]);
        p= gcd(p, b[i]);
      }
 
      cout << p << "/" << q << endl;
    }
 
 
    return 0;
}