第八届蓝桥杯省赛javaA组题解
1.标题:迷宫
X星球的一处迷宫游乐场建在某个小山坡上。
它是由10x10相互连通的小房间组成的。
房间的地板上写着一个很大的字母。
我们假设玩家是面朝上坡的方向站立,则:
L表示走到左边的房间,
R表示走到右边的房间,
U表示走到上坡方向的房间,
D表示走到下坡方向的房间。
X星球的居民有点懒,不愿意费力思考。
他们更喜欢玩运气类的游戏。这个游戏也是如此!
开始的时候,直升机把100名玩家放入一个个小房间内。
玩家一定要按照地上的字母移动。
迷宫地图如下:
UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR
请你计算一下,最后,有多少玩家会走出迷宫?
而不是在里边兜圈子。
请提交该整数,表示走出迷宫的玩家数目,不要填写任何多余的内容。
如果你还没明白游戏规则,可以参看一个简化的4x4迷宫的解说图:
p1.png
思路:
模拟上下左右,超出边界则走出迷宫。
判断是否困在里面?简单粗暴的方式是记录一下走了多少步,判断大于100则认为是困在里面了。
static int ans = 0;
public static void dfs(int x, int y, int step, char[][] m) {
if (x == 10 || y == 10 || x == -1 || y == -1) {
ans++;
return;
}
if (step > 100) {//在10x10 的地图内走了大于100步则认为是困住了
return;
}
switch (m[x][y]) {
case 'U':
dfs(x - 1, y, step + 1, m);
break;
case 'D':
dfs(x + 1, y, step + 1, m);
break;
case 'L':
dfs(x, y - 1, step + 1, m);
break;
case 'R':
dfs(x, y + 1, step + 1, m);
break;
}
}
public static void main(String[] args) {
String s = "UDDLUULRUL\n" +
"UURLLLRRRU\n" +
"RRUURLDLRD\n" +
"RUDDDDUUUU\n" +
"URUDLLRRUU\n" +
"DURLRLDLRL\n" +
"ULLURLLRDU\n" +
"RDLULLRDDD\n" +
"UUDDUDUDLL\n" +
"ULRDLUURRR";
String[] lines = s.split("\n");
char[][] matrix = new char[10][10];
int n = 0;
//储存到矩阵
for (String line :
lines) {
char[] chars = line.toCharArray();
for (int i = 0; i < 10; i++) {
matrix[n][i] = chars[i];
}
n++;
}
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
dfs(i, j, 0, matrix);
}
}
System.out.println(ans);
}
其实是可以使用vis矩阵判断是否走过该路径来是否困住了。
答案:31
2.标题:9数算式
观察如下的算式:
9213 x 85674 = 789314562
左边的乘数和被乘数正好用到了1~9的所有数字,每个1次。
而乘积恰好也是用到了1~9的所有数字,并且每个1次。
请你借助计算机的强大计算能力,找出满足如上要求的9数算式一共有多少个?
注意:
- 总数目包含题目给出的那个示例。
- 乘数和被乘数交换后作为同一方案来看待。
思路:
dfs
对乘数进行搜索,两数相乘,结果满足条件则结束,不需要对乘数和结果同时搜索。
题目也是没理解清楚 x的位置是不固定的
所以就是使用一个长度为10的数组,其中0表示x的位置。其中对0在第一和最后的情况进行排除。
最后把结果/2得到最终答案。
static boolean[] vis = new boolean[10];
static int[] factor = new int[10];
static int ans = 0;
public static boolean judge(int result) {
Set<Character> set = new HashSet<Character>();
char[] nums = String.valueOf(result).toCharArray();
if(nums.length!=9){
return false;
}
for (char num :
nums) {
if(num=='0'){
return false;
}
if (set.contains(num)) {
return false;
} else {
set.add(num);
}
}
return true;
}
public static void dfs(int cur) {
if (cur == 1 && factor[0] == 0) {
return;
}
if (cur == 10) {
if (factor[9] == 0) {
return;
}
int a;
int b;
int c;
String s_a = "";
int index = 0;
for (int i = 0; i < 10; i++) {
if (factor[i] == 0) {
index = i;
break;
}
s_a += String.valueOf(factor[i]);
}
a = Integer.parseInt(s_a);
String s_b = "";
for (int i = index + 1; i < 10; i++) {
s_b += String.valueOf(factor[i]);
}
b = Integer.parseInt(s_b);
int result = a * b;
if (judge(result)) {
ans++;
System.out.println(ans);
System.out.println(a + " " + b + " " + result);
return;
}
return;
}
for (int i = 0; i < 10; i++) {
if (!vis[i] && factor[cur] == -1) {
vis[i] = true;
factor[cur] = i;
dfs(cur + 1);
vis[i] = false;
factor[cur] = -1;
}
}
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
factor[i] = -1;
}
dfs(0);
System.out.println(ans / 2);
}
答案:1625
3.标题:魔方状态*
二阶魔方就是只有2层的魔方,只由8个小块组成。
如图p1.png所示。
小明很淘气,他只喜欢3种颜色,所有把家里的二阶魔方重新涂了颜色,如下:
前面:橙色
右面:绿色
上面:黄色
左面:绿色
下面:橙色
后面:黄色
请你计算一下,这样的魔方被打乱后,一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后,各个面的颜色都一致,则认为是同一状态。
请提交表示状态数的整数,不要填写任何多余内容或说明文字。
思路:
感觉有点小难,如何判断重复的情况,以及如何限定排列。
是太难了,我看答案都看不懂
4.标题:方格分割*
6x6的方格,沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如图:p1.png, p2.png, p3.png 就是可行的分割法。
试计算:
包括这3种分法在内,一共有多少种不同的分割方法。
注意:旋转对称的属于同一种分割法。
请提交该整数,不要填写任何多余的内容或说明文字。
思路:
不用分割的思想,而是用填数的思想
从左三列,右三列进行判断是否对称。
还需要进行判断是否为连通,是否能够按一条线进行分割?
答案:
我的解法
会出现不连通和无法剪开的情况。
static int[][] mat=new int[6][6];
static int ans=0;
static boolean[][] vis=new boolean[6][6];
static public boolean check(int[][] m){
for (int i = 0; i <3 ; i++) {
for (int j = 0; j <6 ; j++) {
if(m[i][j]==m[5-i][5-j]){
return false;
}
}
}
return true;
}
public static void dfs(int cur){
if(cur==18){
if(check(mat)){
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
System.out.print(mat[i][j] + " ");
}
System.out.println();
}
System.out.println();
ans++;
return;
}
return;
}
for (int i = 0; i <6 ; i++) {
for (int j = 0; j <6 ; j++) {
if(!vis[i][j]){
vis[i][j]=true;
mat[i][j]=1;
dfs(cur+1);
vis[i][j]=false;
mat[i][j]=0;
}
}
}
}
public static void main(String[] args) {
dfs(0);
System.out.println(ans);
}
参考答案:
所有分割线都过 中心对称点( 3,3 ) ,以(3,3)为起点,进行dfs枚举分割线,到达边界就 sum++ , 又因为旋转对称, sum/4。
static int[][] dir ={ {0,1} ,{0,-1},{-1,0},{1,0}};//方向 下,上,左,右
static boolean[][] vis=new boolean[7][7];//把方格看成带点 即7x7
static int sum ;
static void dfs( int x ,int y ){
if( x == 0 || x == 6 || y==0 || y ==6 ){
//到达边界
sum++;
return ;
}
for( int i=0;i<=3;i++ ){
//依次遍历下一个方向
int xx = x+dir[i][0];
int yy = y+dir[i][1];
if( xx >=0 && x<=6 && yy>=0 && yy <=6 && !vis[xx][yy]){
//在范围内,且未访问过
vis[xx][yy] =true;
vis[6-xx][6-yy] =true;//对称点
dfs(xx,yy);
vis[xx][yy] =false;
vis[6-xx][6-yy] =false;
}
}
}
public static void main(String[] args) {
vis[3][3] =true;
dfs(3,3);//从中心对称点,像四周搜索
int ans = sum/4;
System.out.println(ans);
}
5.标题:字母组串*
由 A,B,C 这3个字母就可以组成许多串。
比如:“A”,“AB”,“ABC”,“ABA”,“AACBB” …
现在,小明正在思考一个问题:
如果每个字母的个数有限定,能组成多少个已知长度的串呢?
他请好朋友来帮忙,很快得到了代码,
解决方案超级简单,然而最重要的部分却语焉不详。
请仔细分析源码,填写划线部分缺少的内容。
public class A
{
// a个A,b个B,c个C 字母,能组成多少个不同的长度为n的串。
static 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 ________________________________; //填空
}
public static void main(String[] args)
{
System.out.println(f(1,1,1,2));
System.out.println(f(1,2,3,3));
}
}
对于上面的测试数据,小明口算的结果应该是:
6
19
注意:只填写划线部分缺少的代码,不要提交任何多余内容或说明性文字。
思路:
之前没看清题目要求,题目的a,b,c分别指的是a个A,b个B和c个C字母。先简单推算,一个a,一个b和一个c字母组成长度为2的串(即f(1,1,1,2))可能性有:ab,ac,ba,bc,ca,cb六种。又可分为三种情况:1a1b组成长度为1的字符串(最后一个字符为c)(f(1,1,0,1)),1a1c组成的字符串(最后一个字符为b)(f(1,0,1,1)),1b1c组成的字符串(最后一个字符为a)(f(0,1,1,1))。便可得出需要填写的代码代码。
————————————————
版权声明:本文为CSDN博主「m0_38056893」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/m0_38056893/article/details/79659859
答案:
f(a-1,b,c,n-1)+f(a,b-1,c,n-1)+f(a,b,c-1,n-1);
6.标题:最大公共子串
最大公共子串长度问题就是:
求两个串的所有子串中能够匹配上的最大长度是多少。
比如:“abcdkkk” 和 “baabcdadabc”,
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的,这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路,并补全划线部分缺失的代码。
public class Main
{
static int f(String s1, String s2)
{
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
int[][] a = new int[c1.length+1][c2.length+1];
int max = 0;
for(int i=1; i<a.length; i++){
for(int j=1; j<a[i].length; j++){
if(c1[i-1]==c2[j-1]) {
a[i][j] = __________________; //填空
if(a[i][j] > max) max = a[i][j];
}
}
}
return max;
}
public static void main(String[] args){
int n = f("abcdkkk", "baabcdadabc");
System.out.println(n);
}
}
注意:只提交缺少的代码,不要提交已有的代码和符号。也不要提交说明性文字。
思路:
应该是动态规划法
创建了比s1,s2长度+1的矩阵,画出矩阵后就很好理解了,对矩阵进行遍历
答案:
a[i-1][j-1]+1
7.描述:正则问题*
考虑一种简单的正则表达式:
只由 x ( ) | 组成的正则表达式。
小明想求出这个正则表达式能接受的最长字符串的长度。
例如 ((xx|xxx)x|(x|xx))xx 能接受的最长字符串是: xxxxxx,长度是6。
输入
一个由x()|组成的正则表达式。输入长度不超过100,保证合法。
输出
这个正则表达式能接受的最长字符串的长度。
例如,
输入:
((xx|xxx)x|(x|xx))xx
程序应该输出:
6
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 1000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
思路:
初步来看应该是使用栈来解决
还是dfs,不要看到括号就想到字符串匹配
答案:
static int pos = 0;//当前的位置
static int len;//字符串长度
static char[] chars;//字符数组
static int dfs() {
int max = 0;
int cur = 0;
while (pos < len) {
if (chars[pos] == '(') {
//进入下一层搜索
pos++;
cur += dfs();
} else if (chars[pos] == '|') {
pos++;
//选出较大的一部分
if (cur > max) {
max = cur;
}
cur = 0;//cur归零
} else if (chars[pos] == ')') {
//一组匹配结束,退出遍历
pos++;
break;
} else {
//x 直接加一
pos++;
cur++;
}
}
if (cur > max) {
max = cur;
}
return max;
}
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
chars = s.next().toCharArray();
len = chars.length;
System.out.println(dfs());
}
8.标题:包子凑数*
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有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
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
提交程序时,注意选择所期望的语言类型和编译器类型。
思路:
- 如何判断无限个:扩展欧几里德变形定理:如果有的包子种类的最大公约数不是1 那么凑不出来的情况就有无限多种
- 完全背包
都是知识盲区
答案:
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();//蒸笼数
int a[] = new int[101];//每种蒸笼的容量
for (int i = 1; i <= n; i++) {
a[i] = sc.nextInt();
}
int gcd = a[1];
//保证所有数互质
for (int i = 2; i <= n; i++) {
gcd = GCD(gcd, a[i]);
}
if (gcd != 1) {
System.out.println("INF");
} else {
//所有数互质
boolean dp[] = new boolean[10000];
//为什么开到10000就够了
dp[0] = true;
for (int i = 1; i <= n; i++) {
for (int j = 0; j + a[i] <= 10000; j++) {
if (dp[j]) {
dp[j + a[i]] = true;
}
}
}
int sum = 0;
for (int i = 0; i <= 10000; i++) {
if (dp[i] == false) {
sum++;
}
}
System.out.println(sum);
}
}
private static int GCD(int x, int y) {
//递归求解最大公约数,辗转相除法
if (y == 0) {
return x;
} else {
return GCD(y, x % y);
}
}
9.标题: 分巧克力*
儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力,其中第i块是Hi x Wi的方格组成的长方形。
为了公平起见,小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足:
- 形状是正方形,边长是整数
- 大小相同
例如一块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
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
思路:
- 题目要求查找最大的变长,并且巧克力长宽都在100000内,想到使用二分搜索
- 对于如何计算,一块h x w巧克力能分成多少块小的lxl方形巧克力,那么(h/l)*(w/l)
答案:
public static boolean judge(int len) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += (heights[i] / len) * (weights[i] / len);
}
if (sum < k) {
//len过大
return false;
}
//len过小
return true;
}
static int n, k;
static int[] heights;
static int[] weights;
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
n = s.nextInt();//巧克力块数
k = s.nextInt();//小朋友数
heights = new int[n];
weights = new int[n];
for (int i = 0; i < n; i++) {
heights[i] = s.nextInt();
weights[i] = s.nextInt();
}
int low = 1;
int hight = 100000;
int mid = 0;
while (low <= hight) {
mid = (low + hight) / 2;
if (judge(mid)) {
//mid过小
low = mid + 1;
} else {
//mid过大
hight = mid - 1;
}
}
low++;
//递减搜索,即为最大
while (low != 0) {
low--;
if (judge(low)) {
break;
}
}
System.out.println(low);
}
10.标题:油漆面积*
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
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
思路:
线段树,扫描线的模版题,不会
答案:
总结
这套题答的不太好,没接触几道题,而且对dfs理解不够透彻,只会一些比较典型的题目,稍加变形就想不出来。知识面不够逛,后多算法自己根本就没想到,还得继续努力