java – 为什么BFS在这种情况下不保证最小的成本路径？

我正在解决关于LeetCode的问题：

Given a matrix consists of 0 and 1, find the distance of the nearest 0 for each cell. The distance between two adjacent cells is 1 (important point).

If input:

[[0,0,0],
 [0,1,0],
 [1,1,1]]

then output:

[[0,0,0],
 [0,1,0],
 [1,2,1]]

我编写的代码将所有0的位置添加到队列中,并从队列中的每个这样的位置执行BFS.不幸的是它超时了.

给出的高度赞成的解决方案是这样的：

public class Solution {
    public int[][] updateMatrix(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;

        Queue<int[]> queue = new LinkedList<>();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == 0) {
                    queue.offer(new int[] {i, j});
                }
                else {
                    matrix[i][j] = Integer.MAX_VALUE;
                }
            }
        }

        int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

        while (!queue.isEmpty()) {
            int[] cell = queue.poll();
            for (int[] d : dirs) {
                int r = cell[0] + d[0];
                int c = cell[1] + d[1];
                if (r < 0 || r >= m || c < 0 || c >= n || 
                    matrix[r][c] <= matrix[cell[0]][cell[1]] + 1) continue;
                queue.add(new int[] {r, c});
                matrix[r][c] = matrix[cell[0]][cell[1]] + 1;
            }
        }

        return matrix;
    }
}

虽然我或多或少了解它是如何工作的,但我有以下问题：

为什么我们必须检查矩阵[r] [c]< = matrix [cell [0]] [cell [1]] 1 - BFS是否保证如果边缘成本相等,那么它的路径发现特定节点是最短的？为什么我们要检查呢？

解决方法:

无法保证BFS算法只能达到矩阵[r] [c]一次.事实上,在这个问题上,它将达到多次.当你第一次达到矩阵[r] [c]时,你所说的保证才有效.

因此,另一种解决方案是保留另一个布尔值矩阵,标记是否已访问过每个单元格,并替换您提到的检查！visited [r] [c].但是,保留额外的矩阵需要额外的内存 – 这是偏好当前方法的原因.

标签：breadth-first-search,java,algorithm
来源： https://codeday.me/bug/20190828/1748238.html