【笔试】Java实现计算在网格中从原点到特定点的最短路径长（BFS）

最新推荐文章于 2024-11-24 23:17:17 发布

原创最新推荐文章于 2024-11-24 23:17:17 发布 · 1.2k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#BFS #网格中最短距离

学习笔记专栏收录该内容

22 篇文章

订阅专栏

本文介绍了一种使用广度优先搜索(BFS)算法在二维网格中寻找从原点到指定点的最短路径的方法。通过队列和标记机制，算法能够有效地避免重复遍历并找到最短路径。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

计算在网格中从原点到特定点的最短路径长度

实现 BFS 时需要考虑以下问题：

队列：用来存储每一轮遍历得到的节点；
标记：对于遍历过的节点，应该将它标记，防止重复遍历。

	[[1,1,0,1],
	 [1,0,1,0],
	 [1,1,1,1],
	 [1,0,1,1]]

题目描述：1 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。

public class FindminPathLength{
	public static void main(String[] args) {
		int [][]grids= {{1,1,0,1},
						{1,0,1,0},
						{1,1,1,1},
						{1,0,1,1}};
		int res=minPathLength(grids, 4, 1);
		System.out.println(res);
	}
	public static int minPathLength(int[][] grids, int tr, int tc) {
	    final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
	    final int m = grids.length, n = grids[0].length;
	    Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
	    queue.add(new Pair<>(0, 0));
	    int pathLength = 0;
	    while (!queue.isEmpty()) {
	        int size = queue.size();
	        pathLength++;
	        while (size-- > 0) {
	            Pair<Integer, Integer> cur = queue.poll();
	            int cr = cur.getKey(), cc = cur.getValue();
	            grids[cr][cc] = 0; // 标记
	            for (int[] d : direction) {
	                int nr = cr + d[0], nc = cc + d[1];
	                if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 0) {
	                    continue;
	                }
	                if (nr == tr && nc == tc) {
	                    return pathLength;
	                }
	                queue.add(new Pair<>(nr, nc));
	            }
	        }
	    }
	    return -1;
	}
}
class Pair<K,V>{
	K key;
	V value;
	public Pair(K key,V value) {
		this.key=key;
		this.value=value;
	}	
	public int getKey() {
		return (int) this.key;
	}	
	public int getValue() {
		return (int) this.value;
	}
}