【Lintcode】663. Walls and Gates

题目地址：

https://www.lintcode.com/problem/walls-and-gates/description

给定一个二维矩阵，里面的$0$代表门，$-1$代表障碍物，$INF$代表空房间，要求修改原矩阵，使得每个位置代表该位置走到离它最近的门所需步数（每一步只能走四个方向并且不能走到障碍物上）。障碍物所在位置不需要修改，如果某个位置走不到门上，则维持其等于$INF$。

思路是BFS。先将所有等于$0$的位置入队，然后向外扩张，逐次更新每个点到$0$的最短距离。代码如下：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Solution {
    /**
     * @param rooms: m x n 2D grid
     * @return: nothing
     */
    public void wallsAndGates(int[][] rooms) {
        // write your code here
        if (rooms == null || rooms.length == 0 || rooms[0].length == 0) {
            return;
        }
        
        Queue<int[]> queue = new LinkedList<>();
        // 先将所有等于0的位置入队
        for (int i = 0; i < rooms.length; i++) {
            for (int j = 0; j < rooms[0].length; j++) {
                if (rooms[i][j] == 0) {
                    queue.offer(new int[]{i, j});
                }
            }
        }
        
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int x = cur[0], y = cur[1];
            // 取出相邻的非-1非0的点
            for (int[] next : getNexts(x, y, rooms)) {
                int nextX = next[0], nextY = next[1];
                // 如果从当前位置到这个位置距离更短，则更新之，并将其入队以便更新别的点
                if (rooms[nextX][nextY] > rooms[x][y] + 1) {
                    rooms[nextX][nextY] = rooms[x][y] + 1;
                    queue.offer(new int[]{nextX, nextY});
                }
            }
        }
    }
    
    private List<int[]> getNexts(int x, int y, int[][] rooms) {
        List<int[]> nexts = new ArrayList<>();
        int[] d = {0, 1, 0, -1, 0};
        for (int i = 0; i < 4; i++) {
            int nextX = x + d[i], nextY = y + d[i + 1];
            if (inBound(nextX, nextY, rooms) && rooms[nextX][nextY] != 0 && rooms[nextX][nextY] != -1) {
                nexts.add(new int[]{nextX, nextY});
            }
        }
        
        return nexts;
    }
    
    private boolean inBound(int x, int y, int[][] rooms) {
        return 0 <= x && x < rooms.length && 0 <= y && y < rooms[0].length;
    }
}

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