feat: update solutions to lc problem: No.1030

No.1030.Matrix Cells in Distance Order

Author: yanglbme

solution/1000-1099/1030.Matrix Cells in Distance Order/README.md

@@ -56,9 +56,11 @@
 
 **方法一：BFS**
 
-从坐标点 `(rCenter, cCenter)` 往上下左右 4 个方向进行搜索，将搜索到的坐标点添加到结果列表 ans 中，并记录访问过的节点，防止重复搜索。
+我们定义一个队列 $q$，初始时将坐标点 $(rCenter, cCenter)$ 入队，用一个二维布尔数组 $vis$ 记录已经访问过的点，初始时 $vis[rCenter][cCenter]$ 为 $true$。
 
-搜索结束，返回结果列表 ans 即可。
+接下来，我们不断地从队列中取出一个点，将其加入答案数组，然后将其上下左右四个相邻点加入队列，注意要判断这些点是否已经访问过，如果没有访问过，就将其标记为已访问，并将其加入队列。一直重复这个过程，直到队列为空，此时答案数组中的点就是按照距离从小到大的顺序排列的。
+
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
 
 <!-- tabs:start -->
 
@@ -71,19 +73,19 @@ class Solution:
     def allCellsDistOrder(
         self, rows: int, cols: int, rCenter: int, cCenter: int
     ) -> List[List[int]]:
-        q = deque([(rCenter, cCenter)])
+        q = deque([[rCenter, cCenter]])
         vis = [[False] * cols for _ in range(rows)]
         vis[rCenter][cCenter] = True
         ans = []
         while q:
             for _ in range(len(q)):
-                i, j = q.popleft()
-                ans.append([i, j])
-                for a, b in [[1, 0], [-1, 0], [0, 1], [0, -1]]:
-                    x, y = i + a, j + b
+                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]:
-                        q.append((x, y))
                         vis[x][y] = True
+                        q.append([x, y])
         return ans
 ```
 
@@ -92,25 +94,26 @@ class Solution:
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+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});
+        q.offer(new int[]{rCenter, cCenter});
         boolean[][] vis = new boolean[rows][cols];
         vis[rCenter][cCenter] = true;
         int[][] ans = new int[rows * cols][2];
-        int idx = 0;
         int[] dirs = {-1, 0, 1, 0, -1};
+        int idx = 0;
         while (!q.isEmpty()) {
             for (int n = q.size(); n > 0; --n) {
-                int[] p = q.poll();
+                var p = q.poll();
                 ans[idx++] = p;
                 for (int k = 0; k < 4; ++k) {
-                    int x = p[0] + dirs[k];
-                    int y = p[1] + dirs[k + 1];
+                    int x = p[0] + dirs[k], y = p[1] + dirs[k + 1];
                     if (x >= 0 && x < rows && y >= 0 && y < cols && !vis[x][y]) {
-                        q.offer(new int[] {x, y});
                         vis[x][y] = true;
+                        q.offer(new int[]{x, y});
                     }
                 }
             }
@@ -126,22 +129,24 @@ class Solution {
 class Solution {
 public:
     vector<vector<int>> allCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
-        queue<vector<int>> q;
-        q.push({rCenter, cCenter});
-        vector<vector<bool>> vis(rows, vector<bool>(cols));
-        vis[rCenter][cCenter] = true;
+        queue<pair<int, int>> q;
+        q.emplace(rCenter, cCenter);
         vector<vector<int>> ans;
-        vector<int> dirs = {-1, 0, 1, 0, -1};
+        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 > 0; --n) {
-                auto p = q.front();
+            for (int n = q.size(); n; --n) {
+                auto [i, j] = q.front();
                 q.pop();
-                ans.push_back(p);
+                ans.push_back({i, j});
                 for (int k = 0; k < 4; ++k) {
-                    int x = p[0] + dirs[k], y = p[1] + dirs[k + 1];
+                    int x = i + dirs[k];
+                    int y = j + dirs[k + 1];
                     if (x >= 0 && x < rows && y >= 0 && y < cols && !vis[x][y]) {
-                        q.push({x, y});
                         vis[x][y] = true;
+                        q.emplace(x, y);
                     }
                 }
             }
@@ -154,15 +159,14 @@ public:
 ### **Go**
 
 ```go
-func allCellsDistOrder(rows int, cols int, rCenter int, cCenter int) [][]int {
+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
-	var ans [][]int
-	dirs := []int{-1, 0, 1, 0, -1}
+	dirs := [5]int{-1, 0, 1, 0, -1}
 	for len(q) > 0 {
 		for n := len(q); n > 0; n-- {
 			p := q[0]
@@ -171,13 +175,13 @@ func allCellsDistOrder(rows int, cols int, rCenter int, cCenter int) [][]int {
 			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] {
-					q = append(q, []int{x, y})
 					vis[x][y] = true
+					q = append(q, []int{x, y})
 				}
 			}
 		}
 	}
-	return ans
+	return
 }
 ```
 

solution/1000-1099/1030.Matrix Cells in Distance Order/README_EN.md

@@ -57,44 +57,45 @@ class Solution:
     def allCellsDistOrder(
         self, rows: int, cols: int, rCenter: int, cCenter: int
     ) -> List[List[int]]:
-        q = deque([(rCenter, cCenter)])
+        q = deque([[rCenter, cCenter]])
         vis = [[False] * cols for _ in range(rows)]
         vis[rCenter][cCenter] = True
         ans = []
         while q:
             for _ in range(len(q)):
-                i, j = q.popleft()
-                ans.append([i, j])
-                for a, b in [[1, 0], [-1, 0], [0, 1], [0, -1]]:
-                    x, y = i + a, j + b
+                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]:
-                        q.append((x, y))
                         vis[x][y] = True
+                        q.append([x, y])
         return ans
 ```
 
 ### **Java**
 
 ```java
+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});
+        q.offer(new int[]{rCenter, cCenter});
         boolean[][] vis = new boolean[rows][cols];
         vis[rCenter][cCenter] = true;
         int[][] ans = new int[rows * cols][2];
-        int idx = 0;
         int[] dirs = {-1, 0, 1, 0, -1};
+        int idx = 0;
         while (!q.isEmpty()) {
             for (int n = q.size(); n > 0; --n) {
-                int[] p = q.poll();
+                var p = q.poll();
                 ans[idx++] = p;
                 for (int k = 0; k < 4; ++k) {
-                    int x = p[0] + dirs[k];
-                    int y = p[1] + dirs[k + 1];
+                    int x = p[0] + dirs[k], y = p[1] + dirs[k + 1];
                     if (x >= 0 && x < rows && y >= 0 && y < cols && !vis[x][y]) {
-                        q.offer(new int[] {x, y});
                         vis[x][y] = true;
+                        q.offer(new int[]{x, y});
                     }
                 }
             }
@@ -110,22 +111,24 @@ class Solution {
 class Solution {
 public:
     vector<vector<int>> allCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
-        queue<vector<int>> q;
-        q.push({rCenter, cCenter});
-        vector<vector<bool>> vis(rows, vector<bool>(cols));
-        vis[rCenter][cCenter] = true;
+        queue<pair<int, int>> q;
+        q.emplace(rCenter, cCenter);
         vector<vector<int>> ans;
-        vector<int> dirs = {-1, 0, 1, 0, -1};
+        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 > 0; --n) {
-                auto p = q.front();
+            for (int n = q.size(); n; --n) {
+                auto [i, j] = q.front();
                 q.pop();
-                ans.push_back(p);
+                ans.push_back({i, j});
                 for (int k = 0; k < 4; ++k) {
-                    int x = p[0] + dirs[k], y = p[1] + dirs[k + 1];
+                    int x = i + dirs[k];
+                    int y = j + dirs[k + 1];
                     if (x >= 0 && x < rows && y >= 0 && y < cols && !vis[x][y]) {
-                        q.push({x, y});
                         vis[x][y] = true;
+                        q.emplace(x, y);
                     }
                 }
             }
@@ -138,15 +141,14 @@ public:
 ### **Go**
 
 ```go
-func allCellsDistOrder(rows int, cols int, rCenter int, cCenter int) [][]int {
+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
-	var ans [][]int
-	dirs := []int{-1, 0, 1, 0, -1}
+	dirs := [5]int{-1, 0, 1, 0, -1}
 	for len(q) > 0 {
 		for n := len(q); n > 0; n-- {
 			p := q[0]
@@ -155,13 +157,13 @@ func allCellsDistOrder(rows int, cols int, rCenter int, cCenter int) [][]int {
 			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] {
-					q = append(q, []int{x, y})
 					vis[x][y] = true
+					q = append(q, []int{x, y})
 				}
 			}
 		}
 	}
-	return ans
+	return
 }
 ```
 

solution/1000-1099/1030.Matrix Cells in Distance Order/Solution.cpp

@@ -1,22 +1,24 @@
 class Solution {
 public:
     vector<vector<int>> allCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
-        queue<vector<int>> q;
-        q.push({rCenter, cCenter});
-        vector<vector<bool>> vis(rows, vector<bool>(cols));
-        vis[rCenter][cCenter] = true;
+        queue<pair<int, int>> q;
+        q.emplace(rCenter, cCenter);
         vector<vector<int>> ans;
-        vector<int> dirs = {-1, 0, 1, 0, -1};
+        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 > 0; --n) {
-                auto p = q.front();
+            for (int n = q.size(); n; --n) {
+                auto [i, j] = q.front();
                 q.pop();
-                ans.push_back(p);
+                ans.push_back({i, j});
                 for (int k = 0; k < 4; ++k) {
-                    int x = p[0] + dirs[k], y = p[1] + dirs[k + 1];
+                    int x = i + dirs[k];
+                    int y = j + dirs[k + 1];
                     if (x >= 0 && x < rows && y >= 0 && y < cols && !vis[x][y]) {
-                        q.push({x, y});
                         vis[x][y] = true;
+                        q.emplace(x, y);
                     }
                 }
             }

solution/1000-1099/1030.Matrix Cells in Distance Order/Solution.go

@@ -1,12 +1,11 @@
-func allCellsDistOrder(rows int, cols int, rCenter int, cCenter int) [][]int {
+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
-	var ans [][]int
-	dirs := []int{-1, 0, 1, 0, -1}
+	dirs := [5]int{-1, 0, 1, 0, -1}
 	for len(q) > 0 {
 		for n := len(q); n > 0; n-- {
 			p := q[0]
@@ -15,11 +14,11 @@ func allCellsDistOrder(rows int, cols int, rCenter int, cCenter int) [][]int {
 			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] {
-					q = append(q, []int{x, y})
 					vis[x][y] = true
+					q = append(q, []int{x, y})
 				}
 			}
 		}
 	}
-	return ans
+	return
 }

solution/1000-1099/1030.Matrix Cells in Distance Order/Solution.java

@@ -1,22 +1,23 @@
+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});
+        q.offer(new int[]{rCenter, cCenter});
         boolean[][] vis = new boolean[rows][cols];
         vis[rCenter][cCenter] = true;
         int[][] ans = new int[rows * cols][2];
-        int idx = 0;
         int[] dirs = {-1, 0, 1, 0, -1};
+        int idx = 0;
         while (!q.isEmpty()) {
             for (int n = q.size(); n > 0; --n) {
-                int[] p = q.poll();
+                var p = q.poll();
                 ans[idx++] = p;
                 for (int k = 0; k < 4; ++k) {
-                    int x = p[0] + dirs[k];
-                    int y = p[1] + dirs[k + 1];
+                    int x = p[0] + dirs[k], y = p[1] + dirs[k + 1];
                     if (x >= 0 && x < rows && y >= 0 && y < cols && !vis[x][y]) {
-                        q.offer(new int[] {x, y});
                         vis[x][y] = true;
+                        q.offer(new int[]{x, y});
                     }
                 }
             }

solution/1000-1099/1030.Matrix Cells in Distance Order/Solution.py

@@ -2,17 +2,17 @@ class Solution:
     def allCellsDistOrder(
         self, rows: int, cols: int, rCenter: int, cCenter: int
     ) -> List[List[int]]:
-        q = deque([(rCenter, cCenter)])
+        q = deque([[rCenter, cCenter]])
         vis = [[False] * cols for _ in range(rows)]
         vis[rCenter][cCenter] = True
         ans = []
         while q:
             for _ in range(len(q)):
-                i, j = q.popleft()
-                ans.append([i, j])
-                for a, b in [[1, 0], [-1, 0], [0, 1], [0, -1]]:
-                    x, y = i + a, j + b
+                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]:
-                        q.append((x, y))
                         vis[x][y] = True
+                        q.append([x, y])
         return ans