[LintCode] Knight Shortest Path II

Given a knight in a chessboard n * m (a binary matrix with 0 as empty and 1 as barrier). the knight initial position is (0, 0) and he wants to reach position (n - 1, m - 1). Find the shortest path to the destination position, return the length of the route. Return -1 if knight can not reached.

 

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 + 2, y + 1)
(x - 2, y + 1)

Example

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

Return 3

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

Return -1

 

Analysis: This problem is different with Knight Shortest Path in that the knight can only move from left to right, not vice versa. This change makes dynamic programming solution possible as current subproblem's result only depends on the results of subproblems that have been computed. 

 

Solution 1. BFS

Same with Knight Shortest Path solution with only 4 possible directions to move.

 

//Algorithm 1. BFS
class Point{
    protected int x;
    protected int y;
    public Point(int x, int y){
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    private int[] deltaX = {1, -1, 2, -2};
    private int[] deltaY = {2, 2, 1, 1};
    
    public int shortestPath2(boolean[][] grid) {
        if(grid == null || grid.length == 0 || grid[0].length == 0){
            return -1;
        }
        Queue<Point> queue = new LinkedList<Point>();
        queue.add(new Point(0, 0));
        grid[0][0] = true;
        int len = 0;
        
        while(queue.isEmpty() == false){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                Point curr = queue.poll();
                if(curr.x == grid.length - 1 && curr.y == grid[0].length - 1){
                    return len;
                }
                for(int dir = 0; dir < 4; dir++){
                    int nextX = curr.x + deltaX[dir];
                    int nextY = curr.y + deltaY[dir];
                    if(isDirectionValid(grid, nextX, nextY)){
                        queue.add(new Point(nextX, nextY));
                        grid[nextX][nextY] = true;
                    }    
                }
            }
            len++;
        }
        return -1;
    }
    private boolean isDirectionValid(boolean[][] grid, int x, int y){
        return !(x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y]);
    }
}

 

Solution 2. Top Down Dynamic Programming

State: f[i][j]: the minimum number of moves needed from (0, 0) to (i, j)

 

public class Solution {
    private int[] deltaX = {-1, 1, -2, 2};
    private int[] deltaY = {-2, -2, -1, -1};
    public int shortestPath2(boolean[][] grid) {
        if(grid == null || grid.length == 0 || grid[0].length == 0){
            return -1;
        }
        int n = grid.length;
        int m = grid[0].length;
        int[][] f = new int[n][m];
        
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                f[i][j] = Integer.MAX_VALUE;    
            }
        }
        
        f[0][0] = 0;
        
        for(int j = 0; j < m; j++){
            for(int i = 0; i < n; i++){
                if(grid[i][j] == false){
                    int min = Integer.MAX_VALUE;
                    for(int dir = 0; dir < 4; dir++){
                        int x = i + deltaX[dir];
                        int y = j + deltaY[dir];
                        if(isDirectionValid(grid, x, y)){
                            if(f[x][y] < min){
                                min = f[x][y];
                            }    
                        }
                    }
                    if(min < Integer.MAX_VALUE){
                        f[i][j] = 1 + min;
                    } 
                }

            }
        }
        return f[n - 1][m - 1] == Integer.MAX_VALUE ? -1 : f[n - 1][m - 1];
    }
    
    private boolean isDirectionValid(boolean[][] grid, int x, int y){
        return !(x < 0 || x >= grid.length || y < 0 || y >= grid[0].length);
    }
}

 

 

Related Problems

Knight Shortest Path