题目1
标题：迷宫
X星球的一处迷宫游乐场建在某个小山坡上。
它是由10x10相互连通的小房间组成的。
房间的地板上写着一个很大的字母。
我们假设玩家是面朝上坡的方向站立，则：
L表示走到左边的房间，
R表示走到右边的房间，
U表示走到上坡方向的房间，
D表示走到下坡方向的房间。
X星球的居民有点懒，不愿意费力思考。
他们更喜欢玩运气类的游戏。这个游戏也是如此！
开始的时候，直升机把100名玩家放入一个个小房间内。
玩家一定要按照地上的字母移动。
迷宫地图如下：
UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR
请你计算一下，最后，有多少玩家会走出迷宫?
而不是在里边兜圈子。
31
请提交该整数，表示走出迷宫的玩家数目，不要填写任何多余的内容。
如果你还没明白游戏规则，可以参看一个简化的4x4迷宫的解说图：
p1.png
思路：深搜
#include<iostream>
#include<cstring>
using namespace std;
int n=10,vis[15][15];
char a[15][15];
bool dfs(int x,int y)
{
if(a[x][y]=='*') return true;
if(a[x][y]=='#') return false;
int dx,dy;
if(a[x][y]=='U')
{
dx=x-1,dy=y;
}
else if(a[x][y]=='R')
{
dx=x,dy=y+1;
}
else if(a[x][y]='D')
{
dx=x+1,dy=y;
}
else if(a[x][y]='L')
{
dx=x,dy=y-1;
}
if(vis[dx][dy]) //可能出现环
{
a[x][y]='#';
return false;
}
vis[dx][dy]=1;
if(dfs(dx,dy))
{
a[x][y]='*';
return true;
}
else
{
a[x][y]='#';
return false;
}
vis[dx][dy]=0;
}
int main()
{
for(int i=0;i<=n+1;i++)
for(int j=0;j<=n+1;j++) a[i][j]='*';
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++) cin>>a[i][j];
cout<<endl;
for(int i=0;i<=n+1;i++)
{
for(int j=0;j<=n+1;j++)
cout<<a[i][j];
cout<<endl;
}
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
memset(vis,0,sizeof vis);
vis[i][j]=1;
dfs(i,j);
}
int cnt=0;
cout<<endl;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(a[i][j]=='*') cnt++;
cout<<a[i][j];
}
cout<<endl;
}
cout<<"cnt="<<cnt<<endl;
return 0;
}
题目二
标题：跳蚱蜢
如图 p1.png 所示：
有9只盘子，排成1个圆圈。
其中8只盘子内装着8只蚱蜢，有一个是空盘。
我们把这些蚱蜢顺时针编号为 1~8
每只蚱蜢都可以跳到相邻的空盘中，
也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，
并且保持空盘的位置不变（也就是1-8换位，2-7换位,…），至少要经过多少次跳跃？
注意：要求提交的是一个整数，请不要填写任何多余内容或说明文字。
20
思路：广搜+判重
注意：每一种状态用string存储较为合适，整型数组操作很复杂
#include<iostream>
#include<set>
#include<string>
#include<queue>
using namespace std;
const int N=9;
int dx[]={-2,-1,1,2};
struct node{
int pos;
int step;
string str; //应该用字符串来存储而不是整型数组
}start;
queue<node>q;
set<string>s;
int bfs()
{
while(!q.empty())
{
int pos=q.front().pos,step=q.front().step;
string a=q.front().str;
q.pop();
if(a=="087654321") return step;
for(int i=0,pos2;i<4;i++)
{
string temp=a;
pos2=(pos+dx[i]+9)%9;
char t=temp[pos];
temp[pos]=temp[pos2];
temp[pos2]=t;
if(s.count(temp)==0)
{
s.insert(temp);
node tt={pos2,step+1,temp};
q.push(tt);
}
}
}
}
int main()
{
//for(int i=1;i<9;i++) a[i]=i;
node start={0,0,"012345678"};
s.insert(start.str);
q.push(start);
cout<<bfs();
return 0;
}
题目三
标题：魔方状态
二阶魔方就是只有2层的魔方，只由8个小块组成。
如图p1.png所示。
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
前面：橙色
右面：绿色
后面：黄色
左面：绿色
上面：黄色
下面：橙色
请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
请提交表示状态数的整数，不要填写任何多余内容或说明文字。
思路：在网上没有找到答案，所以也不知道自己做的对不对。按照前右后左上下的方向标记魔方的状态，并用string存储（原因同上）。
#include<iostream>
#include<string>
#include<set>
using namespace std;
set<string>s;
int a[9][25]=
{{0,13,14,3,4,1,2,7,8,5,6,11,12,9,10,15,16,17,18,19,20,21,22,23,24},{0,9,10,3,4,13,14,7,8,1,2,11,12,5,6,15,16,17,18,19,20,21,22,23,24}
,{0,5,6,3,4,9,10,7,8,13,14,11,12,1,2,15,16,17,18,19,20,21,22,23,24},{0,1,22,3,24,5,6,7,8,9,18,11,20,13,14,15,16,17,2,19,4,21,10,23,12}
,{0,1,10,3,12,5,6,7,8,9,2,11,4,13,14,15,16,17,22,19,24,21,18,23,20},{0,1,18,3,20,5,6,7,8,9,22,11,24,13,14,15,16,17,10,19,12,21,2,23,4}
,{0,1,2,3,4,5,22,7,21,9,10,11,12,13,18,15,17,6,8,19,20,14,16,23,24},{0,1,2,3,4,5,16,7,14,9,10,11,12,13,8,15,6,22,21,19,20,18,17,23,24}
,{0,1,2,3,4,5,17,7,18,9,10,11,12,13,21,15,22,16,14,19,20,8,6,23,24}}; //有9中旋转方式
void dfs(string x)
{
for(int i=0;i<9;i++)
{
string temp=x;
for(int j=1;j<25;j++)
{
temp[j]=x[a[i][j]];
}
if(s.find(temp)==s.end())
{
cout<<temp<<endl;
s.insert(temp);
dfs(temp);
}
}
}
int main()
{
string start="0000011112222111122220000";
s.insert(start);
dfs(start);
cout<<s.size()/24<<endl;
return 0;
}
题目四
标题：方格分割
6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如图：p1.png, p2.png, p3.png 就是可行的分割法。
试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。
请提交该整数，不要填写任何多余的内容或说明文字。
509
思路：找一条以（3,3）为中心的对称路线，即走一次标记两个点。
注意，由于旋转对称属于一种，所以最后结果要除以4
#include<iostream>
using namespace std;
const int N=8;
int n=6,vis[N][N],dx[]={-1,0,1,0},dy[]={0,1,0,-1},res=0;
void dfs(int x,int y)
{
if(x<=0 || x>=n || y<=0 || y>=n)
{
res++;
return;
}
for(int i=0;i<4;i++)
{
int nx=x+dx[i],ny=y+dy[i];
if(nx>=0 && nx<=n && ny>=0 && ny<=n && vis[nx][ny]==0)
{
vis[nx][ny]=1; //很巧妙，只需走的路线关于(3,3)中心对称
vis[n-nx][n-ny]=1;
dfs(nx,ny);
vis[nx][ny]=0;
vis[n-nx][n-ny]=0;
}
}
}
int main()
{
vis[3][3]=1;
dfs(3,3);
cout<<res/4<<endl;
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)
注意：这种一般都是dp问题，或者递归求解
题目六
标题：最大公共子串
最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。
比如：“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
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
思路：从第一个‘）’开始，一层一层将括号里的内容取出
#include<iostream>
#include<string>
#include<algorithm>
#include<cstring>
using namespace std;
int res=0;
void split(string s)
{
int posl,posr=s.find(')');
if(posr==s.npos)
{
int pos=s.find('|'),len=s.size();
if(pos==s.npos) res+=len;
else res=res+max(pos, len-pos-1);
}
else
{
posl=s.rfind('(',posr);
string temp=s.substr(0,posl)+s.substr(posr+1);
split(temp);
temp=s.substr(posl+1,posr-posl-1); //忘记去掉外层括号
split(temp);
}
}
int main()
{
string str;
cin>>str;
split(str);
cout<<res<<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
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
思路：借鉴某大神，若所有包子数的最大公约数>1,则无解；
否则枚举1~10000以内的数，看是否可以凑出->背包问题
#include<cstdio>
using namespace std;
const int N=110,M=10010;
//bool f[N][M];
bool f[M];
int a[N];
int gcd(int a, int b)
{
return b ? gcd(b, a % b) : a;
}
int main()
{
//for(int i=0;i<N;i++) f[i][0]=true;
f[0]=true;
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
int temp=a[1];
for(int i=2;i<=n;i++)
{
if(temp==1) break;
temp=gcd(temp,a[i]);
}
if(temp!=1)
{
printf("INF\n");
return 0;
}
/*for(int i=1;i<n;i++)
{
for(int j=1;j<M;j++)
{
f[i][j]=f[i-1][j];
if(j>=a[i]) f[i][j]=f[i][j] || f[i][j-a[i]];
}
}*/
for(int i=1;i<=n;i++)
for(int j=a[i];j<=10000;j++)
f[j]=f[j] || f[j-a[i]];
int res=0;
for(int i=0;i<=10000;i++)
{
if(f[i]==false) res++;
}
printf("%d\n",res);
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
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
思路：首先，最大边长小于等于所有矩形的最短边，然后二分求解
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=100010;
int n,k,w[N],h[N];
bool check(int x) // 检查x是否满足某种性质
{
int ans=0;
for(int i=0;i<n;i++)
{
ans+=(h[i]/x) * (w[i]/x);
}
if(ans>=k) return true;
return false;
}
// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
int bsearch_2(int l, int r)
{
while (l < r)
{
int mid = l + r + 1 >> 1;
printf("%d %d\n",l,r);
if (check(mid)) l = mid;
else r = mid - 1;
}
return l;
}
int main()
{
scanf("%d %d",&n,&k);
int r=0x3f3f3f3f;
for(int i=0;i<n;i++)
{
scanf("%d %d",&h[i],&w[i]);
r=min(r,min(h[i],w[i]));
}
printf("%d\n",bsearch_2(1,r));
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
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include
不能通过工程设置而省略常用头文件。
提交程序时，注意选择所期望的语言类型和编译器类型。
思路：扫描线法，但是我初学线段树，还不能理解如此高深的方法。还是不写了吧
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
