第七届蓝桥杯决赛B组C++题解代码

第一题

一步之遥

从昏迷中醒来，小明发现自己被关在X星球的废矿车里。
矿车停在平直的废弃的轨道上。
他的面前是两个按钮，分别写着“F”和“B”。

小明突然记起来，这两个按钮可以控制矿车在轨道上前进和后退。
按F，会前进97米。按B会后退127米。
透过昏暗的灯光，小明看到自己前方1米远正好有个监控探头。
他必须设法使得矿车正好停在摄像头的下方，才有机会争取同伴的援助。
或许，通过多次操作F和B可以办到。

矿车上的动力已经不太足，黄色的警示灯在默默闪烁…
每次进行 F 或 B 操作都会消耗一定的能量。
小明飞快地计算，至少要多少次操作，才能把矿车准确地停在前方1米远的地方。

请填写为了达成目标，最少需要操作的次数。

注意，需要提交的是一个整数，不要填写任何无关内容（比如：解释说明等）

答案：97

#include<bits/stdc++.h>
using namespace std;
int main()
{
	for(int i = 1;;i++)
	{
		if((i*97-1)%127==0)
		{
			cout<<i<<" "<<(i*97-1)/127<<endl;
			cout<<i+(i*97-1)/127<<endl;
			break;
		}
	}
	return 0;
}

第二题

凑平方数

把0~9这10个数字，分成多个组，每个组恰好是一个平方数，这是能够办到的。
比如：0, 36, 5948721

再比如：
1098524736
1, 25, 6390784
0, 4, 289, 15376
等等…

注意，0可以作为独立的数字，但不能作为多位数字的开始。
分组时，必须用完所有的数字，不能重复，不能遗漏。

如果不计较小组内数据的先后顺序，请问有多少种不同的分组方案？

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

答案：300

#include<bits/stdc++.h>
using namespace std;
vector<vector<long long> > same;
void checked(int a1[10],int idx,vector<long long> res)
{
	if(idx==10)
	{
		sort(res.begin(),res.end());
		for(int i = 0;i<same.size();i++)
		{
			if(same[i]==res)
			{
				return;
			}
		}
		same.push_back(res);
		return;
	}
	if(a1[idx]==0)
	{
		res.push_back(0);
		checked(a1,idx+1,res);
		res.pop_back();
		return;
	}
	double sum = 0;
	for(int i = idx;i<10;i++)
	{
		sum=sum*10+a1[i];
		if(sqrt(sum)==(int)sqrt(sum))
		{
			res.push_back(sum);
			checked(a1,i+1,res);
			res.pop_back();
		}
	}
}
int main()
{
	int a1[10] = {0,1,2,3,4,5,6,7,8,9};
	sort(a1,a1+10);
	vector<long long> res;
	int sum = 0;
	do
	{
		checked(a1,0,res);
		
	}while(next_permutation(a1,a1+10));
	for(int i = 0;i<same.size();i++)
	{
		for(int j = 0;j<same[i].size();j++)
		{
			cout<<same[i][j]<<" ";
		}
		cout<<endl;
	}
	cout<<same.size()<<endl;
	return 0;
}

第三题

棋子换位

有n个棋子A，n个棋子B，在棋盘上排成一行。
它们中间隔着一个空位，用“.”表示，比如：

AAA.BBB

现在需要所有的A棋子和B棋子交换位置。
移动棋子的规则是：

1. A棋子只能往右边移动，B棋子只能往左边移动。
2. 每个棋子可以移动到相邻的空位。
3. 每个棋子可以跳过相异的一个棋子落入空位（A跳过B或者B跳过A）。

AAA.BBB 可以走法：
移动A ==> AA.ABBB
移动B ==> AAAB.BB

跳走的例子：
AA.ABBB ==> AABA.BB

以下的程序完成了AB换位的功能，请仔细阅读分析源码，填写划线部分缺失的内容。

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

void move(char* data, int from, int to)
{
	data[to] = data[from];
	data[from] = '.';
}

int valid(char* data, int k)
{
	if(k<0 || k>=strlen(data)) return 0;
	return 1;
}
	
void f(char* data)
{
	int i;
	int tag;
	int dd = 0; // 移动方向
	
	while(1){
		tag = 0;
		for(i=0; i<strlen(data); i++){
			if(data[i]=='.') continue;
			if(data[i]=='A') dd = 1;
			if(data[i]=='B') dd = -1;
			
			if(valid(data, i+dd) && valid(data,i+dd+dd) 
			&& data[i+dd]!=data[i] && data[i+dd+dd]=='.'){ 
			//如果能跳... 
				move(data, i, i+dd+dd);
				printf("%s\n", data);
				tag = 1;
				break;
			}
		}
		
		if(tag) continue;
		
		for(i=0; i<strlen(data); i++){
			if(data[i]=='.') continue;
			if(data[i]=='A') dd = 1;
			if(data[i]=='B') dd = -1;			
				 
			if(valid(data, i+dd) && data[i+dd]=='.'){ 
			// 如果能移动...
				if( ______________________ ) continue;  //填空位置 
				move(data, i, i+dd);
				printf("%s\n", data);
				tag = 1;
				break;
			}
		}
		
		if(tag==0) break;					
	}
}
	
int main()
{
	char data[] = "AAA.BBB";	
	f(data);
	return 0;
}

注意：只提交划线部分缺少的代码，不要复制已有代码或填写任何多余内容。

答案：i==3&&data[i+dd+dd]!=data[i]

第四题

机器人塔

X星球的机器人表演拉拉队有两种服装，A和B。
他们这次表演的是搭机器人塔。

类似：

     A
    B B
   A B A
  A A B B
 B B B A B
A B A B B A

队内的组塔规则是：

A 只能站在 AA 或 BB 的肩上。
B 只能站在 AB 或 BA 的肩上。

你的任务是帮助拉拉队计算一下，在给定A与B的人数时，可以组成多少种花样的塔。

输入一行两个整数 M 和 N，空格分开（0<M,N<500）,分别表示A、B的人数，保证人数合理性。

要求输出一个整数，表示可以产生的花样种数。

例如：
用户输入：
1 2

程序应该输出：
3

再例如：
用户输入：
3 3

程序应该输出：
4

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

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

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

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

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

//↓↓↓↓↓↓↓↓↓估计只能过一个测试用例，垃圾代码↓↓↓↓↓↓↓
#include<bits/stdc++.h>
using namespace std;
int M,N;
char table[1001];
int sum = 0;
void dfs(int m,int n,int floor,int num,int node)
{
	if(m<0||n<0)
	{
		return;
	}
	if(m==0&&n==0)
	{
		sum++;
		return;
	}

	if(table[node]=='A')
	{
		if(table[floor+node+num]=='\0')
		{
			table[floor+node+num] = 'A';
			table[floor+node+num+1] = 'A';
			if(num+1==floor)
			{
				dfs(m-2,n,floor+1,0,node+1);
			}
			else
			{
				dfs(m-2,n,floor,num+1,node+1);
			}
			
			
			table[floor+node+num] = 'B';
			table[floor+node+num+1] = 'B';
			if(num+1==floor)
			{
				dfs(m,n-2,floor+1,0,node+1);
			}
			else
			{
				dfs(m,n-2,floor,num+1,node+1);
			}
			table[floor+node+num] = '\0';
			table[floor+node+num+1] = '\0';
			
		}
		else if(table[floor+node+num]=='A')
		{
			table[floor+node+num+1] = 'A';
			if(num+1==floor)
			{
				dfs(m-1,n,floor+1,0,node+1);
			}
			else
			{
				dfs(m-1,n,floor,num+1,node+1);
			}
			table[floor+node+num+1] = '\0';
		}
		else if(table[floor+node+num]=='B')
		{
			table[floor+node+num+1] = 'B';
			if(num+1==floor)
			{
				dfs(m,n-1,floor+1,0,node+1);
			}
			else
			{
				dfs(m,n-1,floor,num+1,node+1);
			}
			table[floor+node+num+1] = '\0';
		}
	}
	else
	{
		if(table[floor+node+num]=='\0')
		{
			table[floor+node+num] = 'A';
			table[floor+node+num+1] = 'B';
			if(num+1==floor)
			{
				dfs(m-1,n-1,floor+1,0,node+1);
			}
			else
			{
				dfs(m-1,n-1,floor,num+1,node+1);
			}
			
			
			table[floor+node+num] = 'B';
			table[floor+node+num+1] = 'A';
			if(num+1==floor)
			{
				dfs(m-1,n-1,floor+1,0,node+1);
			}
			else
			{
				dfs(m-1,n-1,floor,num+1,node+1);
			}
			table[floor+node+num] = '\0';
			table[floor+node+num+1] = '\0';
			
		}
		else if(table[floor+node+num]=='A')
		{
			table[floor+node+num+1] = 'B';
			if(num+1==floor)
			{
				dfs(m,n-1,floor+1,0,node+1);
			}
			else
			{
				dfs(m,n-1,floor,num+1,node+1);
			}
			table[floor+node+num+1] = '\0';
		}
		else if(table[floor+node+num]=='B')
		{
			table[floor+node+num+1] = 'A';
			if(num+1==floor)
			{
				dfs(m-1,n,floor+1,0,node+1);
			}
			else
			{
				dfs(m-1,n,floor,num+1,node+1);
			}
			table[floor+node+num+1] = '\0';
		}
	}
	
	
	
}
int main()
{
	cin>>M>>N;
	table[1] = 'A';
	dfs(M-1,N,1,0,1);
	fill(table,table+1001,'\0');
	table[1] = 'B';
	dfs(M,N-1,1,0,1);
	cout<<sum<<endl;
	return 0;
}