542. 01 矩阵
问题描述
给定一个由 0 和 1 组成的矩阵，找出每个元素到最近的 0 的距离。
这里的距离定义为曼哈顿距离（即上下左右移动的步数），每个元素只能向上下左右四个方向移动。
示例：
输入：
[[0,0,0],
[0,1,0],
[1,1,1]]
输出：
[[0,0,0],
[0,1,0],
[1,2,1]]
算法思路
方法一：多源 BFS（推荐解法）
- 核心思想：将所有值为 0 的位置作为起点，同时进行广度优先搜索（BFS）
- 从所有 0 开始向外扩散，每一轮将距离加 1
- 第一次访问到某个 1 时，其距离就是最短距离
方法二：动态规划（两次扫描）
- 第一次扫描（左上到右下）：
- 从左上角开始，向右下角遍历
- 每个位置的距离 = min(上方距离 + 1, 左方距离 + 1)
- 第二次扫描（右下到左上）：
- 从右下角开始，向左上角遍历
- 每个位置的距离 = min(当前距离, 下方距离 + 1, 右方距离 + 1)
- 两次扫描结合，确保考虑了所有方向的最短路径
代码实现
方法一：多源 BFS（推荐）
import java.util.*;
class Solution {
/**
* 计算矩阵中每个元素到最近的0的距离
* 使用多源BFS算法
*
* @param mat 输入的01矩阵
* @return 每个位置到最近0的距离矩阵
*/
public int[][] updateMatrix(int[][] mat) {
int m = mat.length; // 矩阵行数
int n = mat[0].length; // 矩阵列数
// 结果数组，初始化为-1表示未访问
int[][] dist = new int[m][n];
for (int i = 0; i < m; i++) {
Arrays.fill(dist[i], -1);
}
// 创建队列用于BFS，存储坐标对 [row, col]
Queue<int[]> queue = new LinkedList<>();
// 第一步：将所有值为0的位置加入队列，并设置距离为0
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (mat[i][j] == 0) {
dist[i][j] = 0; // 0到自身的距离为0
queue.offer(new int[]{i, j}); // 将0的位置加入BFS队列
}
}
}
// 四个方向的偏移量：上、下、左、右
int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
// 多源BFS主循环
while (!queue.isEmpty()) {
int[] curr = queue.poll(); // 取出队首元素
int row = curr[0];
int col = curr[1];
// 探索四个相邻方向
for (int[] dir : directions) {
int newRow = row + dir[0];
int newCol = col + dir[1];
// 检查新位置是否在矩阵范围内
if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n) {
// 如果该位置未被访问过（即原来是1）
if (dist[newRow][newCol] == -1) {
// 距离 = 当前位置距离 + 1
dist[newRow][newCol] = dist[row][col] + 1;
// 将新位置加入队列，继续BFS
queue.offer(new int[]{newRow, newCol});
}
}
}
}
return dist;
}
}
方法二：动态规划（两次扫描）
class Solution {
/**
* 使用动态规划方法计算每个元素到最近0的距离
* 通过两次扫描确保找到全局最短距离
*
* @param mat 输入的01矩阵
* @return 每个位置到最近0的距离矩阵
*/
public int[][] updateMatrix(int[][] mat) {
int m = mat.length;
int n = mat[0].length;
// 初始化结果数组
// 初始值设为m+n，因为最大可能距离不会超过m+n-2
int[][] dp = new int[m][n];
for (int i = 0; i < m; i++) {
Arrays.fill(dp[i], m + n);
}
// 第一次扫描：从左上到右下
// 只考虑从上方和左方转移
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (mat[i][j] == 0) {
// 如果当前是0，则距离为0
dp[i][j] = 0;
} else {
// 如果不是边界，可以考虑从上方转移
if (i > 0) {
dp[i][j] = Math.min(dp[i][j], dp[i-1][j] + 1);
}
// 如果不是边界，可以考虑从左方转移
if (j > 0) {
dp[i][j] = Math.min(dp[i][j], dp[i][j-1] + 1);
}
}
}
}
// 第二次扫描：从右下到左上
// 考虑从下方和右方转移，并与第一次扫描的结果比较
for (int i = m - 1; i >= 0; i--) {
for (int j = n - 1; j >= 0; j--) {
if (mat[i][j] != 0) { // 只处理1的位置
// 如果不是边界，可以考虑从下方转移
if (i < m - 1) {
dp[i][j] = Math.min(dp[i][j], dp[i+1][j] + 1);
}
// 如果不是边界，可以考虑从右方转移
if (j < n - 1) {
dp[i][j] = Math.min(dp[i][j], dp[i][j+1] + 1);
}
}
}
}
return dp;
}
}
算法分析
-
时间复杂度：
- 多源BFS：O(m × n)，每个元素最多入队一次
- 动态规划：O(m × n)，进行两次完整遍历
-
空间复杂度：
- 多源BFS：O(m × n)，队列最坏情况下存储所有0的位置
- 动态规划：O(1) 额外空间（不考虑输出数组）
-
方法对比：
- 多源BFS：逻辑清晰，易于理解，符合直观的"扩散"思维
- 动态规划：空间效率更高，但需要理解两次扫描的必要性
算法过程
输入 [[0,0,0],[0,1,0],[1,1,1]] ：
多源BFS执行过程：
-
初始化：
- 将所有0的位置加入队列：(0,0), (0,1), (0,2), (1,0), (1,2)
- 设置这些位置的距离为0
-
第一轮BFS：
- 从队列中取出所有0位置
- 向四周扩散，找到距离为1的位置：(1,1), (2,0)
- 将这些位置加入队列
-
第二轮BFS：
- 取出距离为1的位置
- 扩散到距离为2的位置：(2,1)
- 将该位置加入队列
-
第三轮BFS：
- 取出(2,1)，扩散到(2,2)，距离为3
- 但实际上(2,2)会从(1,2)直接到达，距离为2
最终结果：[[0,0,0],[0,1,0],[1,2,1]]
动态规划执行过程：
第一次扫描（左上→右下）：
初始：[[∞,∞,∞],[∞,∞,∞],[∞,∞,∞]]
结果：[[0,0,0],[0,1,0],[1,2,3]]
第二次扫描（右下→左上）：
从(2,2)开始：
- (2,2): min(3, dp[2,1]+1=3, dp[1,2]+1=1) → 1
- (2,1): min(2, dp[2,2]+1=2, dp[1,1]+1=2) → 2
- (2,0): min(1, dp[2,1]+1=3) → 1
- (1,1): min(1, dp[1,2]+1=1, dp[2,1]+1=3) → 1
最终结果：[[0,0,0],[0,1,0],[1,2,1]]
测试用例
public static void main(String[] args) {
Solution solution = new Solution();
// 测试用例1：标准示例
int[][] mat1 = {
{0,0,0},
{0,1,0},
{1,1,1}
};
printMatrix("Test 1:", solution.updateMatrix(mat1));
// 预期输出：
// [0,0,0]
// [0,1,0]
// [1,2,1]
// 测试用例2：全0矩阵
int[][] mat2 = {
{0,0},
{0,0}
};
printMatrix("Test 2:", solution.updateMatrix(mat2));
// 预期输出：
// [0,0]
// [0,0]
// 测试用例3：全1矩阵（不可能，至少有一个0）
// 根据题意，至少有一个0，所以不考虑这种情况
// 测试用例4：单行矩阵
int[][] mat3 = {{1,0,1,1,0}};
printMatrix("Test 3:", solution.updateMatrix(mat3));
// 预期输出：[1,0,1,1,0]
// 测试用例5：单列矩阵
int[][] mat4 = {{1},{0},{1},{1},{0}};
printMatrix("Test 4:", solution.updateMatrix(mat4));
// 预期输出：[1],[0],[1],[1],[0]
}
// 辅助函数：打印矩阵
private static void printMatrix(String title, int[][] matrix) {
System.out.println(title);
for (int[] row : matrix) {
System.out.println(Arrays.toString(row));
}
System.out.println();
}
关键点
-
多源BFS的本质：
- 将所有0视为同一层的起点
- 同时向外扩散，保证第一次到达某个1时就是最短路径
-
为什么需要两次扫描：
- 单次扫描只能考虑部分方向（如只考虑左上方）
- 第二次反向扫描确保考虑了所有可能的路径
-
距离初始化：
- BFS中用-1表示未访问
- DP中用较大值（m+n）表示无穷大
-
边界处理：
- 注意数组越界检查
- 0的位置距离始终为0
常见问题
-
为什么BFS能保证是最短距离？
- 因为BFS按层扩展，第一次访问到某个节点时的层数就是最短距离
- 多源BFS相当于从多个起点同时开始的BFS
-
DP方法中为什么初始值设为m+n？
- 在m×n的矩阵中，任意两点间的最大曼哈顿距离不超过m+n-2
- 设为m+n可确保大于任何实际距离，起到"无穷大"的作用
-
能否用普通BFS逐个计算？
- 可以，但时间复杂度会达到O((mn)^2)，效率很低
- 多源BFS将时间复杂度优化到O(mn)
-
四种方向偏移量的作用？
{-1,0}：向上移动{1,0}：向下移动{0,-1}：向左移动{0,1}：向右移动- 这种表示法简洁且易于遍历
-
两种方法的选择：
- 多源BFS：推荐，逻辑清晰，容易理解和调试
- 动态规划：空间效率略高，适合对空间要求严格的场景
扫一扫
50万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
