feat: add solutions to lc problem: No.1765

No.1765.Map of Highest Peak

Author: yanglbme

solution/1700-1799/1764.Form Array by Concatenating Subarrays of Another Array/README.md

@@ -65,7 +65,7 @@
 
 如果 $i$ 走到了 $groups.length$，说明所有的子数组都匹配上了，返回 `true`，否则返回 `false`。
 
-时间复杂度 $O(n \times m)，空间复杂度 O(1)$。其中 $n$ 和 $m$ 分别为 `groups` 和 `nums` 的长度。
+时间复杂度 $O(n \times m)$，空间复杂度 $O(1)$。其中 $n$ 和 $m$ 分别为 `groups` 和 `nums` 的长度。
 
 <!-- tabs:start -->
 

solution/1700-1799/1765.Map of Highest Peak/README.md

@@ -65,7 +65,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-多源 BFS。
+**方法一：BFS**
+
+根据题目描述，水域的高度必须是 $0$，而任意相邻格子的高度差至多为 $1$。因此，我们可以从所有水域格子出发，用 BFS 搜索相邻且未访问过的格子，将其高度置为当前格子的高度再加一。
+
+最后返回结果矩阵即可。
+
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是整数矩阵 `isWater` 的行数和列数。
 
 <!-- tabs:start -->
 
@@ -79,52 +85,70 @@ class Solution:
         m, n = len(isWater), len(isWater[0])
         ans = [[-1] * n for _ in range(m)]
         q = deque()
-        for i in range(m):
-            for j in range(n):
-                if isWater[i][j] == 1:
-                    ans[i][j] = 0
+        for i, row in enumerate(isWater):
+            for j, v in enumerate(row):
+                if v:
                     q.append((i, j))
+                    ans[i][j] = 0
         while q:
             i, j = q.popleft()
-            for a, b in [[0, -1], [0, 1], [1, 0], [-1, 0]]:
+            for a, b in pairwise((-1, 0, 1, 0, -1)):
                 x, y = i + a, j + b
                 if 0 <= x < m and 0 <= y < n and ans[x][y] == -1:
                     ans[x][y] = ans[i][j] + 1
                     q.append((x, y))
         return ans
 ```
 
+```python
+class Solution:
+    def highestPeak(self, isWater: List[List[int]]) -> List[List[int]]:
+        m, n = len(isWater), len(isWater[0])
+        ans = [[-1] * n for _ in range(m)]
+        q = deque()
+        for i, row in enumerate(isWater):
+            for j, v in enumerate(row):
+                if v:
+                    q.append((i, j))
+                    ans[i][j] = 0
+        while q:
+            for _ in range(len(q)):
+                i, j = q.popleft()
+                for a, b in pairwise((-1, 0, 1, 0, -1)):
+                    x, y = i + a, j + b
+                    if 0 <= x < m and 0 <= y < n and ans[x][y] == -1:
+                        ans[x][y] = ans[i][j] + 1
+                        q.append((x, y))
+        return ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
 class Solution {
-    private int[][] dirs = new int[][] {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
-
     public int[][] highestPeak(int[][] isWater) {
         int m = isWater.length, n = isWater[0].length;
         int[][] ans = new int[m][n];
-        for (int i = 0; i < m; ++i) {
-            Arrays.fill(ans[i], -1);
-        }
-        Deque<int[]> q = new LinkedList<>();
+        Deque<int[]> q = new ArrayDeque<>();
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                if (isWater[i][j] == 1) {
-                    ans[i][j] = 0;
-                    q.offerLast(new int[] {i, j});
+                ans[i][j] = isWater[i][j] - 1;
+                if (ans[i][j] == 0) {
+                    q.offer(new int[] {i, j});
                 }
             }
         }
+        int[] dirs = {-1, 0, 1, 0, -1};
         while (!q.isEmpty()) {
-            int[] p = q.pollFirst();
+            var p = q.poll();
             int i = p[0], j = p[1];
-            for (int[] dir : dirs) {
-                int x = i + dir[0], y = j + dir[1];
+            for (int k = 0; k < 4; ++k) {
+                int x = i + dirs[k], y = j + dirs[k + 1];
                 if (x >= 0 && x < m && y >= 0 && y < n && ans[x][y] == -1) {
                     ans[x][y] = ans[i][j] + 1;
-                    q.offerLast(new int[] {x, y});
+                    q.offer(new int[] {x, y});
                 }
             }
         }
@@ -133,84 +157,106 @@ class Solution {
 }
 ```
 
-### **TypeScript**
-
-```ts
-function highestPeak(isWater: number[][]): number[][] {
-    const m = isWater.length,
-        n = isWater[0].length;
-    let ans: Array<Array<number>> = Array.from({ length: m }, v =>
-        new Array(n).fill(-1),
-    );
-    // BFS
-    let queue: Array<Array<number>> = []; // i, j, num
-    for (let i = 0; i < m; i++) {
-        for (let j = 0; j < n; j++) {
-            if (isWater[i][j]) {
-                ans[i][j] = 0;
-                queue.push([i, j, 0]);
+```java
+class Solution {
+    public int[][] highestPeak(int[][] isWater) {
+        int m = isWater.length, n = isWater[0].length;
+        int[][] ans = new int[m][n];
+        Deque<int[]> q = new ArrayDeque<>();
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                ans[i][j] = isWater[i][j] - 1;
+                if (ans[i][j] == 0) {
+                    q.offer(new int[] {i, j});
+                }
             }
         }
-    }
-    const directions = [
-        [0, -1],
-        [-1, 0],
-        [0, 1],
-        [1, 0],
-    ]; // left, up, right, down
-    while (queue.length) {
-        // 消除push/shift出现超时问题
-        let tmp: Array<Array<number>> = [];
-        for (const [i, j, num] of queue) {
-            for (const [dx, dy] of directions) {
-                const x = i + dx,
-                    y = j + dy;
-                // 校验合法的相邻格子
-                if (x > -1 && x < m && y > -1 && y < n && ans[x][y] == -1) {
-                    ans[x][y] = num + 1;
-                    tmp.push([x, y, num + 1]);
+        int[] dirs = {-1, 0, 1, 0, -1};
+        while (!q.isEmpty()) {
+            for (int t = q.size(); t > 0; --t) {
+                var p = q.poll();
+                int i = p[0], j = p[1];
+                for (int k = 0; k < 4; ++k) {
+                    int x = i + dirs[k], y = j + dirs[k + 1];
+                    if (x >= 0 && x < m && y >= 0 && y < n && ans[x][y] == -1) {
+                        ans[x][y] = ans[i][j] + 1;
+                        q.offer(new int[] {x, y});
+                    }
                 }
             }
+
         }
-        queue = tmp;
+        return ans;
     }
-    return ans;
 }
 ```
 
 ### **C++**
 
 ```cpp
-typedef pair<int, int> PII;
-
 class Solution {
 public:
-    vector<vector<int>> dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+    const int dirs[5] = {-1, 0, 1, 0, -1};
 
     vector<vector<int>> highestPeak(vector<vector<int>>& isWater) {
         int m = isWater.size(), n = isWater[0].size();
-        vector<vector<int>> ans(m, vector<int>(n, -1));
-        queue<PII> q;
+        vector<vector<int>> ans(m, vector<int>(n));
+        queue<pair<int, int>> q;
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                if (isWater[i][j] == 1) {
-                    ans[i][j] = 0;
-                    q.push({i, j});
+                ans[i][j] = isWater[i][j] - 1;
+                if (ans[i][j] == 0) {
+                    q.emplace(i, j);
                 }
             }
         }
         while (!q.empty()) {
-            PII p = q.front();
+            auto [i, j] = q.front();
             q.pop();
-            int i = p.first, j = p.second;
-            for (auto& dir : dirs) {
-                int x = i + dir[0], y = j + dir[1];
+            for (int k = 0; k < 4; ++k) {
+                int x = i + dirs[k], y = j + dirs[k + 1];
                 if (x >= 0 && x < m && y >= 0 && y < n && ans[x][y] == -1) {
                     ans[x][y] = ans[i][j] + 1;
-                    q.push({x, y});
+                    q.emplace(x, y);
+                }
+            }
+        }
+        return ans;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    const int dirs[5] = {-1, 0, 1, 0, -1};
+
+    vector<vector<int>> highestPeak(vector<vector<int>>& isWater) {
+        int m = isWater.size(), n = isWater[0].size();
+        vector<vector<int>> ans(m, vector<int>(n));
+        queue<pair<int, int>> q;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                ans[i][j] = isWater[i][j] - 1;
+                if (ans[i][j] == 0) {
+                    q.emplace(i, j);
                 }
             }
         }
+        while (!q.empty()) {
+            for (int t = q.size(); t; --t) {
+                auto [i, j] = q.front();
+                q.pop();
+                for (int k = 0; k < 4; ++k) {
+                    int x = i + dirs[k], y = j + dirs[k + 1];
+                    if (x >= 0 && x < m && y >= 0 && y < n && ans[x][y] == -1) {
+                        ans[x][y] = ans[i][j] + 1;
+                        q.emplace(x, y);
+                    }
+                }
+            }
+
+        }
         return ans;
     }
 };
@@ -222,30 +268,26 @@ public:
 func highestPeak(isWater [][]int) [][]int {
 	m, n := len(isWater), len(isWater[0])
 	ans := make([][]int, m)
-	for i := range ans {
-		ans[i] = make([]int, n)
-		for j := range ans[i] {
-			ans[i][j] = -1
-		}
-	}
 	type pair struct{ i, j int }
-	var q []pair
-	for i := 0; i < m; i++ {
-		for j := 0; j < n; j++ {
-			if isWater[i][j] == 1 {
-				ans[i][j] = 0
+	q := []pair{}
+	for i, row := range isWater {
+		ans[i] = make([]int, n)
+		for j, v := range row {
+			ans[i][j] = v - 1
+			if v == 1 {
 				q = append(q, pair{i, j})
 			}
 		}
 	}
-	dirs := [4][2]int{{0, -1}, {0, 1}, {1, 0}, {-1, 0}}
+	dirs := []int{-1, 0, 1, 0, -1}
 	for len(q) > 0 {
 		p := q[0]
 		q = q[1:]
-		for _, dir := range dirs {
-			x, y := p.i+dir[0], p.j+dir[1]
+		i, j := p.i, p.j
+		for k := 0; k < 4; k++ {
+			x, y := i+dirs[k], j+dirs[k+1]
 			if x >= 0 && x < m && y >= 0 && y < n && ans[x][y] == -1 {
-				ans[x][y] = ans[p.i][p.j] + 1
+				ans[x][y] = ans[i][j] + 1
 				q = append(q, pair{x, y})
 			}
 		}
@@ -254,6 +296,75 @@ func highestPeak(isWater [][]int) [][]int {
 }
 ```
 
+```go
+func highestPeak(isWater [][]int) [][]int {
+	m, n := len(isWater), len(isWater[0])
+	ans := make([][]int, m)
+	type pair struct{ i, j int }
+	q := []pair{}
+	for i, row := range isWater {
+		ans[i] = make([]int, n)
+		for j, v := range row {
+			ans[i][j] = v - 1
+			if v == 1 {
+				q = append(q, pair{i, j})
+			}
+		}
+	}
+	dirs := []int{-1, 0, 1, 0, -1}
+	for len(q) > 0 {
+		for t := len(q); t > 0; t-- {
+			p := q[0]
+			q = q[1:]
+			i, j := p.i, p.j
+			for k := 0; k < 4; k++ {
+				x, y := i+dirs[k], j+dirs[k+1]
+				if x >= 0 && x < m && y >= 0 && y < n && ans[x][y] == -1 {
+					ans[x][y] = ans[i][j] + 1
+					q = append(q, pair{x, y})
+				}
+			}
+		}
+	}
+	return ans
+}
+```
+
+### **TypeScript**
+
+```ts
+function highestPeak(isWater: number[][]): number[][] {
+    const m = isWater.length;
+    const n = isWater[0].length;
+    let ans: number[][] = [];
+    let q: number[][] = [];
+    for (let i = 0; i < m; ++i) {
+        ans.push(new Array(n).fill(-1));
+        for (let j = 0; j < n; ++j) {
+            if (isWater[i][j]) {
+                q.push([i, j]);
+                ans[i][j] = 0;
+            }
+        }
+    }
+    const dirs = [-1, 0, 1, 0, -1];
+    while (q.length) {
+        let tq: number[][] = [];
+        for (const [i, j] of q) {
+            for (let k = 0; k < 4; k++) {
+                const [x, y] = [i + dirs[k], j + dirs[k + 1]];
+                if (x >= 0 && x < m && y >= 0 && y < n && ans[x][y] == -1) {
+                    tq.push([x, y]);
+                    ans[x][y] = ans[i][j] + 1;
+                }
+            }
+        }
+        q = tq;
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```