LeetCode Shortest Distance from All Buildings

原题链接在这里：https://leetcode.com/problems/shortest-distance-from-all-buildings/

题目：

You want to build a house on an empty land which reaches all buildings in the shortest amount of distance. You can only move up, down, left and right. You are given a 2D grid of values 0, 1 or 2, where:

• Each 0 marks an empty land which you can pass by freely.
• Each 1 marks a building which you cannot pass through.
• Each 2 marks an obstacle which you cannot pass through.

Example:

Input: [[1,0,2,0,1],[0,0,0,0,0],[0,0,1,0,0]]

1 - 0 - 2 - 0 - 1
|   |   |   |   |
0 - 0 - 0 - 0 - 0
|   |   |   |   |
0 - 0 - 1 - 0 - 0

Output: 7 

Explanation: Given three buildings at (0,0), (0,4), (2,2), and an obstacle at (0,2),
             the point (1,2) is an ideal empty land to build a house, as the total
             travel distance of 3+3+1=7 is minimal. So return 7.

Note:
There will be at least one building. If it is not possible to build such house according to the above rules, return -1.

题解：

从每一座building开始做BFS, 更新每个空地达到building的距离总和 以及 每个空地能到达building的个数.

第二次扫描grid, 若是空地并且它能到达的building数目是总共的building数目，就更新min距离.

Note: For the second iteration, check 2 conditions. grid[i][j] < 0 && reachCount[i][j] = totalCount.

Time Complexity: O(m^2 * n^2), 每次BFS用O(mn), 一共做了m*n次BFS.

Space: O(m*n)

AC Java:

 class Solution {
     public int shortestDistance(int[][] grid) {
         if(grid == null || grid.length == 0 || grid[0].length == 0){
             return 0;
         }

         int m = grid.length;
         int n = grid[0].length;

         //记录每个点能够到达building的个数
         int [][] reachCount = new int[m][n];
         int totalCount = 0;

         for(int i = 0; i<m; i++){
             for(int j = 0; j<n; j++){
                 if(grid[i][j] == 1){
                     //遇到building, 从这个building开始做bfs
                     totalCount++;
                     bfs(grid, i, j, reachCount);
                 }
             }
         }

         int res = Integer.MAX_VALUE;
         for(int i = 0; i<m; i++){
             for(int j = 0; j<n; j++){
                 if(grid[i][j] < 0 && reachCount[i][j] == totalCount){
                     res = Math.min(res, -grid[i][j]);
                 }
             }
         }

         return res == Integer.MAX_VALUE ? -1 : res;
     }

     int [][] dirs = new int[][]{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
     private void bfs(int [][] grid, int i, int j, int [][] reachCount){
         int level = 0;
         int m = grid.length;
         int n = grid[0].length;
         LinkedList<int []> que = new LinkedList<>();
         boolean[][] visited = new boolean[m][n];
         que.add(new int[]{i, j});
         visited[i][j] = true;

         while(!que.isEmpty()){
             int size = que.size();
             while(size-- > 0){
                 int [] cur = que.poll();
                 grid[cur[0]][cur[1]] -= level;
                 reachCount[cur[0]][cur[1]]++;

                 for(int [] dir : dirs){
                     int x = cur[0] + dir[0];
                     int y = cur[1] + dir[1];
                     if(x < 0 || x >=m || y < 0 || y >=n || visited[x][y] || grid[x][y] > 0){
                         continue;
                     }

                     que.add(new int[]{x, y});
                     visited[x][y] = true;
                 }
             }

             level++;
         }
     }
 }