542. 01 矩阵
给定一个由 0 和 1 组成的矩阵,找出每个元素到最近的 0 的距离。两个相邻元素间的距离为 1 。
示例 1:
输入:
0 0 0
0 1 0
0 0 0
输出:
0 0 0
0 1 0
0 0 0
示例 2:
输入:
0 0 0
0 1 0
1 1 1
输出:
0 0 0
0 1 0
1 2 1
注意:
给定矩阵的元素个数不超过 10000。
给定矩阵中至少有一个元素是 0。
矩阵中的元素只在四个方向上相邻: 上、下、左、右。
分析:
想法一:广度优先搜索
- 把每个源点0入队,然后每个0向1一圈一圈辐射扩散
- 设置 int[ ] [ ]dist 来记录距离(即扩散的层次)并同时标志是否访问过
【注】要先把 matrix 数组中 1 的位置设置成 -1 (或无效的距离值)
广度优先搜索
找每个元素到最近的 0 的距离,即为,0到该元素的最短距离。可将0视作源点进行辐射。辐射过程如图所示。
1.红色为源点。
2.橙色为辐射第一圈。
3.黄色为辐射第二圈。(因此该其值为2)
由图可知,
1.将源点0(红色)入队,并将终点(即非0点,元素点)值改为-1,(-1为未访问)
2.将队列中结点弹出,并在四个方向辐射,向左向右向上向下(方向矢量为左(-1,0)右(1,0)上(0,-1)下(0,1)),得到辐射第一圈结点。并将辐射第一圈结点值改为1。
3.将辐射第一圈结点入队,然后依次弹出,并在四个方向辐射(忽略源点方向,即只往-1方向辐射),得到辐射第二圈结点。并将辐射第二圈结点值改为2。
…
重复执行上述步骤,直至队列为空
4.返回新的matrix矩阵
public class T542 {
public int [][] updateMatrix(int[][] matrix){
Queue<int[]> queue=new LinkedList<>();
for (int i = 0; i < matrix.length; i++) {
for(int j=0;j<matrix[0].length;j++){
if(matrix[i][j]==0){
queue.offer(new int[]{i,j});//0元素入队
}else {
matrix[i][j]=-1;//-1为未访问标记
}
}
}
//dx,dy表示坐标系中x,y向左、向右、向上、向下的分量
int[] dx=new int[]{-1,1,0,0};
int[] dy=new int[]{0,0,-1,1};
while (!queue.isEmpty()){
int[] point=queue.poll();//0元素出队
int x=point[0],y=point[1];
for (int i = 0; i < 4; i++) {
//弹出的0元素向四个方向移动后的新坐标
int newX=x+dx[i];
int newY=y+dy[i];
// 如果四邻域的点是 -1,表示这个点是未被访问过的 1
// 所以这个点到 0 的距离就可以更新成 matrix[x][y] + 1。
if (newX >= 0 && newX < matrix.length &&
newY >= 0 && newY < matrix[0].length//判断是否超出数组边界
&& matrix[newX][newY] == -1) {//判断新坐标是否为终点-1
matrix[newX][newY] = matrix[x][y] + 1;//将终点值-1,改为源点值+1
queue.offer(new int[] {newX, newY});//将终点坐标加入队列,进行第二轮的辐射
}
}
}
return matrix;
}
}
第二种
class Solution {
public int[][] updateMatrix(int[][] matrix) {
// 首先将 0 边上的 1 入队
int[] dx = new int[] {-1, 1, 0, 0};
int[] dy = new int[] {0, 0, -1, 1};
Queue<int[]> queue = new LinkedList<>();
int m = matrix.length, n = matrix[0].length;
int[][] res = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (matrix[i][j] == 0) {
for (int k = 0; k < 4; k++) {
int x = i + dx[k];
int y = j + dy[k];
if (x >= 0 && x < m && y >= 0 && y < n
&& matrix[x][y] == 1 && res[x][y] == 0) {
// 这是在 0 边上的1。需要加上 res[x][y] == 0 的判断防止重复入队
res[x][y] = 1;
queue.offer(new int[] {x, y});
}
}
}
}
}
while (!queue.isEmpty()) {
int[] point = queue.poll();
int x = point[0], y = point[1];
for (int i = 0; i < 4; i++) {
int newX = x + dx[i];
int newY = y + dy[i];
if (newX >= 0 && newX < m && newY >= 0 && newY < n
&& matrix[newX][newY] == 1 && res[newX][newY] == 0) {
res[newX][newY] = res[x][y] + 1;
queue.offer(new int[] {newX, newY});
}
}
}
return res;
}
}
动态规划
class Solution {
public int[][] updateMatrix(int[][] matrix) {
int m = matrix.length, n = matrix[0].length;
int[][] dp = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = matrix[i][j] == 0 ? 0 : 10000;
}
}
// 从左上角开始
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (i - 1 >= 0) {
dp[i][j] = Math.min(dp[i][j], dp[i - 1][j] + 1);
}
if (j - 1 >= 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 (i + 1 < m) {
dp[i][j] = Math.min(dp[i][j], dp[i + 1][j] + 1);
}
if (j + 1 < n) {
dp[i][j] = Math.min(dp[i][j], dp[i][j + 1] + 1);
}
}
}
return dp;
}
}