My code:
import java.util.LinkedList;
import java.util.Queue;
public class Solution {
private int row = 0;
private int col = 0;
private int[][] dir = new int[][]{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
public int shortestDistance(int[][] grid) {
if (grid == null || grid.length == 0 || grid[0].length == 0) {
return -1;
}
this.row = grid.length;
this.col = grid[0].length;
int[][] distance = new int[row][col];
int[][] reach = new int[row][col];
int totalBuilding = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == 1) {
totalBuilding++;
boolean[][] mark = new boolean[row][col];
Queue<int[]> q = new LinkedList<int[]>();
q.offer(new int[]{i, j});
mark[i][j] = true;
int level = 1;
while (!q.isEmpty()) {
int size = q.size();
for (int m = 0; m < size; m++) {
int[] loc = q.poll();
for (int k = 0; k < 4; k++) {
int next_x = loc[0] + dir[k][0];
int next_y = loc[1] + dir[k][1];
if (check(next_x, next_y) && !mark[next_x][next_y] && grid[next_x][next_y] == 0) {
mark[next_x][next_y] = true;
distance[next_x][next_y] += level;
reach[next_x][next_y]++;
q.offer(new int[]{next_x, next_y});
}
}
}
level++;
}
}
}
}
int ret = Integer.MAX_VALUE;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (grid[i][j] == 0 && reach[i][j] == totalBuilding && distance[i][j] < ret) {
ret = distance[i][j];
}
}
}
return ret == Integer.MAX_VALUE ? -1 : ret;
}
private boolean check(int i, int j) {
if (i < 0 || i >= row || j < 0 || j >= col) {
return false;
}
else {
return true;
}
}
}
reference:
https://discuss.leetcode.com/topic/31925/java-solution-with-explanation-and-time-complexity-analysis
这道题目让我想起了 multi-end BFS
就是从多个building同时出发，一起遍历。
但是问题在于，如何标志，这个 empty area 被多个Building访问过后的状态？
我没仔细想，直接看了答案。
目前的这个解法，感觉并不是最优的，时间复杂度达到了
O(m * n * m * n)
他解决我说的问题的方法是，
对building 一个个进行BFS，同时维护两个数组，一个累加距离，一个累加到这个点的building 个数。
最后再遍历这个距离数组，如果到这个点的building 个数 = 总building个数，那么这个点可以作为一个最短点，然后我们判断下他的总距离是否最小，如果最小，就更新最小值。
同时，记住， BFS的时候，我们需要一个变量level，这是必须的，用来记录每次距离应该加多少。
时间不知不觉到了10月份了。。好久没刷题了。
加油。未来，就在这最后一个月！
Optimization:
My code:
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class Solution {
private class Tuple {
int x;
int y;
int distance;
Tuple(int x, int y, int distance) {
this.x = x;
this.y = y;
this.distance = distance;
}
}
private int row = 0;
private int col = 0;
private int[][] dir = new int[][]{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
public int shortestDistance(int[][] grid) {
if (grid == null || grid.length == 0 || grid[0].length == 0) {
return -1;
}
row = grid.length;
col = grid[0].length;
int[][] dist = new int[row][col];
List<Tuple> buildings = new ArrayList<Tuple>();
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (grid[i][j] == 1) {
buildings.add(new Tuple(i, j, 0));
}
grid[i][j] = -grid[i][j];
}
}
for (int i = 0; i < buildings.size(); i++) {
bfs(buildings.get(i), i, grid, dist);
}
int ret = Integer.MAX_VALUE;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (grid[i][j] == buildings.size() && dist[i][j] < ret) {
ret = dist[i][j];
}
}
}
return ret == Integer.MAX_VALUE ? -1 : ret;
}
private void bfs(Tuple root, int k, int[][] grid, int[][] dist) {
Queue<Tuple> q = new LinkedList<Tuple>();
q.offer(root);
while (!q.isEmpty()) {
Tuple t = q.poll();
dist[t.x][t.y] += t.distance;
for (int i = 0; i < 4; i++) {
int next_x = t.x + dir[i][0];
int next_y = t.y + dir[i][1];
if (check(next_x, next_y) && grid[next_x][next_y] == k) {
q.offer(new Tuple(next_x, next_y, t.distance + 1));
grid[next_x][next_y] = k + 1;
}
}
}
}
private boolean check(int i, int j) {
if (i < 0 || i >= row || j < 0 || j >= col) {
return false;
}
return true;
}
public static void main(String[] args) {
Solution test = new Solution();
int[][] input = new int[][]{{1, 0, 2, 0, 1}, {0, 0, 0, 0, 0}, {0, 0, 1, 0, 0}};
int ret = test.shortestDistance(input);
System.out.println(ret);
}
}
reference:
https://discuss.leetcode.com/topic/32391/share-a-java-implement
做完这题，总感觉之前的解法，有太多重复运算。
于是看了更好的解法。
之前的重复在于，如果一个index,他确定不能被一个大楼走到，那么以后对于其他大楼，我们都不需要对他做BFS了，也就是剪枝。
然后现在这个做法，可以很好地剪枝。
Anyway, Good luck, Richardo! -- 10/07/2016
