华为机试 迷宫最短路径

最新推荐文章于 2025-04-14 08:40:21 发布
最新推荐文章于 2025-04-14 08:40:21 发布
阅读量1.8k 收藏 2
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012150590/article/details/52491833
版权
闯迷宫
 
描述:

sun所在学校每年都要举行电脑节，今年电脑节有一个新的趣味比赛项目叫做闯迷宫。

sun的室友在帮电脑节设计迷宫，所以室友就请sun帮忙计算下走出迷宫的最少步数。

知道了最少步数就可以辅助控制比赛难度以及去掉一些没有路径到达终点的map。

比赛规则是：从原点（0,0）开始走到终点（n-1,n-1），只能上下左右4个方向走，只能在给定的矩阵里走。

运行时间限制:10 Sec
内存限制:128 MByte
输入:

输入有多组数据。



每组数据输入n（0<n<=100），然后输入n*n的0、1矩阵，0代表该格子没有障碍，为1表示有障碍物。

注意：如果输入中的原点和终点为1则这个迷宫是不可达的。

输出:

对每组输入输出该迷宫的最短步数，若不能到达则输出-1。

样例输入: 
2
0 1
0 0
5
0 0 0 0 0
1 0 1 0 1
0 0 0 0 0
0 1 1 1 0
1 0 1 0 0
样例输出: 
2
8

BFS实现版：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

class Point{

	int x,y;
	public Point(int x,int y) {
		// TODO Auto-generated constructor stub
		this.x=x;
		this.y=y;

	}

}
public class Main {

	static final int unreachable=100000;     //代表从未走过
	static int dx[]={0,1,0,-1};              
	static int dy[]={1,0,-1,0};
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner in=new Scanner(System.in);
		while (in.hasNextInt()) {

			int n=in.nextInt();
			int m=n;
			int maze[][]=new int[n][n];
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					maze[i][j]=in.nextInt();
				}
			}
			
			
			
			if (maze[0][0]==1||maze[n-1][n-1]==1) {
				System.out.println(-1);
				continue;
			}
			
			int distance[][]=new int[n][n];
			initDistance(distance);
			distance[0][0]=0;
			int dis=bfs(maze,distance,n);
			if (dis==unreachable) {
				System.out.println(-1);
			}else {
				System.out.println(dis);
			}
			

		}
	}
	private static int bfs(int[][] maze, int[][] distance, int n) {
		// TODO Auto-generated method stub
		
		Queue<Point> q=new LinkedList<Point>();
		q.offer(new Point(0, 0));
		
		while (!q.isEmpty()) {
			Point front=q.poll();
			if (front.x==n-1&&front.y==n-1) {
				break;
			}
			
			for (int i = 0; i < 4; i++) {     //上下左右
				int px=front.x+dx[i];
				int py=front.y+dy[i];
				
				if (px>=0&&px<n&&py>=0&&py<n&&maze[px][py]!=1&&distance[px][py]==unreachable) {
					q.add(new Point(px, py));
					distance[px][py]=distance[front.x][front.y]+1;
				}
			}
		}
		return distance[n-1][n-1];
	}
	private static void initDistance(int[][] distance) {
		// TODO Auto-generated method stub
		for (int i = 0; i < distance.length; i++) {
			for (int j = 0; j < distance.length; j++) {
				distance[i][j]=unreachable;
			}
		}
		
	}

}

测试结果：



下面再给出DFS版本的解法

import java.util.Scanner;
import java.util.Stack;

class point{

	int x,y;
	public point(int x,int y) {
		// TODO Auto-generated constructor stub
		this.x=x;
		this.y=y;
	}

}
public class DFSMaze {
	static final int unreachable=100000;
	static int dx[]={0,1,0,-1};
	static int dy[]={1,0,-1,0};
	static int steps=-1;
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner in=new Scanner(System.in);
		while (in.hasNextInt()) {
			
			int n=in.nextInt();
			int m=n;
			int maze[][]=new int[n][n];
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					maze[i][j]=in.nextInt();
				}
			}
			
			if (maze[0][0]==1||maze[n-1][n-1]==1) {
				System.out.println(-1);
				continue;
			}
			boolean visit[][]=new boolean[n][n];
			
			Stack<point> stack=new Stack<point>();
			int dis=dfs (maze,n,stack,visit);
			
			System.out.println(dis);
			
		}
	}
	private static int dfs(int[][] maze, int n, Stack<point> stack, boolean[][] visit) {
		// TODO Auto-generated method stub
		
		 recursive(maze,n,stack,0,0,visit);
		 return steps;
	}
	private static void recursive(int[][] maze, int n, Stack<point> stack, int x, int y, boolean[][] visit) {
		// TODO Auto-generated method stub
		stack.push(new point(x, y));
		if (x==n-1&&y==n-1) {
			System.out.println("Start.......");
			for (point p : stack) {
				System.out.println("("+p.x+","+p.y+")");
			}
			System.out.println("End........");
			steps=stack.size()-1;
			return;
		}
		visit[x][y]=true;
		for (int i = 0; i <4; i++) {
			int px=x+dx[i];
			int py=y+dy[i];
			if (px>=0&&px<n&&py>=0&&py<n&&maze[px][py]!=1&&visit[px][py]==false) {
				recursive(maze, n, stack, px, py,visit);
			}
		}
		stack.pop();
		visit[x][y]=false;
		
	}

}

测试结果：



//以下通用版，S代表起始点，G代表出口

实现代码：

import java.util.LinkedList;  
import java.util.Queue;  
import java.util.concurrent.ConcurrentLinkedQueue;  
  
/** 
 * Created by yangjianzhou on 2014/8/18 21:36. 
 * TODO :给定一个大小为N*M的迷宫，迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四 
 * 格的通道移动。求从起点到终点所需的最小步数。 
 */  
public class Maze {  
  
    private static final int INF = 100000;  // 表示没有走过
    private static final int N = 10;  
    private static final int M = 10;  
    private static char[][] mazeMatrix = {  
            {'#', 'S', '#', '#', '#', '#', '#', '#', 'o', '#'},  
            {'o', 'o', 'o', 'o', 'o', 'o', '#', 'o', 'o', '#'},  
            {'o', '#', 'o', '#', '#', 'o', '#', '#', 'o', '#'},  
            {'o', '#', 'o', 'o', 'o', 'o', 'o', 'o', 'o', 'o'},  
            {'#', '#', 'o', '#', '#', 'o', '#', '#', '#', '#'},  
            {'o', 'o', 'o', 'o', '#', 'o', 'o', 'o', 'o', '#'},  
            {'#', '#', '#', '#', '#', '#', '#', '#', 'o', '#'},  
            {'o', 'o', 'o', '#', 'o', 'o', 'o', 'o', 'o', 'o'},  
            {'o', '#', '#', '#', '#', 'o', '#', '#', '#', 'o'},  
            {'o', 'o', 'o', 'o', '#', 'o', 'o', 'o', 'G', '#'}  
    };  
    ;  
    private static int xs = 0;  
    private static int ys = 1;  
    private static int xe = 9;  
    private static int ye = 8;  
    private static int[][] distance = new int[N][M];  
  
    private static int[] xd = {1, 0, -1, 0};  
    private static int[] yd = {0, 1, 0, -1};  
  
    public static void main(String[] args) {  
        initDistance();  
        Maze maze = new Maze();  
        int dis = maze.bfs();  
        System.out.println("shortest length is : " + dis);  
       printDistance();  
    }  
  
    private int bfs() {  
        Queue<Point> que = new ConcurrentLinkedQueue<Point>();  
        que.add(new Point(xs, ys));  
        distance[xs][ys] = 0;  
        while (que.size() > 0) {  
            Point point = que.poll();  
            if (point.getX() == xe && point.getY() == ye) {  
                break;  
            }  
            for (int i = 0; i < 4; i++) {  
                int xp = point.getX() + xd[i];  
                int yp = point.getY() + yd[i];  
                if (0 <= xp && xp < N && 0 <= yp && yp < M && mazeMatrix[xp][yp] != '#' && distance[xp][yp] == INF) {  
                    que.add(new Point(xp, yp));  
                    distance[xp][yp] = distance[point.getX()][point.getY()] + 1;  
                }  
            }  
        }  
        return distance[xe][ye];  
    }  
  
    private static void initDistance() {  
        for (int i = 0; i < N; i++) {  
            for (int j = 0; j < M; j++) {  
                distance[i][j] = INF;  
            }  
        }  
    }  
  
    private static void printDistance() {  
        for (int i = 0; i < N; i++) {  
            System.out.println();  
            for (int j = 0; j < M; j++) {  
                System.out.print("\t\t" + distance[i][j]);  
            }  
        }  
    }  
  
    class Point {  
        int x;  
        int y;  
  
        public Point(int x, int y) {  
            this.x = x;  
            this.y = y;  
        }  
  
        public int getX() {  
            return x;  
        }  
  
        public int getY() {  
            return y;  
        }  
  
        public void setX(int x) {  
            this.x = x;  
        }  
  
        public void setY(int y) {  
            this.y = y;  
        }  
    }  
}

测试结果：


华为OD机试2025B卷统一考试题库清单（持续收录中）以及考点说明
学Java，找哪吒
07-14 5万+
每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
华为OD机试|华为od题库|华为od机考|2025真题目录C++实现|C卷D卷E卷
热门推荐
u014481728的博客
02-18 7万+
华为OD机试|华为od题库|华为od机考|2025真题目录C++实现|C卷D卷E卷|华为OD机试|华为od题库|华为od机考|2025真题目录C++实现|C卷D卷E卷|华为OD机试|华为od题库|华为od机考|2025真题目录C++实现|C卷D卷E卷|华为OD机试|华为od题库|华为od机考|2025真题目录C++实现|C卷D卷E卷|华为OD机试|华为od题库|华为od机考|2025真题目录C++实现|C卷D卷E卷
迷宫的最短路径实现
06-15
实现迷宫的最短路径，利用递归和回溯实现深度搜索。
BFS (迷宫的最短路径)
LaoXiangQ的博客
10-02 5896
迷宫的最短路径 给定一个大小为N * M 的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四格的通道移动。请求出从起点到终点所需的最小步数。请注意，本题假定从起点一定可以移动到终点 。 限制条件： N ， M<=100 。（ # . S G 分别代表 墙壁、通道、起点和终点。） sample input 10 10 # S # # # ...
华为OD机试2025A卷统一考试题库清单（持续收录中）以及考点说明
最新发布
KJ.JK
04-14 4570
华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
迷宫最短路径
笃笃前行的专栏
10-13 408
Description 为了测试某种药物对小白鼠方向感的影响，生物学家在实验室做了一个矩形迷宫，入口和出口都确定为唯一的，且分布在矩形的不同边上。现在让你算出小白鼠最短需要走多少步，才可以从入口走到出口。 Input 共N+1行，第一行为N（N=0表示输入结束），以下N行N列0-1矩阵，1表示不能通过，0表示可以通过（左上角和右下角为0，即入口和出口），其中N。 O
华为笔试题：找迷宫的最短路径
jimeng224的博客
09-06 498
s=[int(i) for i in input().split()] print(s[0],s[1]) a=[] for i in range(s[0]): a.append([int(i) for i in input().split()]) used=[[0 for _ in range(s[1])] for _ in range(s[0])] res=[] def dfs(i,j,path): if i<0 or i>=s[0] or j<0 or j>=s[
迷宫的最短路径
SuperFeng
03-05 1480
题目来源 挑战程序设计竞赛（第二版） 语言 C/C++ 题目 迷宫的最短路径 描述 给定一个大小为 N * M 的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四格的通道移动。请求出从起点到终点所需要的最小步数。请注意，本题假定从起点一定可以移动到终点。 样例 输入： N=10，M=10（迷宫如下所示。'#', '.', 'S', 'G' 分别表示墙壁、通道、起点和终点...
华为OD机试C卷-- 迷宫问题（Java & JS & Python）
wbajsjhhhhh的博客
06-02 4131
定义一个二维数组 N*M ，如 5 × 5 数组下所示： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。入口点为[0,0],既第一格是可以走的路。 数据范围： 2≤n,m≤10 ， 输入的内容只包含 0≤val≤1。
华为OD机试真题整理合集
02-09
7. **图论问题**：最小生成树（Prim或Kruskal）、最短路径（Dijkstra或Floyd-Warshall）、拓扑排序等。这些问题经常出现在网络设计、任务调度等场景。 8. **递归与分治**：递归是解决复杂问题的一种有效手段，而...
【华为机试真题 Python实现】机器人走迷宫
05-07 6272
文章目录题目描述示例1：输入：输出：示例2：输入：输出：示例3：输入：输出：参考代码 该题出自2020年5月机试由“赫夫曼”提供，祝他早日上岸。 题目描述 机器人走一个迷宫,给出迷宫的 x*y 的迷宫并且迷宫中有障碍物,输入k表示障碍物有k个,并且会将障碍物的坐标挨个输入。 机器人从 0,0 的位置走到 x,y 的位置并且只能向 x,y 增加的方向走（即只能向左向下移动）,不能回退。 #表示可以走的方格, 0代表障碍, 机器人从 0,0 的位置只能向下或者向前走到出口。 其中会有不可达方格和陷阱方格.
迷宫-最短路径
chengxiang89228的博客
09-20 953
华为oj和剑指offer都有相关题型，但针对不同题型会有不同解法，有动态规划取最优解和广度、深度遍历的方法。 这里针对华为oj上的原题，以及16年华为大牛专场的笔试题。 所求的是地图中的最短路径，但并不是只有一条路径。 华为最早的oj题里是只有一条路径，那么用深度遍历是最快捷的。 但如果有多条路径，需要就最短路径。还是要用广度遍历。 深度遍历无法保证求得最优解。 #includ
Python 动态规划迷宫问题
09-02
动态规划是一种解决复杂问题的算法思想，它将原问题分解为多个子问题，并通过保存子问题的解来避免重复计算，从而实现高效的求解。在Python中，动态规划可以用来解决迷宫问题。 迷宫问题是指在一个迷宫中找到从起点到终点的路径。在动态规划的思想下，可以将迷宫看作一个二维的网格，其中每个网格可以是墙壁或者可以通过的空地。通过定义状态和状态转移方程，可以利用动态规划算法来找到最短路径或者所有可能的路径。 具体地说，可以使用一个二维数组来表示迷宫，其中每个元素代表一个网格的状态。然后，通过定义初始状态、状态转移方程和边界条件，可以逐步计算出所有网格的最优解，最终得到从起点到终点的最短路径或者所有可能的路径。 在解决迷宫问题时，可以利用递归或者迭代的方式进行求解。递归方式可以通过定义递归函数来实现，每次递归调用时，根据当前位置和当前状态，判断是否继续向下一步前进，并更新状态。迭代方式则可以使用动态规划的思想，通过迭代更新网格的状态，直到达到终点。 参考资料中提供了一份关于动态规划迷宫问题的python代码，你可以通过阅读该代码来了解具体的实现方法。同时，你也可以通过搜索其他相关资料来深入学习和了解动态规划在解决迷宫问题中的应用。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [动态规划(DP)的整理-Python描述](https://blog.csdn.net/MrLevo520/article/details/75676160)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *3* [Python解法华为OJ机试-迷宫问题](https://blog.csdn.net/qq_39802810/article/details/115522203)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值