使矩阵中的 1 互不相邻的最小操作数

/*
 * 题目思路：
 * 1. 使用 Java Stream 遍历矩阵，找到所有的 1 的位置。
 * 2. 对每个 1 的位置，检查其上下左右是否有相邻的 1。
 * 3. 计算每个 1 移动到非相邻位置所需的最小操作数。
 * 4. 累计所有操作数，得到最终结果。
 */

import java.util.*;
import java.util.stream.*;

public class Solution {
    public int minOperations(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        boolean[][] visited = new boolean[n][m];

        List<int[]> ones = IntStream.range(0, n)
            .boxed()
            .flatMap(i -> IntStream.range(0, m)
                .filter(j -> grid[i][j] == 1)
                .mapToObj(j -> new int[]{i, j}))
            .collect(Collectors.toList());

        int operations = ones.stream()
            .filter(pos -> !visited[pos[0]][pos[1]])
            .mapToInt(pos -> bfs(grid, visited, pos[0], pos[1]))
            .sum();

        return operations;
    }

    private int bfs(int[][] grid, boolean[][] visited, int x, int y) {
        int n = grid.length;
        int m = grid[0].length;
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};
        int operations = 0;
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{x, y});
        visited[x][y] = true;

        while (!queue.isEmpty()) {
            int[] pos = queue.poll();
            int i = pos[0];
            int j = pos[1];

            for (int k = 0; k < 4; k++) {
                int ni = i + dx[k];
                int nj = j + dy[k];

                if (ni >= 0 && ni < n && nj >= 0 && nj < m && grid[ni][nj] == 1 && !visited[ni][nj]) {
                    operations++;
                    visited[ni][nj] = true;
                    queue.add(new int[]{ni, nj});
                }
            }
        }
        return operations;
    }
}