LeetCode 317. 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++;
        }
    }
}

类似Walls and Gates.