[LeetCode] Shortest Distance from All Buildings Solution

之前听朋友说LeetCode出了一道新题，但是一直在TLE，我就找时间做了一下。这题是一个比较典型的BFS的题目，自己匆忙写了一个答案，没有考虑优化的问题，应该是有更好的解法的。

原题如下：

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.

For example, given three buildings at (0,0), (0,4), (2,2), and an obstacle at (0,2):

  1 - 0 - 2 - 0 - 1

  |    |    |    |    |

  0 - 0 - 0 - 0 - 0

  |    |    |    |    |

  0 - 0 - 1 - 0 - 0

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.

基本想法就是从每个数值为1的点做bfs，遇到为0的点就加上相应的距离。这题因为要求到所有1的距离和最小的点，所以就可以无脑iterate over所有数值为1的点，并开一个二维数组来记录各个点的累加距离值。最后要检查一下所有结果中的值，确保其可以reach到所有的值为1的点，若不存在这样的，则返回-1。代码如下，比较冗长，等有机会再优化一下吧。

public class Solution {
    public int shortestDistance(int[][] grid) {
        int result = Integer.MAX_VALUE;
        boolean[][] done = new boolean[grid.length][grid[0].length];
        int[][] cost = new int[grid.length][grid[0].length];
        int[][] count = new int[grid.length][grid[0].length];
        int total = 0; // total # of 1
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                done[i][j] = grid[i][j] != 0;
                total = grid[i][j] == 1 ? total + 1 : total;
            }
        }
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 1) {
                    Deque<Integer> row = new ArrayDeque<>();
                    Deque<Integer> col = new ArrayDeque<>();
                    enqueue(row, col, i, j, done, grid);
                    bfs(row, col, grid, cost, done, count, 1);
                }
            }
        }
        if (!isValid(count, total)) {
            return -1;
        }
        for (int i = 0; i < cost.length; i++) {
            for (int j = 0; j < cost[0].length; j++) {
                if (count[i][j] == total) {
                    result = cost[i][j] > 0 ? Math.min(result, cost[i][j]) : result;
                }
            }
        }
        return result;
    }

    private void bfs(Deque<Integer> row, Deque<Integer> col, int[][] grid, int[][] cost, boolean[][] done, int[][] count, int distance) {
        if (row.isEmpty()) {
            return;
        }
        int size = row.size();
        List<Integer> row1 = new ArrayList<>();
        List<Integer> col1 = new ArrayList<>();
        for (int k = 0; k < size; k++) {
            int i = row.poll();
            int j = col.poll();
            row1.add(i);
            col1.add(j);
            cost[i][j] += distance;
            count[i][j] += 1;
            enqueue(row, col, i, j, done, grid);
        }
        bfs(row, col, grid, cost, done, count, distance + 1);
        for (int i = 0; i < row1.size(); i++) {
            done[row1.get(i)][col1.get(i)] = false;
        }
    }

    private void enqueue(Deque<Integer> row, Deque<Integer> col, int i, int j, boolean[][] done, int[][] grid) {
        int down = i + 1;
        int up = i - 1;
        int left = j - 1;
        int right = j + 1;
        if (up >= 0 && !done[up][j] && grid[up][j] == 0) {
            row.offer(up);
            col.offer(j);
            done[up][j] = true;
        }
        if (down < grid.length && !done[down][j] && grid[down][j] == 0) {
            row.offer(down);
            col.offer(j);
            done[down][j] = true;
        }
        if (left >= 0 && !done[i][left] && grid[i][left] == 0) {
            row.offer(i);
            col.offer(left);
            done[i][left] = true;
        }
        if (right < grid[0].length && !done[i][right] && grid[i][right] == 0) {
            row.offer(i);
            col.offer(right);
            done[i][right] = true;
        }
    }

    private boolean isValid(int[][] count, int total) {
        for (int[] aCount : count) {
            for (int c : aCount) {
                if (c == total) {
                    return true;
                }
            }
        }
        return false;
    }
}