离建筑物最近的距离

/*
 * Leetcode Problem 317: Shortest Distance from All Buildings
 * 
 * Approach using Java Streams (where applicable):
 * 1. Initialize distance and reach arrays to store the sum of distances and the number of buildings reached from each cell.
 * 2. Use BFS from each building to compute distances to all reachable empty lands.
 * 3. Use Streams to find the minimum distance cell which can reach all buildings.
 */
 
import java.util.*;
import java.util.stream.IntStream;
 
public class SolutionStream {
    public int shortestDistance(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] distance = new int[m][n];
        int[][] reach = new int[m][n];
        int numBuildings = 0;
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};
 
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    numBuildings++;
                    boolean[][] visited = new boolean[m][n];
                    Queue<int[]> queue = new LinkedList<>();
                    queue.offer(new int[]{i, j});
                    int level = 1;
                    while (!queue.isEmpty()) {
                        int size = queue.size();
                        for (int k = 0; k < size; k++) {
                            int[] cur = queue.poll();
                            for (int d = 0; d < 4; d++) {
                                int x = cur[0] + dx[d];
                                int y = cur[1] + dy[d];
                                if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 0 && !visited[x][y]) {
                                    visited[x][y] = true;
                                    distance[x][y] += level;
                                    reach[x][y]++;
                                    queue.offer(new int[]{x, y});
                                }
                            }
                        }
                        level++;
                    }
                }
            }
        }
 
        return IntStream.range(0, m).boxed()
            .flatMap(i -> IntStream.range(0, n).filter(j -> grid[i][j] == 0 && reach[i][j] == numBuildings).mapToObj(j -> distance[i][j]))
            .min(Integer::compare)
            .orElse(-1);
    }
}