【Lintcode】1888. Shortest Path in Matrix

题目地址：

https://www.lintcode.com/problem/shortest-path-in-matrix/description

给定一个$0-1$矩阵$A$，规模是$m\times n$，$0$代表空地，$1$代表目的地（可能有多个），问从每个空地出发，每步只能上下左右走一步，走到与其最近的目的地的最短路的第一步是朝什么方向走的。上下左右四个方向分别用$2,3,4,5$四个数字来表示。要求返回一个矩阵$B$，$B[i][j]$表示从该位置按上述要求出发的方向对应的数字。如果从某个空地出发存在多个方向可以最少步数到达目的地，则按照上下左右的优先级优先填写。如果$A[i][j]=1$，则取$B[i][j]=1$。

思路是BFS。直接从空地开始搜比较难做，可能需要记录路径。由于这里是问第一步朝哪个方向走，所以可以考虑从目的地开始搜，同时更新每个空地的信息。每当走到一个空地的时候，如果是第一次到这个空地，就赋值一下方向；如果发现这个空地在同一层的BFS到过（可以记录步数，看到步数一样就知道是同一层BFS遇到的了），那就将方向更新为优先级更高的方向。为了节省空间，可以直接在原数组上操作。此外需要注意，从目的地向空地走的时候，方向是和空地到目的地相反的。代码如下:

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

public class Solution {
    /**
     * @param grid: the input matrix
     * @return: the new matrix
     */
    public int[][] shortestPath(int[][] grid) {
        // Write your code here
        int m = grid.length, n = grid[0].length;
        // 记录每个点到达目的地的最短步数
        int[][] steps = new int[m][n];
        
        Queue<int[]> queue = new LinkedList<>();
        // 先将所有的目的地坐标入队
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    queue.offer(new int[]{i, j});
                }
            }
        }
    
        int step = 0;
        // 方向是下左上右，但mark记录的应该是上右下左对应的数字
        int[] d = {1, 0, -1, 0, 1}, mark = {2, 5, 3, 4};
        while (!queue.isEmpty()) {
            step++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                int[] cur = queue.poll();
                for (int j = 0; j < 4; j++) {
                    int nextX = cur[0] + d[j], nextY = cur[1] + d[j + 1];
                    if (inBound(nextX, nextY, grid)) {
                    	// 第一次遇到空地，则赋值一下方向，并记录步数，将到达的位置入队继续BFS
                        if (grid[nextX][nextY] == 0) {
                            grid[nextX][nextY] = mark[j];
                            steps[nextX][nextY] = step;
                            
                            queue.offer(new int[]{nextX, nextY});
                        } else {
                        	// 如果同层BFS走到了相同位置，那么更新方向
                            if (steps[nextX][nextY] == step) {
                                grid[nextX][nextY] = Math.min(grid[nextX][nextY], mark[j]);
                            }
                        }
                    }
                }
            }
        }
        
        return grid;
    }
    
    private boolean inBound(int x, int y, int[][] grid) {
        return 0 <= x && x < grid.length && 0 <= y && y < grid[0].length;
    }
}

时空复杂度$O(mn)$。