第一题：
标题：迷宫
X星球的一处迷宫游乐场建在某个小山坡上。
它是由10x10相互连通的小房间组成的。
房间的地板上写着一个很大的字母。
我们假设玩家是面朝上坡的方向站立，则：
L表示走到左边的房间，
R表示走到右边的房间，
U表示走到上坡方向的房间，
D表示走到下坡方向的房间。
X星球的居民有点懒，不愿意费力思考。
他们更喜欢玩运气类的游戏。这个游戏也是如此！
开始的时候，直升机把100名玩家放入一个个小房间内。
玩家一定要按照地上的字母移动。
迷宫地图如下：
UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR
请你计算一下，最后，有多少玩家会走出迷宫?
而不是在里边兜圈子。
请提交该整数，表示走出迷宫的玩家数目，不要填写任何多余的内容。
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
char map[20][20];
int vis[20][20];//标记数组，在一条路径中，被查找过的节点不能被再次查找，不然就会使路径出现循环
int cnt = 0;
int findd(int i,int j){
memset(vis,0,sizeof(vis));
while(1){
if(i < 0 || i > 9 || j < 0 || j > 9 ){
return 1;
}
if(vis[i][j]){
return 0;
}
vis[i][j]=1;
switch(map[i][j]){
case 'U': i--;break;
case 'L': j--;break;
case 'R': j++;break;
case 'D': i++;break;
default: break;
}
}
}
int main(){
int i,j;
for(i=0;i<10;i++){
for(j=0;j<10;j++){
cin >> map[i][j];
}
}
for(int i = 0; i < 10; i++)
{
for(int j = 0; j < 10; j++)
{
cnt +=findd(i, j);
}
}
printf("%d", cnt);
return 0;
}
第二题：
标题：跳蚱蜢
如图 p1.png 所示：
有9只盘子，排成1个圆圈。
其中8只盘子内装着8只蚱蜢，有一个是空盘。
我们把这些蚱蜢顺时针编号为 1~8
每只蚱蜢都可以跳到相邻的空盘中，
也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，
并且保持空盘的位置不变（也就是1-8换位，2-7换位,…），至少要经过多少次跳跃？
#include<iostream>
#include<memory.h>
#include<stack>
#include<string>
#include<cmath>
#include<map>
#include<algorithm>
#include<sstream>
#include<set>
#include<queue>
using namespace std;
struct node
{
string str;
int pos;
int step;
node(string str,int pos,int step):str(str),pos(pos),step(step){
}
};
int N=9;
set<string> visited;//已经搜索过的局面
queue<node> q;//用户来广搜的队列
void insertq(node no,int i)//node为新的局面,i为移动方式
{
string s=no.str;
swap(s[no.pos],s[(no.pos+i+9)%9]);//将0和目标位置数字交换
//取模是为了模拟循环的数组
if(visited.count(s)==0)//如果没有搜索过这个局面
{
visited.insert(s);
node n(s,(no.pos+i+9)%9,no.step+1);
q.push(n);
}
}
int main()
{
node first("012345678",0,0);
q.push(first);
while(!q.empty())
{
node temp = q.front();
if(temp.str=="087654321")
{
cout<<temp.step;
break;
}
else
{
//四种跳法
insertq(temp,1);
insertq(temp,-1);
insertq(temp,2);
insertq(temp,-2);
q.pop();
}
}
}
第三题：
标题：魔方状态
二阶魔方就是只有2层的魔方，只由8个小块组成。
如图p1.png所示。
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色
请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
请提交表示状态数的整数，不要填写任何多余内容或说明文字。
第四题：
标题：方格分割
6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如图：p1.png, p2.png, p3.png 就是可行的分割法。
试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。
请提交该整数，不要填写任何多余的内容或说明文字。
#include<iostream>
using namespace std;
int dx[4]={
1,0,-1,0},dy[4]={
0,1,0,-1};
int ans=0;
int map[7][7]={
0};//初始化
void DFS(int x,int y)
{
if(x==0||x==6||y==0||y==6)
{
ans++;
return;
}
for(int i=0;i<4;i++)//四个方向
{
int newx=x+dx[i];
int newy=y+dy[i];
if(map[newx][newy]==0)
{
map[newx][newy]=1;
map[6-newx][6-newy]=1;
DFS(newx,newy);
map[newx][newy]=0;
map[6-newx][6-newy]=0;
}
}
}
int main()
{
map[3][3]=1;//从中心开始，3,3表示中心的点
DFS(3,3);
cout<<ans/4<<endl;//注意结果除以4
return 0;
}
第五题：
标题：字母组串
由 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
答案：
f(a - 1, b, c, n - 1) + f(a, b - 1, c, n - 1) + f(a, b, c - 1, n - 1)
第六题：
标题：最大公共子串
最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。
比如：“abcdkkk” 和 “baabcdadabc”，
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路，并补全划线部分缺失的代码。
#include <stdio.h>
#include <string.h>
#define N 256
int f(const char* s1, const char* s2)
{
int a[N][N];
int len1 = strlen(s1);
int len2 = strlen(s2);
int i,j;
memset(a,0,sizeof(int)*N*N);
int max = 0;
for(i=1; i<=len1; i++){
for(j=1; j<=len2; j++){
if(s1[i-1]==s2[j-1]) {
a[i][j] = __________________________; //填空
if(a[i][j] > max) max = a[i][j];
}
}
}
return max;
}
int main()
{
printf("%d\n", f("abcdkkk", "baabcdadabc"));
return 0;
}
答案：a[i - 1][j - 1] + 1
第七题：
描述：正则问题
考虑一种简单的正则表达式：
只由 x ( ) | 组成的正则表达式。
小明想求出这个正则表达式能接受的最长字符串的长度。
例如 ((xx|xxx)x|(x|xx))xx 能接受的最长字符串是： xxxxxx，长度是6。
输入
一个由x()|组成的正则表达式。输入长度不超过100，保证合法。
输出
这个正则表达式能接受的最长字符串的长度。
例如，
输入：
((xx|xxx)x|(x|xx))xx
程序应该输出：
6
#include <iostream>
using namespace std;
string str;
int pos, len, ans;
int dfs()
{
int num = 0, res = 0;
while(pos < len)
{
if(str[pos] == '(')
{
pos ++ ;
num += dfs();
}
else if(str[pos] == ')')
{
pos ++ ;
break;
}
else if(str[pos] == '|')
{
pos ++ ;
res = max(res, num);
num = 0;
}
else
{
num ++ ;
pos ++ ;
}
}
res = max(res, num);
return res;
}
int main()
{
cin >> str;
len = str.length();
ans = dfs();
cout << ans << 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
#include<iostream>
using namespace std;
typedef long long ll;
const ll maxn=100005;
ll dp[maxn],val[maxn];
ll gcd(int a,int b)
{
return b==0?a:gcd(b,a%b);
}
int main()
{
int n;
cin>>n;
ll G;
for(int i=1;i<=n;i++)
{
scanf("%lld",&val[i]);
if(i==1) G=val[i];
else
{
G=gcd(G,val[i]);
}
}
dp[0]=1;
for(int i=1;i<=n;i++)
{
for(ll j=val[i];j<maxn;j++)
{
if(dp[j-val[i]]) dp[j]=1;
}
}
ll ans=0;
if(G!=1)
cout<<"INF"<<endl;
else
{
for(int i=1;i<maxn;i++)
{
if(dp[i]==0) ans++;
}
cout<<ans<<endl;
}
return 0;
}
第九题：
标题： 分巧克力
儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。
为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：
1. 形状是正方形，边长是整数
2. 大小相同
例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。
当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？
输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
输入保证每位小朋友至少能获得一块1x1的巧克力。
输出
输出切出的正方形巧克力最大可能的边长。
样例输入：
2 10
6 5
5 6
样例输出：
2
经典二分
#include <iostream>
#include <cstring>
using namespace std;
const int N = 1e5 + 10;
typedef long long LL;
int n;
LL k, a[N], b[N];
int main()
{
scanf("%d%lld", &n, &k);
for(int i = 0; i < n; i ++ )
{
scanf("%lld%lld", &a[i], &b[i]);
}
int l = 1, r = 100000;
int ans = 0;
while(l <= r)
{
int mid=(r + l) / 2;
int m = 0;
for(int i = 0; i < n; i ++ )
{
m += (a[i] / mid) * (b[i] / mid);
}
if(m >= k)
{
l = mid + 1;
ans = mid;
}
else r = mid - 1;
}
printf("%d\n", ans);
return 0;
}
第十题：
标题：油漆面积
X星球的一批考古机器人正在一片废墟上考古。
该区域的地面坚硬如石、平整如镜。
管理人员为方便，建立了标准的直角坐标系。
每个机器人都各有特长、身怀绝技。它们感兴趣的内容也不相同。
经过各种测量，每个机器人都会报告一个或多个矩形区域，作为优先考古的区域。
矩形的表示格式为(x1,y1,x2,y2)，代表矩形的两个对角点坐标。
为了醒目，总部要求对所有机器人选中的矩形区域涂黄色油漆。
小明并不需要当油漆工，只是他需要计算一下，一共要耗费多少油漆。
其实这也不难，只要算出所有矩形覆盖的区域一共有多大面积就可以了。
注意，各个矩形间可能重叠。
本题的输入为若干矩形，要求输出其覆盖的总面积。
输入格式：
第一行，一个整数n，表示有多少个矩形(1<=n<10000)
接下来的n行，每行有4个整数x1 y1 x2 y2，空格分开，表示矩形的两个对角顶点坐标。
(0<= x1,y1,x2,y2 <=10000)
输出格式：
一行一个整数，表示矩形覆盖的总面积。
例如，
输入：
3
1 5 10 10
3 1 20 20
2 7 15 17
程序应该输出：
340
再例如，
输入：
3
5 2 10 6
2 7 12 10
8 1 15 15
程序应该输出：
128
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms
#include <iostream>
#include <cstdio>
using namespace std;
bool a[10005][10005];//记录一个点是否被油漆涂过
int sum;
void paint(int x1,int y1,int x2,int y2)
{
for(int i=x1;i<x2;i++)
{
for(int j=y1;j<y2;j++)
{
a[i][j]=1;//涂上颜色
}
}
}
int main()
{
int n;
cin>>n;
for(int i=0;i<n;i++)
{
int x1,x2,y1,y2;
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
paint(x1,y1,x2,y2);
}
for(int i=0;i<10005;i++)
{
for(int j=0;j<10005;j++)
{
if(a[i][j])
sum++;//面积增加
}
}
printf("%d\n",sum);
return 0;
}