My code:

public class Solution {
    private int row = 0;
    private int col = 0;
    private int[][] dir = new int[][]{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    private class Pair {
        int x;
        int y;
        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    public void wallsAndGates(int[][] rooms) {
        if (rooms == null || rooms.length == 0 || rooms[0].length == 0) {
            return;
        }
        this.row = rooms.length;
        this.col = rooms[0].length;
        Queue<Pair> q = new LinkedList<Pair>();
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (rooms[i][j] == 0) {
                    q.offer(new Pair(i, j));
                }
            }
        }
        
        while (!q.isEmpty()) {
            Pair curr = q.poll();
            int curr_x = curr.x;
            int curr_y = curr.y;
            for (int k = 0; k < 4; k++) {
                int x = curr_x + dir[k][0];
                int y = curr_y + dir[k][1];
                if (check(x, y) && rooms[x][y] == Integer.MAX_VALUE) {
                    rooms[x][y] = 1 + rooms[curr_x][curr_y];
                    q.offer(new Pair(x, y));
                }
            }
        }
    }
    
    private boolean check(int i, int j) {
        if (i < 0 || i >= row || j < 0 || j >= col) {
            return false;
        }
        return true;
    }
}

一开始拿 DFS来做，发现 stack overflow.可能这道题目对stack要求比较严格。
然后拿BFS做，再次超时。。。
然后我才发现，原来我的BFS效率很低，是
Naive BFS

然后我自己写出了现在的 AC解法，论坛里别人称之为：
Multi-End BFS
为什么这么叫呢？我有自己的理解。
一般性的BFS，都是从一个点，一个end开始，BFS，一步步扩大。
但是这个里面，一开始队列里面有多个点，多个end

所以称作： Multi-End BFS

perfect

适用情况：
一定是，在外围，向内部渗透的时候，可以用到这种BFS
Surrounded Regions 也是如此。

然后Naive BFS 就不展示了。之前几道题目，BFS都超时。。
原来就是因为用了 naive bfs

dietpepsi 这篇文章写得挺不错的。
分析了

MultiEnd BFS,
Naive BFS,
DFS

reference:
https://discuss.leetcode.com/topic/35242/benchmarks-of-dfs-and-bfs

Anyway, Good luck, Richardo!