2019年第十届蓝桥杯省赛真题 迷宫 Java

最新推荐文章于 2023-01-25 11:07:11 发布
最新推荐文章于 2023-01-25 11:07:11 发布
阅读量314 收藏 1
点赞数 2
文章标签： 蓝桥杯 java bfs 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21551773/article/details/123699839
版权
本文介绍了一种使用广度优先搜索（BFS）算法解决复杂迷宫问题的方法，相比于深度优先搜索（DFS），BFS在处理大型迷宫时能更快找到最短路径。在给定的迷宫实例中，BFS成功找到了步数最少的解决方案，并通过字典序排序给出了最优路径。此外，文章还对比了DFS和BFS在解决此类问题上的性能差异。
摘要由CSDN通过智能技术生成

迷宫
题目描述
下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可以通行的地方。
010000
000100
001001
110000
迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这个它的上、下、左、右四个方向之一。对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫，一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。

对于下面这个更复杂的迷宫（30 行 50 列） ，请找出一种通过迷宫的方式，其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。

请注意在字典序中D<L<R<U。（如果你把以下文字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 maze.txt，内容与下面的文本相同）

01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000

分析：这种题一般为搜索题，可以用BFS（广度优先搜索）和DFS（深度优先搜索算法）

解法一：DFS（超时了，看个乐呵）

package labyrinth;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * 迷宫问题（dfs超时）
 * 
 * @author zmz
 *
 */
public class Labyrinth1 {
	static int[][] f = { { 1, 0 }, { -1, 0 }, { 0, -1 }, { 0, 1 } }; // 每个位置走的四个方向
	static char[] ch = { 'D', 'U', 'L', 'R' }; // 记录走的方向
	static int res = Integer.MAX_VALUE;
	static int[][] arr = {
			{0,1,0,0,0,0},
			{0,0,0,1,0,0},
			{0,0,1,0,0,1},
			{1,1,0,0,0,0}	   
	};

	static boolean[][] flag = new boolean[arr.length][arr[0].length]; // 标记该位置是否已经走过
	static StringBuilder sb = new StringBuilder();
	static List<String> dict = new ArrayList<>();

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = null;
		try {
			scanner = new Scanner(System.in);
			dfs(0, 0, 0);
			System.out.println("步数为 " + res);

			// 根据字典序排序
			dict.sort((o1, o2) -> {
				if (o1.length() == o2.length()) {
					char[] c1 = o1.toCharArray();
					char[] c2 = o2.toCharArray();

					for (int i = 0; i < o1.length(); i++) {
						if (c1[i] > c2[i])
							return 1;
						if (c1[i] < c2[i])
							return -1;
					}
				}
				return o1.length() - o2.length();
			});

			System.out.println(dict);
			System.out.println(dict.get(0));
		} finally {
			if (scanner != null) {
				scanner.close();
			}
		}
	}

	/**
	 * 
	 * @param x    当前在数组中的第 x 行
	 * @param y    当前在数组中的第 y 列
	 * @param step 步数
	 */
	private static void dfs(int x, int y, int step) {
		if (x == arr.length - 1 && y == arr[0].length - 1) {
			res = Math.min(res, step);
			dict.add(sb.toString()); // 将结果存到字典
			return;
		}

		for (int i = 0; i < f.length; i++) {
			int newX = x + f[i][0];
			int newY = y + f[i][1];
			if (newX >= 0 && newX < arr.length && newY >= 0 && newY < arr[0].length && arr[newX][newY] != 1
					&& !flag[newX][newY]) { // 这步走得通
				flag[newX][newY] = true;
				sb.append(ch[i]);
				dfs(newX, newY, step + 1);
				flag[newX][newY] = false;
				sb.deleteCharAt(step);
			}
		}
	}
}

只有小数据量能过
输出结果：
在这里插入图片描述

解法二：BFS（秒出结果）

package labyrinth;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Stack;

public class Labyrinth2 {

	static int[][] arr = {
			{0,1,0,1,0,1,0,1,0,0,1,0,1,1,0,0,1,0,0,1,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0},
			{0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1,0,1,0,0,1,0,1},
			{0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0},
			{0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,0,0,1,0,1,1},
			{0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0},
			{1,1,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,1,0,1,0,1,1,0,0,0,1,1,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,0,1,1,1},
			{0,0,0,1,1,0,1,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,1,0,0,0,0,0,0,0},
			{1,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0},
			{0,0,1,1,1,0,0,0,0,0,1,0,1,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,0,0,0,0,1,0,0,1},
			{1,1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0,0,1,0,0,0,1,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0},
			{0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,0,1,0,1},
			{1,1,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0},
			{0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,1,1,0,0,1,1,1,1,0,1,0,0,0,1,1,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,1,1},
			{1,0,1,0,1,0,1,0,0,1,1,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,1,1,0,0,1,1,1,1,0,1,1,0,1,0,0,0,0,1,0,0,0},
			{1,0,1,0,1,0,1,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,1,1,0,1,1,1,0,1,0,0,1},
			{1,0,0,0,0,0,0,0,1,0,1,1,0,0,0,1,0,0,0,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0},
			{1,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,1,1,1,1,0,1,0,1,0,0,1},
			{0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,0,1,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,1,0,1,1,0,1,1,1,0,0,0,0,1,1,0,1,0,1},
			{1,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,1,0},
			{0,0,0,0,1,0,0,0,1,1,0,0,0,0,1,1,0,1,0,1,1,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1},
			{1,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,0,0,0,0,1},
			{0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1},
			{1,0,1,0,0,0,0,1,0,0,0,1,1,0,0,1,0,0,0,1,0,0,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,0,1,0},
			{0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0},
			{1,1,0,1,0,0,0,0,0,0,1,0,0,1,1,1,0,1,1,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,0,0,1,0,1,1,0,1,1,1,0,1,0,0,0},
			{0,0,0,0,0,1,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0,0,0,0,0,0,1,1,0,0,1,1},
			{1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,1,0,0,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0},
			{1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,1,0,1,1,1,0,1,0,0,0},
			{0,0,1,1,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1},
			{1,0,0,0,0,0,0,1,1,0,0,1,1,1,0,1,0,1,1,1,0,1,0,0,0,1,0,0,0,1,1,0,1,1,1,0,1,0,1,0,1,1,0,1,1,1,1,0,0,0}
	};

	static int a = arr.length;
	static int b = arr[0].length;
	static int[][] f = { { 1, 0 }, { -1, 0 }, { 0, -1 }, { 0, 1 } };
	static char[] ch = { 'D', 'U', 'L', 'R' }; // 正常顺序
	static int res = Integer.MAX_VALUE;
	static boolean[][] flag = new boolean[a][b];
	static Pose[][] pF = new Pose[a][b];

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Deque<Pose> deque = new ArrayDeque<>();
		Stack<Character> stack = new Stack<>();
		Pose pose = new Pose(0, 0, 0, 'O'); // 原点
		deque.add(pose);
		flag[0][0] = true;
		pF[0][0] = pose;

		while (!deque.isEmpty()) {
			Pose pop = deque.pop();
			for (int i = 0; i < 4; i++) {
				int newX = pop.x + f[i][0];
				int newY = pop.y + f[i][1];
				if (newX >= 0 && newX < a && newY >= 0 && newY < b && !flag[newX][newY] && arr[newX][newY] != 1) {
					// 可行点
					Pose p = new Pose(newX, newY, pop.step + 1, ch[i]);
					pF[newX][newY] = p;
					flag[newX][newY] = true;
					deque.add(p);
				}
			}
		}

		/*
		 * 输出地图全貌，位置值的含义为上一个点是从哪个方向过来该位置的
		 */
		for (Pose[] i : pF) {
			for (int j = 0; j < i.length; j++) {
				if (i[j] != null) {
					System.out.print(i[j].lastP);
				} else {
					System.out.print(" ");
				}
			}
			System.out.println();
		}

		// 倒退回去，用栈保存
		a = a - 1;
		b = b - 1;
		stack.push(pF[a][b].lastP);
		while (a != 0 || b != 0) { // 求路径
			switch (pF[a][b].lastP) {
			case 'D':
				a -= 1; // 上一个节点向下走到该位置， 要回到上一个节点， 从该位置向上走
				stack.push(pF[a][b].lastP);
				break;
			case 'U':
				a += 1;
				stack.push(pF[a][b].lastP);
				break;
			case 'L':
				b += 1;
				stack.push(pF[a][b].lastP);
				break;
			case 'R':
				b -= 1;
				stack.push(pF[a][b].lastP);
				break;
			}

		}
		stack.pop(); // 去掉原点
		while (!stack.isEmpty()) {
			System.out.print(stack.pop());
		}
	}

}

class Pose {
	int x; // 位置的横坐标
	int y; // 位置的纵坐标
	int step; // 从原点到该位置的最小距离
	char lastP; // 上一个点到该点的方向

	public Pose() {
	}

	public Pose(int x, int y, int step, char lastP) {
		this.x = x;
		this.y = y;
		this.step = step;
		this.lastP = lastP;
	}
}

输出结果（太多了，放不下）
在这里插入图片描述
用Excel试了一下，路径是这样子的
在这里插入图片描述

大家都有一个铭治
关注
第十届蓝桥杯省赛C++B组 迷宫
ryo_218的博客
03-26 5744
试题 E：迷宫 本题总分：15 分 【问题描述】 下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRD...
蓝桥杯【2019】迷宫 java
weixin_43384365的博客
03-27 177
package javaa; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; public class mg { public static int han = 30; public static int lie = 50; public static int tongdao = 0; public static int zhangai = 1; public static int[.
2019第十届蓝桥杯省赛真题（JavaB组题解）
God_stf的博客
03-07 1875
2019第十届蓝桥杯省赛真题（JavaB组题解）试题 A: 组队试题 B: 不同子串试题 C: 数列求值试题 D: 数的分解试题 E: 迷宫试题 F: 特别数的和试题 G: 外卖店优先级试题 H: 人物相关性分析试题 I: 后缀表达式试题 J: 灵能传输 题解逐步更新中 试题 A: 组队 本题总分：5 分 【问题描述】 作为篮球队教练，你需要从以下名单中选出 1 号位至 5 号位各一名球员， 组成球队的首发阵容。 每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1 号位至 5 号位的
蓝桥杯2019年第十届JavaB组真题题目+解析+代码+答案：5.迷宫
CSDN 精品推荐
12-03 2431
不要自卑，去提升实力 互联网行业谁技术牛谁是爹 如果文章可以带给你能量，那是最好的事！请相信自己 加油o~ 点击下面链接 蓝桥杯历届真题题目+解析+代码+答案（2013-2020）（JavaA、B、C组） 题目描述： 下图给出了一个迷宫的平面图，其中标记为1的是障碍，0的是可以通行的地方 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDD..
迷宫蓝桥杯省赛填空题（不过被老师改成了编程大题）
weixin_45653543的博客
11-12 1082
迷宫 下图给出了一个迷宫的平面图，其中标记为1的为障碍，标记为0的为可以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR的顺序通过迷宫，一共 10 步。 其中 D、 U、 L、 R 分别表示向下、向上、向左、向右走。 对于一个n行m列的迷宫（n≤30,m≤50），请找出一种通过迷宫的方式，其使用的步数最少，在步数最少的前提下，请找出
2019年4月1日蓝桥杯省赛第十届蓝桥杯真题JAVA(C组)
12-18
2019年4月1日蓝桥杯省赛第十届蓝桥杯真题JAVA(C组)
2019第十届蓝桥杯省赛真题.zip
03-18
2019年的第十届蓝桥杯省赛真题是参赛者们准备比赛的重要参考资料，它包含了当年比赛的各类题目，涵盖了C/C++程序设计、Java软件开发等多个方向。 在这一压缩包文件中，"2019第十届蓝桥杯省赛真题"可能包含了多份...
2019第十届蓝桥杯省赛真题 试题 E: 迷宫 配套资源 maze.txt
03-07
2019第十届蓝桥杯省赛真题 试题 E: 迷宫 配套资源 maze.txt
2019年4月1日蓝桥杯省赛第十届蓝桥杯真题JAVA(G组)
12-18
【标题】"2019年4月1日蓝桥杯省赛第十届蓝桥杯真题JAVA(G组)"指的是2019年度第十届蓝桥杯程序设计竞赛的省级比赛，该比赛针对Java编程语言组别的一系列真题。蓝桥杯是一项全国性的IT技能竞赛，旨在检验参赛者的编程...
2019年第十届蓝桥杯C/C++大学B组省赛真题
03-25
【2019年第十届蓝桥杯C/C++大学B组省赛真题】是针对计算机科学领域的一项重要竞赛，旨在检验参赛者的C/C++编程能力以及算法设计与实现水平。蓝桥杯赛事通常包括预赛、复赛和决赛等阶段，其试题覆盖了从基础编程到...
2019第十届蓝桥杯省赛--迷宫
weixin_43364551的博客
10-13 443
题目 【问题描述】 下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式， 其使用的步数最少，在
[蓝桥杯2017初赛]迷宫
SakuraZhangrx的博客
06-23 1117
X星球的一处迷宫游乐场建在某个小山坡上。它是由10x10相互连通的小房间组成的。 房间的地板上写着一个很大的字母。我们假设玩家是面朝上坡的方向站立，则： L表示走到左边的房间，R表示走到右边的房间，U表示走到上坡方向的房间，D表示走到下坡方向的房间。 X星球的居民有点懒，不愿意费力思考。他们更喜欢玩运气类的游戏。这个游戏也是如此！ 开始的时候，直升机把100名玩家放入一个个小房间内。玩家一定要按照地上的字母移动。 迷宫地图如下： UDDLUULRUL UURLLLRRRU RRUURLDLRD RUDDDD
蓝桥杯迷宫问题(Java实现)
weixin_63187753的博客
04-04 1306
因为最近有蓝桥杯考试，但我对于BFS还不是很熟悉。特意这里写文，记录我学习写蓝桥真题 迷宫问题的过程。 第一步将这么大又臭又长的字符串转为数组存储就吓到我了，原来只需要把字符连接起来，然后arr[i][j] = string.charAt(i*50+j) 就可以了 package forlanqiao19; import java.util.Deque; import java.util.LinkedList; import java.util.Queue; public class Main
P1605 迷宫(C++_DFS_回溯)
ccql's Blog
01-21 323
题目背景 给定一个N*M方格的迷宫，迷宫里有T处障碍，障碍处不可通过。给定起点坐标和终点坐标，问: 每个方格最多经过1次，有多少种从起点坐标到终点坐标的方案。在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。 题目描述 无 输入格式 第一行N、M和T，N为行，M为列，T为障碍总数。第二行起点坐标SX,SY，终点坐标FX,FY。接下来T行，每行为障碍点的坐标。 输出格式 ...
蓝桥杯备赛---------迷宫dfs（学习笔记）
最新发布
giegie0506的博客
01-25 224
下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可以通行的地方。迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。对于上面的迷宫，从入口开始，可以按DRRURRDDDR的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式，其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。请注意在字典序中 D
2019年第十届蓝桥杯省赛B组真题：迷宫
Lily的博客
04-10 412
#include<stdio.h> #include<string.h> #include<stdlib.h> #include<math.h> #include<queue> #include<algorithm> using namespace std; int to[4][2]= {1,0,0,-1,0,1,-1,0}; char m[40][60]; int sx,sy; int book[40][60]; struct not
第十届蓝桥杯--迷宫
shan1956的博客
03-04 282
第十届蓝桥杯 ——迷宫_六级不考550+不改名-CSDN博客https://blog.csdn.net/weixin_46239370/article/details/105763944代码： #include <iostream> #include <cstring> #include <queue> using namespace std; typedef pair<int, int> PII; char g[30][50]; int dist[3
2019年第十一届蓝桥杯省赛JavaB组第E题——“迷宫“题目及解析
imreal_的博客
03-02 729
原文件内容： 01010101001011001001010110010110100100001000101010 00001000100000101010010000100000001001100110100101 01111011010010001000001101001011100011000000010000 01000000001010100011010000101000001010101011001011 00011111000000101000010010100010100000101..
蓝桥杯省赛真题：程序设计与结果填空
"蓝桥杯省赛真题包括Java大学B组的竞赛题目，主要涉及程序设计和结果填空两类题型。考生需通过浏览器提交答案，程序设计题要求程序能处理不同输入数据并得到正确输出，源码主类名为Main。试题包括组队问题、不同子串...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值