Knight Shortest Path

最新推荐文章于 2022-04-25 01:07:05 发布

原创最新推荐文章于 2022-04-25 01:07:05 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

算法专栏收录该内容

46 篇文章

订阅专栏

本文介绍了一种算法，用于解决棋盘上骑士从源位置到目标位置的最短路径问题。通过广度优先搜索（BFS）遍历所有可能的移动方式，考虑障碍物的存在，并返回最短路径长度。

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

Given a knight in a chessboard (a binary matrix with 0 as empty and 1 as barrier) with a source position, find the shortest path to a destination position, return the length of the route.
Return -1 if knight can not reached.

/**
 * Definition for a point.
 * public class Point {
 *     publoc int x, y;
 *     public Point() { x = 0; y = 0; }
 *     public Point(int a, int b) { x = a; y = b; }
 * }
 */
public class Solution {
    /**
     * @param grid a chessboard included 0 (false) and 1 (true)
     * @param source, destination a point
     * @return the shortest path 
     */
    public int shortestPath(boolean[][] grid, Point source, Point destination) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return -1;
        }
        int n = grid.length;
        int m = grid[0].length;
        int[] directionX = {1, 1, -1, -1, 2, 2, -2, -2};
        int[] directionY = {2, -2, 2, -2, 1, -1, 1, -1};
        Queue<Point> queue = new LinkedList<>();
        queue.offer(source);
        int step = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            step++;
            for (int i = 0; i < size; i++) {
                Point point = queue.poll();
                for (int j = 0; j < 8; j++) {
                    Point adj = new Point(
                        point.x + directionX[j],
                        point.y + directionY[j]
                    );
                    if (inBound(adj.x, adj.y, grid)) {
                        if (adj.x == destination.x && adj.y == destination.y) {
                            return step;
                        }
                        //走过的点不能再走了，抹掉
                        grid[adj.x][adj.y] = true;
                        queue.offer(adj);
                    }
                }
            }
        }
        return -1;
    }
    private boolean inBound(int x, int y, boolean[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        return x >= 0 && x < n && y >= 0 && y < m && grid[x][y] == false;
    }
}