矩阵中元素与特定元素距离的修改（Java）

Tinkinon

已于 2024-01-18 10:39:21 修改

阅读量368

点赞数 8

文章标签：矩阵动态规划 java

于 2024-01-18 10:32:18 首次发布

本文链接：https://blog.csdn.net/lohath/article/details/135658465

版权

问题描述：
给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。两个相邻元素间的距离为 1 。

eg 1:
输入：mat = [[0,0,0],[0,1,0],[1,1,1]]
输出：[[0,0,0],[0,1,0],[1,2,1]]

图例：
输入：
在这里插入图片描述
输出：

实际上就是在给定的矩阵中，0元素保持不变，其他元素变为离最近的0元素的距离；

对于这类问题，有以下解决方法：

广度优先搜索：

例如下图，若矩阵中只有一个0元素，那么周围元素离0元素距离为1的只有四个，分别为上下左右。
离0元素距离为2的便是0的对角方向和左左右右上上下下等等

在这里插入图片描述
可以找到矩阵中所有的0元素，从这些0元素出发去分别找距离为1，2，3的位置便是基本思路；

首先创建一个用于广度搜索的队列：

 Queue<int[]> queue = new LinkedList<int[]>();  // 用于广度优先搜索的队列

然后将所有的0元素添加到队列中，在录入0元素的位置坐标时，要注意0元素和0元素之间可能会存在干扰，所以要引入一个Boolean变量来判断是否访问过此元素：

        int m = matrix.length, n = matrix[0].length;
        int[][] dist = new int[m][n];  // 用于存储每个位置到最近的 0 的距离
        boolean[][] seen = new boolean[m][n];  // 用于标记位置是否已经访问过
        Queue<int[]> queue = new LinkedList<int[]>();  // 用于广度优先搜索的队列
 // 将所有的 0 添加进初始队列中，并标记已访问
        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});  // 将坐标加入队列
                    seen[i][j] = true;  // 标记为已访问
                }
            }

queue.offer（）实现的功能是将这些0元素的坐标数据加入该队列的尾部

之后便开始搜索：
利用队列queue.poll()方法弹出队列中的一个位置，由于其返回的是一个一维数组，是一个坐标数组，包含两个元素，分别表示行和列的坐标。我们可以创建一个一维数组来存储：

int[] cell = queue.poll();  // 弹出队列中的一个位置
int i = cell[0], j = cell[1];

然后以这个0元素为中心遍历四个方向：

 for (int d = 0; d < 4; ++d) {
                int ni = i + dirs[d][0];  // 计算新位置的行坐标
                int nj = j + dirs[d][1];  // 计算新位置的列坐标
}

然后判断新位置是否被访问过，如果满足新位置没有在矩阵范围之外或从未被访问过，则将此新位置的距离数+1，并加入队列：

if (ni >= 0 && ni < m && nj >= 0 && nj < n && !seen[ni][nj]) {
                    dist[ni][nj] = dist[i][j] + 1;  // 更新距离
                    queue.offer(new int[]{ni, nj});  // 将新位置加入队列
                    seen[ni][nj] = true;  // 标记为已访问
                }

最后将以上操作套入循环，将矩阵中所有位置都进行更新：

 while (!queue.isEmpty()) {
            int[] cell = queue.poll();  // 弹出队列中的一个位置
            int i = cell[0], j = cell[1];
            // 遍历四个方向
            for (int d = 0; d < 4; ++d) {
                int ni = i + dirs[d][0];  // 计算新位置的行坐标
                int nj = j + dirs[d][1];  // 计算新位置的列坐标
                // 判断新位置是否在矩阵范围内且未访问过
                if (ni >= 0 && ni < m && nj >= 0 && nj < n && !seen[ni][nj]) {
                    dist[ni][nj] = dist[i][j] + 1;  // 更新距离
                    queue.offer(new int[]{ni, nj});  // 将新位置加入队列
                    seen[ni][nj] = true;  // 标记为已访问
                }
            }
        }
        return dist;  // 返回最终结果
    }

总实现类代码如下：

class Solution {
    // 定义四个方向的偏移量，上、下、左、右
    static int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    // 主函数，接收一个二维矩阵，返回一个与输入矩阵大小相同的二维数组，表示每个位置距离最近的 0 的距离
    public int[][] updateMatrix(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        int[][] dist = new int[m][n];  // 用于存储每个位置到最近的 0 的距离
        boolean[][] seen = new boolean[m][n];  // 用于标记位置是否已经访问过
        Queue<int[]> queue = new LinkedList<int[]>();  // 用于广度优先搜索的队列

        // 将所有的 0 添加进初始队列中，并标记已访问
        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});  // 将坐标加入队列
                    seen[i][j] = true;  // 标记为已访问
                }
            }
        }

        // 广度优先搜索
        while (!queue.isEmpty()) {
            int[] cell = queue.poll();  // 弹出队列中的一个位置
            int i = cell[0], j = cell[1];

            // 遍历四个方向
            for (int d = 0; d < 4; ++d) {
                int ni = i + dirs[d][0];  // 计算新位置的行坐标
                int nj = j + dirs[d][1];  // 计算新位置的列坐标

                // 判断新位置是否在矩阵范围内且未访问过
                if (ni >= 0 && ni < m && nj >= 0 && nj < n && !seen[ni][nj]) {
                    dist[ni][nj] = dist[i][j] + 1;  // 更新距离
                    queue.offer(new int[]{ni, nj});  // 将新位置加入队列
                    seen[ni][nj] = true;  // 标记为已访问
                }
            }
        }

        return dist;  // 返回最终结果
    }
}

动态规划

我们可以发现，对于一个给定的数组而言，其余元素离0元素的距离移动无非是向左向上，向左向下，向右向上，向右向下，那么可以利用这四种方法便可以完整的将距离进行表示

首先创建一个二维数组用来存放最终结果

        int m = mat.length, n = mat[0].length;
        int[][] dist = new int[m][n];
         for (int i = 0; i < m; ++i) {
            Arrays.fill(dist[i], Integer.MAX_VALUE /2);//当你在程序中使用 Integer.MAX_VALUE 时，是可以取到这个值的
            //但是需要注意的是，如果在某个表达式中的计算导致超过 Integer.MAX_VALUE，则会发生溢出，结果将变为负数。
            //因此，在实际编程中，为了防止溢出，通常会采取一些预防性的措施
            //例如使用 Integer.MAX_VALUE / 2，这是一个相对较大的值，减小了发生溢出的风险。
        }

之后将0元素的位置的值变为0（改之前是Integer.MAX_VALUE /2）：

for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (mat[i][j] == 0) {
                    dist[i][j] = 0;
                }
            }
        }

然后就是写出分别向左向上，向左向下，向右向上，向右向下的动态规划方程，要注意移动的过程中不能超出二维数组边界：
向左向上：

for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (i - 1 >= 0) {
                    dist[i][j] = Math.min(dist[i][j], dist[i - 1][j] + 1);
                }
                if (j - 1 >= 0) {
                    dist[i][j] = Math.min(dist[i][j], dist[i][j - 1] + 1);
                }
            }
        }

向左向下

for (int i = m - 1; i >= 0; --i) {
            for (int j = 0; j < n; ++j) {
                if (i + 1 < m) {
                    dist[i][j] = Math.min(dist[i][j], dist[i + 1][j] + 1);
                }
                if (j - 1 >= 0) {
                    dist[i][j] = Math.min(dist[i][j], dist[i][j - 1] + 1);
                }
            }
        }

向右向上

for (int i = 0; i < m; ++i) {
            for (int j = n - 1; j >= 0; --j) {
                if (i - 1 >= 0) {
                    dist[i][j] = Math.min(dist[i][j], dist[i - 1][j] + 1);
                }
                if (j + 1 < n) {
                    dist[i][j] = Math.min(dist[i][j], dist[i][j + 1] + 1);
                }
            }
        }

向右向下

for (int i = m - 1; i >= 0; --i) {
            for (int j = n - 1; j >= 0; --j) {
                if (i + 1 < m) {
                    dist[i][j] = Math.min(dist[i][j], dist[i + 1][j] + 1);
                }
                if (j + 1 < n) {
                    dist[i][j] = Math.min(dist[i][j], dist[i][j + 1] + 1);
                }
            }
        }

最后返回修改好的dist二维数组即可

完整方法类代码如下：

class Solution {
    public int[][] updateMatrix(int[][] mat) {
int m = mat.length, n = mat[0].length;
        // 初始化动态规划的数组，所有的距离值都设置为一个很大的数
        int[][] dist = new int[m][n];
        for (int i = 0; i < m; ++i) {
            Arrays.fill(dist[i], Integer.MAX_VALUE/2);
        }
        // 如果 (i, j) 的元素为 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;
                }
            }
        }
        // 只有 水平向左移动 和 竖直向上移动，注意动态规划的计算顺序
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (i - 1 >= 0) {
                    dist[i][j] = Math.min(dist[i][j], dist[i - 1][j] + 1);
                }
                if (j - 1 >= 0) {
                    dist[i][j] = Math.min(dist[i][j], dist[i][j - 1] + 1);
                }
            }
        }
        // 只有 水平向左移动 和 竖直向下移动，注意动态规划的计算顺序
        for (int i = m - 1; i >= 0; --i) {
            for (int j = 0; j < n; ++j) {
                if (i + 1 < m) {
                    dist[i][j] = Math.min(dist[i][j], dist[i + 1][j] + 1);
                }
                if (j - 1 >= 0) {
                    dist[i][j] = Math.min(dist[i][j], dist[i][j - 1] + 1);
                }
            }
        }
        // 只有 水平向右移动 和 竖直向上移动，注意动态规划的计算顺序
        
        // 只有 水平向右移动 和 竖直向下移动，注意动态规划的计算顺序
        for (int i = m - 1; i >= 0; --i) {
            for (int j = n - 1; j >= 0; --j) {
                if (i + 1 < m) {
                    dist[i][j] = Math.min(dist[i][j], dist[i + 1][j] + 1);
                }
                if (j + 1 < n) {
                    dist[i][j] = Math.min(dist[i][j], dist[i][j + 1] + 1);
                }
            }
        }
        return dist;
    
    }
}