Walls and Gates

You are given a m x n 2D grid initialized with these three possible values.

-1 - A wall or an obstacle. 0 - A gate. INF - Infinity means an empty room. We use the value 2^31 - 1 = 2147483647 to represent INF as you may assume that the distance to a gate is less than 2147483647. Fill each empty room with the distance to its nearest gate. If it is impossible to reach a Gate, that room should remain filled with INF

Example

Example1

Input:
[[2147483647,-1,0,2147483647],[2147483647,2147483647,2147483647,-1],[2147483647,-1,2147483647,-1],[0,-1,2147483647,2147483647]]
Output:
[[3,-1,0,1],[2,2,1,-1],[1,-1,2,-1],[0,-1,3,4]]

Explanation:
the 2D grid is:
INF  -1  0  INF
INF INF INF  -1
INF  -1 INF  -1
  0  -1 INF INF
the answer is:
  3  -1   0   1
  2   2   1  -1
  1  -1   2  -1
  0  -1   3   4

Example2

Input:
[[0,-1],[2147483647,2147483647]]
Output:
[[0,-1],[1,2]]

public class Solution {
    public void wallsAndGates(int[][] rooms) {
        Queue<int[]> q = new LinkedList<>();
        for (int i = 0; i < rooms.length; i++) {
            for (int j = 0; j < rooms[i].length; j++) {
                if (rooms[i][j] == 0)
                    q.add(new int[] { i, j });
            }
        }
        int[][] dir = { { 0, 1 }, { -1, 0 }, { 1, 0 }, { 0, -1 } };
        int dist = 1;
        while (q.size() != 0) {
            int size = q.size();
            while (size-- > 0) {
                int[] node = q.poll();
                for (int i = 0; i < 4; i++) {
                    int newX = node[0] + dir[i][0];
                    int newY = node[1] + dir[i][1];
                    if (newX >= 0 && newX < rooms.length && newY >= 0 && newY < rooms[newX].length && rooms[newX][newY] == Integer.MAX_VALUE) {
                        rooms[newX][newY] = dist;
                        q.add(new int[] { newX, newY });
                    }
                }
            }
            dist++;
        }
    }
}