第八届蓝桥杯省赛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理解不够透彻，只会一些比较典型的题目，稍加变形就想不出来。知识面不够逛，后多算法自己根本就没想到，还得继续努力
