第四届蓝桥杯C++本科B组决赛解题报告

<1>猜灯谜

897
A村的元宵节灯会上有一迷题：
请猜谜 * 请猜谜 = 请边赏灯边猜
小明想，一定是每个汉字代表一个数字，不同的汉字代表不同的数字。
请你用计算机按小明的思路算一下，然后提交“请猜谜”三个字所代表的整数即可。
请严格按照格式，通过浏览器提交答案。
注意：只提交一个3位的整数，不要写其它附加内容，比如：说明性的文字。

方法1：回溯排列法

#include<iostream>
using namespace std;
int c[6];
bool vis[10];

////////////////////////////////
void check(int* c)
{
	int qcm = c[0]*100 + c[1]*10 + c[2];
	int qbsdbc = c[0]*100000 + c[3]*10000 + c[4]*1000 + c[5]*100 + c[3]*10 + c[1];
	if(qcm*qcm == qbsdbc)
	{
		cout<<qcm<<endl;
	}
}

////////////////////////////////
void dfs(int start,int n)
{
	if(start == 6)
	{
		check(c);
		return;
	}
    for(int i = 0;i <= n;i++)
	{
		if(!vis[i])
		{
			c[start] = i;
			vis[i] = true;     //当时这里没写，后来想起来了，差点苦逼了。
			dfs(start+1,n);
			vis[i] = false;
		}
	}
}

///////////////////////////////////
void main()
{
	dfs(0,9);
}

/*
897
*/

方法2：暴力破解

#include<iostream>
using namespace std;

///////////////////////////////////
void f()
{
    for(int q = 0;q <= 9;q++)
        for(int c = 0;c <= 9;c++)
			for(int m = 0;m <= 9;m++)
				for(int b = 0;b <= 9;b++)
					for(int s = 0;s <= 9;s++)
						for(int d = 0;d <= 9;d++)
						{
							int cc[10] = {0};
							cc[q]++;
							cc[c]++;
							cc[m]++;
							cc[b]++;
							cc[s]++;
							cc[d]++;
							if(cc[q]==1 && cc[c]==1 && cc[m]==1 && cc[b]==1 && cc[s]==1 && cc[d]==1 )
							{
								
								int qcm = q*100 + c*10 + m;
								int qbsdbc = q*100000 + b*10000 + s*1000 + d*100 + b*10 + c;
								if(qcm*qcm == qbsdbc)
								{
									cout<<qcm<<endl;
								}
							}
						}
										
}


///////////////////////////////////
void main()
{
	f();
}

/*
897
*/

<2>连续奇数和

371
小明看到一本书上写着：任何数字的立方都可以表示为连续奇数的和。
比如：
2^3 = 8 = 3 + 5
3^3 = 27 = 7 + 9 + 11
4^3 = 64 = 1 + 3 + ... + 15
虽然他没有想出怎么证明，但他想通过计算机进行验证。
请你帮助小明写出 111 的立方之连续奇数和表示法的起始数字。如果有多个表示方案，选择起始数字小的方案。
请严格按照要求，通过浏览器提交答案。
注意：只提交一个整数，不要写其它附加内容，比如：说明性的文字。

#include<iostream>
using namespace std;

///////////////////////////////////
void f(int N)
{
	for(int i = 1;i <= N-1;i++)                //起始数字是i
	{
		int maxtimes = N/i;
		for(int j = 1;j <= maxtimes;j++)       //数字个数为j
		{
			if( (i+j-1)*j == N)
			{
				cout<<i<<endl;
				return;
			}
		}
	}
}

///////////////////////////////////
void main()
{
	f(111*111*111);
}

/*
371
*/

<3>空白格式化

*p_from
本次大赛采用了全自动机器测评系统。
如果你的答案与标准答案相差了一个空格，很可能无法得分，所以要加倍谨慎！
但也不必过于惊慌。因为在有些情况下，测评系统会把你的答案进行“空白格式化”。
其具体做法是：去掉所有首尾空白；中间的多个空白替换为一个空格。所谓空白指的是：空格、制表符、回车符。
以下代码实现了这个功能。仔细阅读代码，填写缺失的部分。
void f(char* from, char* to)
{

 char*p_from = from;
 char*p_to = to;
 while(*p_from==' ' || *p_from=='\t' || *p_from=='\n')
  p_from++;
 do{
  if(*p_from==' ' || *p_from=='\t' ||*p_from=='\n')
  {
   do{p_from++;}
   while(*p_from==' ' || *p_from=='\t' || *p_from=='\n');
   if(____________________)
    *p_to++ = ' '; //填空位置
  }
 }while(*p_to++ = *p_from++);
}

请分析代码逻辑，并推测划线处的代码，通过网页提交。
注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！ 

#include<iostream>
using namespace std;

//////////////////////////////////
void f(char* from, char* to)
{ 
	char*p_from = from; 
	char*p_to = to;
	while(*p_from==' ' || *p_from=='\t' || *p_from=='\n') 
		p_from++; 
	do{ 
		if(*p_from==' ' || *p_from=='\t' ||*p_from=='\n') 
		{   
			do
			{
				p_from++;
			} 
			while(*p_from==' ' || *p_from=='\t' || *p_from=='\n');   
			if(*p_from)    
				*p_to++ = ' ';//填空位置 
		}
	}while(*p_to++ = *p_from++);
}

//////////////////////////////////
void main()
{
	char str[] = " asd sdf  sdf  dsffsdf dfg gffg      ";
	f(str,str);
	cout<<str<<endl;
	cout<<strlen(str)<<endl;
}

/*
asd sdf sdf dsffsdf dfg gffg
28
*/

<4>高僧斗法
古时丧葬活动中经常请高僧做法事。仪式结束后，有时会有“高僧斗法”的趣味节目，以舒缓压抑的气氛。
节目大略步骤为：先用粮食（一般是稻米）在地上“画”出若干级台阶（表示N级浮屠）。
又有若干小和尚随机地“站”在某个台阶上。最高一级台阶必须站人，其它任意。(如图所示)
两位参加游戏的法师分别指挥某个小和尚向上走任意多级的台阶，但会被站在高级台阶上的小和尚阻挡，不能越过。
两个小和尚也不能站在同一台阶，也不能向低级台阶移动。
两法师轮流发出指令，最后所有小和尚必然会都挤在高段台阶，再也不能向上移动。
轮到哪个法师指挥时无法继续移动，则游戏结束，该法师认输。
对于已知的台阶数和小和尚的分布位置，请你计算先发指令的法师该如何决策才能保证胜出。
输入数据为一行用空格分开的N个整数，表示小和尚的位置。
台阶序号从1算起，所以最后一个小和尚的位置即是台阶的总数。（N<100, 台阶总数<1000）
输出为一行用空格分开的两个整数: A B, 表示把A位置的小和尚移动到B位置。若有多个解，输出A值较小的解，若无解则输出-1。

例如：
用户输入：
1 5 9
则程序输出：
1 4

再如：
用户输入：
1 5 8 10
则程序输出：
1 3

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

方法1：暴力破解

#include <stdio.h>   //参考蓝桥杯贴吧 dezhonger
int main()
{
	int a[105],b[105],i=0,j,k,count,sum;
	char c;
	while(1)
	{
		scanf("%d%c",&a[i++],&c);
		if(c=='\n')
			break;
	} 
	count=i;
	for(i = 0;i < count-1;i++)
		b[i]=a[i+1]-a[i]-1;
	b[count-1]=0;
	sum=b[0];
	for(i = 2;i < count;i = i+2)
		sum^=b[i];
	if(sum == 0) 
		printf("-1\n");
	else
	{
		for(i = 0;i < count;i++)
			for(j = 1;j <= b[i];j++)
			{
				b[i] -= j;
				if(i!=0)
					b[i-1]+=j;
				sum = b[0];
				for(k = 2;k < count;k = k+2)
					sum ^= b[k];
				if(sum == 0)
				{
					printf("%d %d\n",a[i],a[i]+j);
					break;
				}
				b[i] + =j;
				if(i != 0)
					b[i-1] -= j;
			}
	}
	return 0;
}

/*
1 3 5 7 12 14 17 26 38 45 66 100
66 84
*/

<5>格子刷油漆
X国的一段古城墙的顶端可以看成
2*N个格子组成的矩形（如图所示），现需要把这些格子刷上保护漆。
你可以从任意一个格子刷起，刷完一格，可以移动到和它相邻的格子（对角相邻也算数），但不能移动到较远的格子（因为油漆未干不能踩！）
比如：a d b c e f 就是合格的刷漆顺序。
c e f d a b 是另一种合适的方案。
当已知 N 时，求总的方案数。当N较大时，结果会迅速增大，请把结果对 1000000007 (十亿零七) 取模。
输入数据为一个正整数（不大于1000）
输出数据为一个正整数。
例如：
用户输入：
2
程序应该输出：
24

再例如：
用户输入：
3
程序应该输出：
96

再例如：
用户输入：
22
程序应该输出：
359635897

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

#include <stdio.h>
__int64 a[1001]={0};
__int64 b[1001]={0};
const int NUM=1000000007;

int main()
{
	int i,n;
	scanf("%d",&n);
	b[1]=1;
	for (i=2;i<=n;i++)
		b[i]=(b[i-1]*2%NUM);
	a[1]=1;a[2]=6;
	for (i=3;i<=n;i++)
		a[i]=(2*a[i-1]+b[i]+4*a[i-2])%NUM;
	__int64 sum=4*a[n];
	for (i=2;i<n;i++)
		sum=(sum+8*b[n-i]*a[i-1]+8*a[n-i]*b[i-1])%NUM;
	printf("%I64d\n",sum);
	return 0;
} 

/*
22
359635897
思路：
名词解释相对的格子：一列之中，除了指定格子之外的另一个格子。
1、构造两个动态规划数组和一个计数器sum，一个数组a[x]，表示在2*x的格子条件下，从最边缘一列的一个角的格子出发，遍历全体格子的种类数，显然a[1]=1,另一个数组b[x]，表示在2*x的格子条件下，从一个角的格子出发，遍历全体格子后回到与之相对的格子的种类数。如图所示，显然因为要考虑到回来的路径，因此除了出发点之外，每一列都只有2种选择方法，因此b[x]=2x-1 
2、先考虑出发点在角上的问题，从一个角出发，只有3种可能性，（1）那就是先去相对的格子，然后前往下一列，这就简化成为从2*x-1列的格子中，从一个角出发遍历所有格子的问题，因为前往下一列的第一个格子有两种选法，因此a[x]+=2*a[x-1];（2）第二种可能性就是先去遍历其余格子，最后以相对的格子收尾。此时a[x]+= b[x];（3）第三种可能性较为复杂，先经过第二列的一次转折，然后到第三列的一个角上进行遍历。此时第二列有2种选法，第三列有2种选法，因此a[x]+=4*a[x-2]; 
3、再去考虑出发点在中间的问题，如图所示，出发点在中间的时候，显然不能直接往下走，否则无法遍历所有点，应当是先遍历左边（右边）所有点，然后回到相对的点，然后遍历右边（左边）的点。注意先遍历的时候，必须是采用“遍历全体格子后回到与之相对的格子”的走法，否则无法遍历出发点正下方的点，而后遍历则不受限制。因此设从第i列开始出发，出发点有两种选法，第一落脚点又有两种走法，后遍历的第一落脚点又有两种走法，走完总走法数为2*(2*b[i-1]*2*a[n-i])+2*(2*b[n-i]*2*a[i-1]) （加法的前一半是先遍历左边，后一半是先遍历右边） 
4、总走法数就是4*a[i]（因为有4个角）+ 从2到第n-1列所有从中间走法数的和。
下面是代码(vc6.0)编译通过。时间复杂度为o[n]
*/

<6>农场阳光
X星球十分特殊，它的自转速度与公转速度相同，所以阳光总是以固定的角度照射。
最近，X星球为发展星际旅游业，把空间位置出租给Y国游客来晒太阳。每个租位是漂浮在空中的圆盘形彩云（圆盘与地面平行）。
当然，这会遮挡住部分阳光，被遮挡的土地植物无法生长。
本题的任务是计算某个农场宜于作物生长的土地面积有多大。输入数据的第一行包含两个整数a, b，表示某农场的长和宽分别是a和b，此时，
该农场的范围是由坐标(0, 0, 0), (a, 0, 0), (a, b, 0), (0, b, 0)围成的矩形区域。
第二行包含一个实数g，表示阳光照射的角度。简单起见，我们假设阳光光线是垂直于农场的宽的，
此时正好和农场的长的夹角是g度，此时，空间中的一点(x,
y, z)在地面的投影点应该是(x + z * ctg(g度), y, 0)，其中ctg(g度)表示g度对应的余切值。
第三行包含一个非负整数n，表示空中租位个数。
接下来 n 行，描述每个租位。其中第i行包含4个整数xi, yi, zi, ri，
表示第i个租位彩云的圆心在(xi, yi, zi)位置，圆半径为ri。
要求输出一个实数，四舍五入保留两位有效数字，表示农场里能长庄稼的土地的面积。
例如：
用户输入：
10 10
90.0
1
5 5 10 5
程序应该输出：
21.46再例如：
用户输入：
8 8
90.0
1
4 4 10 5
程序应该输出：
1.81样例3：
用户输入：
20 10
45.0
2
5 0 5 5
8 6 14 6程序输出：
130.15资源约定：
峰值内存消耗 < 64M  CPU消耗 < 1000ms