Question

1030. 距离顺序排列矩阵单元格

English Version

题目描述

给定四个整数 rows ,   cols ,  rCenter 和 cCenter 。有一个 rows x cols 的矩阵，你在单元格上的坐标是 (rCenter, cCenter) 。

返回矩阵中的所有单元格的坐标，并按与_ _(rCenter, cCenter)_ _的 距离 从最小到最大的顺序排。你可以按 任何 满足此条件的顺序返回答案。

单元格(r1, c1) 和 (r2, c2) 之间的距离为|r1 - r2| + |c1 - c2|。

 

示例 1：

输入：rows = 1, cols = 2, rCenter = 0, cCenter = 0
输出：[[0,0],[0,1]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1]

示例 2：

输入：rows = 2, cols = 2, rCenter = 0, cCenter = 1
输出：[[0,1],[0,0],[1,1],[1,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2]
[[0,1],[1,1],[0,0],[1,0]] 也会被视作正确答案。

示例 3：

输入：rows = 2, cols = 3, rCenter = 1, cCenter = 2
输出：[[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2,2,3]
其他满足题目要求的答案也会被视为正确，例如 [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]]。

 

提示：

• 1 <= rows, cols <= 100
• 0 <= rCenter < rows
• 0 <= cCenter < cols

解法

方法一：BFS

我们定义一个队列 $q$，初始时将坐标点 $(rCenter, cCenter)$ 入队，用一个二维布尔数组 $vis$ 记录已经访问过的点，初始时 $vis[rCenter][cCenter]$ 为 $true$。

接下来，我们不断地从队列中取出一个点，将其加入答案数组，然后将其上下左右四个相邻点加入队列，注意要判断这些点是否已经访问过，如果没有访问过，就将其标记为已访问，并将其加入队列。一直重复这个过程，直到队列为空，此时答案数组中的点就是按照距离从小到大的顺序排列的。

时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。

class Solution:
  def allCellsDistOrder(
    self, rows: int, cols: int, rCenter: int, cCenter: int
  ) -> List[List[int]]:
    q = deque([[rCenter, cCenter]])
    vis = [[False] * cols for _ in range(rows)]
    vis[rCenter][cCenter] = True
    ans = []
    while q:
      for _ in range(len(q)):
        p = q.popleft()
        ans.append(p)
        for a, b in pairwise((-1, 0, 1, 0, -1)):
          x, y = p[0] + a, p[1] + b
          if 0 <= x < rows and 0 <= y < cols and not vis[x][y]:
            vis[x][y] = True
            q.append([x, y])
    return ans

import java.util.Deque;

class Solution {
  public int[][] allCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
    Deque<int[]> q = new ArrayDeque<>();
    q.offer(new int[] {rCenter, cCenter});
    boolean[][] vis = new boolean[rows][cols];
    vis[rCenter][cCenter] = true;
    int[][] ans = new int[rows * cols][2];
    int[] dirs = {-1, 0, 1, 0, -1};
    int idx = 0;
    while (!q.isEmpty()) {
      for (int n = q.size(); n > 0; --n) {
        var p = q.poll();
        ans[idx++] = p;
        for (int k = 0; k < 4; ++k) {
          int x = p[0] + dirs[k], y = p[1] + dirs[k + 1];
          if (x >= 0 && x < rows && y >= 0 && y < cols && !vis[x][y]) {
            vis[x][y] = true;
            q.offer(new int[] {x, y});
          }
        }
      }
    }
    return ans;
  }
}

class Solution {
public:
  vector<vector<int>> allCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
    queue<pair<int, int>> q;
    q.emplace(rCenter, cCenter);
    vector<vector<int>> ans;
    bool vis[rows][cols];
    memset(vis, false, sizeof(vis));
    vis[rCenter][cCenter] = true;
    int dirs[5] = {-1, 0, 1, 0, -1};
    while (!q.empty()) {
      for (int n = q.size(); n; --n) {
        auto [i, j] = q.front();
        q.pop();
        ans.push_back({i, j});
        for (int k = 0; k < 4; ++k) {
          int x = i + dirs[k];
          int y = j + dirs[k + 1];
          if (x >= 0 && x < rows && y >= 0 && y < cols && !vis[x][y]) {
            vis[x][y] = true;
            q.emplace(x, y);
          }
        }
      }
    }
    return ans;
  }
};

func allCellsDistOrder(rows int, cols int, rCenter int, cCenter int) (ans [][]int) {
  q := [][]int{{rCenter, cCenter}}
  vis := make([][]bool, rows)
  for i := range vis {
    vis[i] = make([]bool, cols)
  }
  vis[rCenter][cCenter] = true
  dirs := [5]int{-1, 0, 1, 0, -1}
  for len(q) > 0 {
    for n := len(q); n > 0; n-- {
      p := q[0]
      q = q[1:]
      ans = append(ans, p)
      for k := 0; k < 4; k++ {
        x, y := p[0]+dirs[k], p[1]+dirs[k+1]
        if x >= 0 && x < rows && y >= 0 && y < cols && !vis[x][y] {
          vis[x][y] = true
          q = append(q, []int{x, y})
        }
      }
    }
  }
  return
}