[LintCode] 611 Knight Shortest Path 解题报告

Description
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.

Notice
source and destination must be empty.
Knight can not enter the barrier.


Clarification
If the knight is at (x, y), he can get to the following positions in one step:

(x + 1, y + 2)
(x + 1, y - 2)
(x - 1, y + 2)
(x - 1, y - 2)
(x + 2, y + 1)
(x + 2, y - 1)
(x - 2, y + 1)
(x - 2, y - 1)


Example
[[0,0,0],
 [0,0,0],
 [0,0,0]]
source = [2, 0] destination = [2, 2] return 2

[[0,1,0],
 [0,0,0],
 [0,0,0]]
source = [2, 0] destination = [2, 2] return 6

[[0,1,0],
 [0,0,1],
 [0,0,0]]
source = [2, 0] destination = [2, 2] return -1

5/13/2017

算法班，未经验证

/**
 * 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) {
        // Write your code here
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return -1;
        }
        if (grid[destination.x][destination.y] == 1 || grid[source.x][source.y] == 1) {
            return -1;
        }
        int[] xDirection = new int[]{1, 1, -1, -1, 2, 2, -2, -2};
        int[] yDirection = new int[]{2, -2, 2, -2, 1, -1, 1, -1};

        Queue<Point> queue = new LinkedList<Point>();

        boolean[][] visited = new boolean[grid.length][grid[0].length];
        int count = 0;

        queue.offer(source);

        while (!queue.isEmpty()) {
            Point p = queue.poll();
            if (p.x == destination.x && p.y == destination.y) return count;

            if (visited[p.x][p.y] || grid[p.x][p.y]) continue;
            visited[p.x][p.y] = true;

            for (int i = 0; i < xDirection.length; i++) {
                int tmpX = p.x + xDirection[i];
                int tmpY = p.y + yDirection[i];
                if (!outOfBoundary(tmpX, tmpY, grid.length, grid[0].length)) {
                    queue.offer(new Pont(tmpX, tmpY));
                }
            }
            count++;
        }
        return -1;
    }
    private boolean outOfBoundary(int x, int y, int xLength, int yLength) {
        if (x >= xLength || x < 0 || y >= yLength || y < 0) return true;
        return false;
    }
}