[LintCode] 574 Build Post Office II

Problem

Given a 2D grid, each cell is either a wall 2, an house 1 or empty 0 (the number zero, one, two), find the place to build a post office, the distance that post office to all the house sum is smallest. Return the smallest distance. Return -1 if it is not possible.

Notice

You cannot pass through wall and house, but can pass through empty.You only build post office on an empty.

Example

Given a grid:

0 1 0 0 0
1 0 0 2 1
0 1 0 0 0

return 8, You can build at (1,1). (Placing a post office at (1,1), the distance that post office to all the house sum is smallest.)

Challenge

Solve this problem within O(n^3) time.

5/14/2017

算法班，抄答案的，未经验证

注意第65行，是否需要判断当前是不是wall？

class Coordinate {
    int x, y;
    public Coordinate(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

public class Solution {

    public int EMPTY = 0;
    public int HOUSE = 1;
    public int WALL = 2;

    public int[] xDirection = {0, 0, 1, -1};
    public int[] yDirection = {1, -1, 0, 0};

    /**
     * @param grid a 2D grid
     * @return an integer
     */
    public int shortestDistance(int[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return -1;
        }

        int[][] distanceSum = new int[grid.length][grid[0].length]; // total distance from all houses to current empty spot
        int[][] visitedTimes = new int[grid.length][grid[0].length]; // total visited times from all houses to current empty spot

        List<Coordinate> houses = getCoordinates(grid, HOUSE);

        for (Coordinate house: houses) {
            bfs(house, grid, distanceSum, visitedTimes);
        }

        List<Coordinate> empties = getCoordinates(grid, EMPTY);
        int shortest = Integer.MAX_VALUE;
        for (Coordinate empty: empties) {
            if (visitedTimes[empty.x][empty.y] != houses.size()) {
                continue;
            }
            shortest = Math.min(shortest, distanceSum[empty.x][empty.y]);
        }
        if (shortest == Integer.MAX_VALUE) return -1;
        return shortest;
    }

    private void bfs(Coordinate house, int[][] grid, int[][] distanceSum, int[][] visitedTimes) {
        Queue<Coordinate> queue = new LinkedList<Coordinate>();
        boolean[][] hash = new boolean[grid.length][grid[0].length];

        queue.offer(house);

        int step = 0;
        while (!queue.isEmpty()) {
            step++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                Coordinate c = queue.poll();
                for (int j = 0; j < xDirection.length; j++) {
                    Coordinate a = new Coordinate(c.x + xDirection[j], c.y + yDirection[j]);
                    if (!inBound(a)) continue;
                    if (hash[a.x][a.y]) continue;
                    // do we need this check?
                    if (grid[a.x][a.y] == WALL) continue;
                    queue.offer(a);
                    hash[a.x][a.y] = true;
                    distanceSum[a.x][a.y] += step;
                    visitedTimes[a.x][a.y]++;
                }
            }
        }
    }

    private List<Coordinate> getCoordinates(int[][] grid, int type) {
        List<Coordinate> ret = new ArrayList<Coordinate>();

        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == type) {
                    ret.add(new Coordinate(i, j));
                }
            }
        }
        return ret;
    }
    private boolean inBound(Coordinate coor) {
        if (coor.x < 0 || coor.x >= n) {
            return false;
        }
        if (coor.y < 0 || coor.y >= m) {
            return false;
        }
        return grid[coor.x][coor.y] == EMPTY;
    }
}