第一题
标题：迷宫
X星球的一处迷宫游乐场建在某个小山坡上。
它是由10x10相互连通的小房间组成的。
房间的地板上写着一个很大的字母。
我们假设玩家是面朝上坡的方向站立，则：
L表示走到左边的房间，
R表示走到右边的房间，
U表示走到上坡方向的房间，
D表示走到下坡方向的房间。
X星球的居民有点懒，不愿意费力思考。
他们更喜欢玩运气类的游戏。这个游戏也是如此！
开始的时候，直升机把100名玩家放入一个个小房间内。
玩家一定要按照地上的字母移动。
迷宫地图如下：
------------
UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR
------------
请你计算一下，最后，有多少玩家会走出迷宫?
而不是在里边兜圈子。
请提交该整数，表示走出迷宫的玩家数目，不要填写任何多余的内容。
如果你还没明白游戏规则，可以参看一个简化的4x4迷宫的解说图：
【思路】
dfs，模拟走路，深度遍历每一条路，设置走出迷宫的条件，每走一步标记该点已经走过(剪枝)，避免重复走。
答案:31
#include <iostream>
#include <cstring>
using namespace std;
char map[10][10];
int a[10][10];
bool dfs(int i, int j) {
if (i < 0 || i > 9 || j < 0 || j > 9)
return true;
else if (a[i][j] == 1)
return false;
else {
a[i][j] = 1;
if (map[i][j] == 'L')
return dfs(i, j - 1);
else if (map[i][j] == 'R')
return dfs(i, j + 1);
else if (map[i][j] == 'U')
return dfs(i - 1, j);
else
return dfs(i + 1, j);
}
}
int main(){
string str = "UDDLUULRULUURLLLRRRURRUURLDLRDRUDDDDUUUUURUDLLRRUUDURLRLDLRLULLURLLRDURDLULLRDDDUUDDUDUDLLULRDLUURRR";
int k = 0;
int rec = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
map[i][j] = str[k];
k++;
}
}
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
memset(a, 0, sizeof(a));
if (dfs(i, j))
rec ++;
}
}
cout << rec << endl;
return 0;
}
第二题
标题：跳蚱蜢
如图 所示：
有9只盘子，排成1个圆圈。
其中8只盘子内装着8只蚱蜢，有一个是空盘。
我们把这些蚱蜢顺时针编号为 1~8，
每只蚱蜢都可以跳到相邻的空盘中，
也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，
并且保持空盘的位置不变（也就是1-8换位，2-7换位,...），至少要经过多少次跳跃？
注意：要求提交的是一个整数，请不要填写任何多余内容或说明文字。
【思路】
设置排列为“123456789”,蚂蚱代表9，依照题意，最终的排列结果应该为"876543219"
再来分析题目，蚂蚱跳相当于盘子的位置改变，所以盘子每次改变位置的情况有四种{-1,1,-2,2}
显然要模拟排列情况，而且由于要求求出最小的步数，想到可以利用广度遍历思想解题。
每次头元素出队，找到头元素(一个排列)的9的位置(蚂蚱的位置)，让他分别从4个方向跳，新的排列存储到队列中，如果目标队列出现，则输出相应的结果。
这里运用一个set集合记录元素的序号。具体处理细节查看代码。
答案:20
#include <iostream>
#include <queue>
#include <cstring>
using namespace std;
const int size = 1000000000;
bool visit[size];
int temp[] = {1, -1, 2, -2}, a[10];
int start = 123456789, last = 876543219;
int get_num(int *a) {
int sum = 0;
for (int i = 0; i < 9; i++) {
sum *= 10;
sum += a[i];
}
return sum;
}
int main(){
memset(visit, 0, sizeof(visit));
queue<int> q;
queue<int> b;
q.push(start);
visit[start] = 1;
b.push(0);
while (1) {
int a_front = q.front(), b_front = b.front();
int c = 8, now;
while (a_front > 0) {
if (a_front % 10 == 9) now = c; //记录数字9在当前数组的位置
a[c--] = a_front % 10;
a_front /= 10;
}
for (int i = 0; i < 4; i++) {
swap(a[now], a[(now+9+temp[i])%9]);
int d = get_num(a);
if (!visit[d]) {
visit[d] = 1;
if (d == last) {
cout << b_front + 1 << endl;
return 0;
}
q.push(d);
b.push(b_front+1);
}
swap(a[now], a[(now+9+temp[i])%9]);
}
q.pop();
b.pop();
}
}
第五题
标题：字母组串
由 A,B,C 这3个字母就可以组成许多串。
比如："A","AB","ABC","ABA","AACBB" ....
现在，小明正在思考一个问题：
如果每个字母的个数有限定，能组成多少个已知长度的串呢？
他请好朋友来帮忙，很快得到了代码，
解决方案超级简单，然而最重要的部分却语焉不详。
请仔细分析源码，填写划线部分缺少的内容。
#include <stdio.h>
// a个A，b个B，c个C 字母，能组成多少个不同的长度为n的串。
int f(int a, int b, int c, int n)
{
if(a<0 || b<0 || c<0) return 0;
if(n==0) return 1;
return ______________________________________ ; // 填空
}
int main()
{
printf("%d\n", f(1,1,1,2));
printf("%d\n", f(1,2,3,3));
return 0;
}
对于上面的测试数据，小明口算的结果应该是：
6
19
注意：只填写划线部分缺少的代码，不要提交任何多余内容或说明性文字。
【思路】
由代码可知必定用到了递归。当前位置的总数等于用了a的总数加上用了b的总数加上用了c的总数。
答案:f(a-1,b,c,n-1) + f(a,b-1,c,n-1) + f(a,b,c-1,n-1)
第七题
描述：正则问题
考虑一种简单的正则表达式：
只由 x ( ) | 组成的正则表达式。
小明想求出这个正则表达式能接受的最长字符串的长度。
例如 ((xx|xxx)x|(x|xx))xx 能接受的最长字符串是： xxxxxx，长度是6。
输入
----
一个由x()|组成的正则表达式。输入长度不超过100，保证合法。
输出
----
这个正则表达式能接受的最长字符串的长度。
例如，
输入：
((xx|xxx)x|(x|xx))xx
程序应该输出：
6
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
【思路】
设置一个栈，遍历字符串，当遍历到')'以外的元素时，元素压栈
对遍历到字符')'的处理:
1.元素一直出栈直到对应的'('出栈；
2.元素如果不是'|'，则计算这一段连续的串中一共有多少个x；
3.元素如果是'|'，则把之前计算到的x的数目压入到一个数组中，重新计算x的数目；
4.当最后遍历到'('时，数组中普通情况下会存在数字，每个数字代表一段连续的x的个数，选出最大的数字，压入栈中，在这里我用字符串处理，即将这个数字强制转换为字符压入栈中，因为输入的字符串长度不超出100，所以可以这样处理。这也解释了为什么第二种情况我没说"元素如果是x"，因为元素可能是100以内的字符，但这不影响我们计算x的个数。
#include <bits/stdc++.h>
using namespace std;
const int num = 100;
int max_num(int *a, int n) {
int max = -1;
for (int i = 0; i < n; i++) {
if (max < a[i])
max = a[i];
}
return max;
}
int main() {
stack<char> st;
string s;
int a[num], t, rec, max;
char c;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(' || s[i] == '|' || s[i] == 'x')
st.push(s[i]);
else {
c = st.top();
t = 0;
rec = 0;
while (c != '(') {
if (c != '|') {
if (c == 'x')
t ++;
else
t += (int)c;
}
else {
a[rec++] = t;
t = 0;
}
st.pop();
c = st.top();
}
st.pop();
a[rec++] = t;
max = max_num(a, rec);
st.push((char)max);
memset(a, 0, sizeof(a));
rec = 0;
}
}
rec = 0;
t = 0;
while (!st.empty()) {
c = st.top();
if (c != '|') {
if (c == 'x')
t ++;
else
t += (int)c;
}
else {
a[rec++] = t;
t = 0;
}
st.pop();
}
a[rec++] = t;
max = max_num(a, rec);
cout << max << endl;
return 0;
}
第八题
标题：包子凑数
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有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 <xxx>
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
【思路】
此题解不能完全正确。
首先要知道给出的数据中没有互质的数，则有无数种情况不能被组合。
下面代码只是模拟了在一个范围内能够被组合的数，输出这个范围内不能被组合的数的个数。
此思路是网上看到的，自己之前写了一个暴力破解某个数是否能被组合，而当然这个数足够大电脑就宕机了。。。
一个很大的困惑是在有限种情况下，那个能被组合出来的最大数值是多少，可能以后会补充。
#include <bits/stdc++.h>
using namespace std;
const int num = 100000;
int n;
int a[100];
int dp[num];
bool flag;
bool gcd(int x, int y) {
while (y != 0) {
int rec = x;
x = y;
y = rec % y;
}
if (x == 1)
return true;
else
return false;
}
int main() {
cin >> n;
int m;
for (int i = 0; i < n; i++)
cin >> a[i];
flag = false;
for (int i = 0; i < n-1; i++) {
for (int j = i+1; j < n; j++) {
if (gcd(a[i], a[j])) {
flag = true;
break;
}
}
if (flag == true)
break;
}
if (flag = false)
cout << "INF" << endl;
else {
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
dp[a[i]] = 1;
for (int j = 0; j+a[i] < num; j++) {
if(dp[j])
dp[j+a[i]] = 1;
}
}
int k = 0;
for (int i = 1; i < num; i++) {
if (!dp[i])
k++;
}
cout << k << endl;
}
return 0;
}