feat: add solutions to lc problem: No.1162

No.1162.As Far from Land as Possible

Author: yanglbme

solution/1100-1199/1161.Maximum Level Sum of a Binary Tree/README.md

@@ -50,8 +50,14 @@
 
 BFS 层次遍历，求每一层的节点和，找出节点和最大的层，若有多个层的节点和最大，则返回最小的层。
 
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点数。
+
 **方法二：DFS**
 
+我们也可以使用 DFS 求解。我们用一个数组 $s$ 来存储每一层的节点和，数组的下标表示层数，数组的值表示节点和。我们使用 DFS 遍历二叉树，将每个节点的值加到对应层数的节点和上。最后，我们返回 $s$ 中的最大值对应的下标即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点数。
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1100-1199/1162.As Far from Land as Possible/README.md

@@ -53,7 +53,17 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-BFS。
+**方法一：BFS**
+
+我们可以将所有陆地单元格加入队列 $q$ 中，如果队列为空，或者队列中元素个数等于网格中的单元格个数，则说明网格中只有陆地或者海洋，返回 $-1$。
+
+否则，我们从陆地单元格开始进行广度优先搜索。定义初始步数 $ans=-1$。
+
+在每一轮搜索中，我们将队列中的所有单元格向四个方向扩散，若单元格是海洋单元格，则将其标记为陆地单元格，并加入队列。在一轮扩散完成后，我们将步数加 $1$。重复这一过程，直到队列为空。
+
+最后，我们返回步数 $ans$。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 是网格的边长。
 
 <!-- tabs:start -->
 
@@ -89,7 +99,7 @@ class Solution:
 class Solution {
     public int maxDistance(int[][] grid) {
         int n = grid.length;
-        Deque<int[]> q = new LinkedList<>();
+        Deque<int[]> q = new ArrayDeque<>();
         for (int i = 0; i < n; ++i) {
             for (int j = 0; j < n; ++j) {
                 if (grid[i][j] == 1) {
@@ -98,65 +108,25 @@ class Solution {
             }
         }
         int ans = -1;
-        boolean valid = false;
+        if (q.isEmpty() || q.size() == n * n) {
+            return ans;
+        }
         int[] dirs = {-1, 0, 1, 0, -1};
         while (!q.isEmpty()) {
-            ++ans;
-            for (int k = q.size(); k > 0; --k) {
+            for (int i = q.size(); i > 0; --i) {
                 int[] p = q.poll();
-                for (int i = 0; i < 4; ++i) {
-                    int x = p[0] + dirs[i];
-                    int y = p[1] + dirs[i + 1];
+                for (int k = 0; k < 4; ++k) {
+                    int x = p[0] + dirs[k], y = p[1] + dirs[k + 1];
                     if (x >= 0 && x < n && y >= 0 && y < n && grid[x][y] == 0) {
-                        valid = true;
                         grid[x][y] = 1;
                         q.offer(new int[] {x, y});
                     }
                 }
             }
+            ++ans;
         }
-        return valid ? ans : -1;
-    }
-}
-```
-
-### **TypeScript**
-
-```ts
-function maxDistance(grid: number[][]): number {
-    const m = grid.length,
-        n = grid[0].length;
-    let queue: Array<Array<number>> = [];
-    for (let i = 0; i < m; i++) {
-        for (let j = 0; j < n; j++) {
-            if (grid[i][j]) {
-                queue.push([i, j]);
-            }
-        }
-    }
-    if ([0, m * n].includes(queue.length)) return -1;
-    const directions = [
-        [0, 1],
-        [0, -1],
-        [1, 0],
-        [-1, 0],
-    ];
-    let depth = 1;
-    while (queue.length) {
-        depth += 1;
-        let nextLevel: Array<Array<number>> = [];
-        for (let [x, y] of queue) {
-            for (let [dx, dy] of directions) {
-                const [i, j] = [x + dx, y + dy];
-                if (i >= 0 && i < m && j >= 0 && j < n && !grid[i][j]) {
-                    grid[i][j] = depth;
-                    nextLevel.push([i, j]);
-                }
-            }
-        }
-        queue = nextLevel;
+        return ans;
     }
-    return depth - 2;
 }
 ```
 
@@ -167,32 +137,34 @@ class Solution {
 public:
     int maxDistance(vector<vector<int>>& grid) {
         int n = grid.size();
-        typedef pair<int, int> pii;
-        queue<pii> q;
-        for (int i = 0; i < n; ++i)
-            for (int j = 0; j < n; ++j)
-                if (grid[i][j] == 1)
-                    q.push({i, j});
+        queue<pair<int, int>> q;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j]) {
+                    q.emplace(i, j);
+                }
+            }
+        }
         int ans = -1;
-        bool valid = false;
-        vector<int> dirs = {-1, 0, 1, 0, -1};
+        if (q.empty() || q.size() == n * n) {
+            return ans;
+        }
+        int dirs[5] = {-1, 0, 1, 0, -1};
         while (!q.empty()) {
-            ++ans;
-            for (int k = q.size(); k > 0; --k) {
-                pii p = q.front();
+            for (int m = q.size(); m; --m) {
+                auto [i, j] = q.front();
                 q.pop();
-                for (int i = 0; i < 4; ++i) {
-                    int x = p.first + dirs[i];
-                    int y = p.second + dirs[i + 1];
-                    if (x >= 0 && x < n && y >= 0 && y < n && grid[x][y] == 0) {
-                        valid = true;
+                for (int k = 0; k < 4; ++k) {
+                    int x = i + dirs[k], y = j + dirs[k + 1];
+                    if (x >= 0 && x < n && y >= 0 && y < n && !grid[x][y]) {
                         grid[x][y] = 1;
-                        q.push({x, y});
+                        q.emplace(x, y);
                     }
                 }
             }
+            ++ans;
         }
-        return valid ? ans : -1;
+        return ans;
     }
 };
 ```
@@ -202,36 +174,70 @@ public:
 ```go
 func maxDistance(grid [][]int) int {
 	n := len(grid)
-	var q [][]int
-	for i := 0; i < n; i++ {
-		for j := 0; j < n; j++ {
-			if grid[i][j] == 1 {
-				q = append(q, []int{i, j})
+	q := [][2]int{}
+	for i, row := range grid {
+		for j, v := range row {
+			if v == 1 {
+				q = append(q, [2]int{i, j})
 			}
 		}
 	}
 	ans := -1
-	valid := false
-	dirs := []int{-1, 0, 1, 0, -1}
+	if len(q) == 0 || len(q) == n*n {
+		return ans
+	}
+	dirs := [5]int{-1, 0, 1, 0, -1}
 	for len(q) > 0 {
-		ans++
-		for k := len(q); k > 0; k-- {
+		for i := len(q); i > 0; i-- {
 			p := q[0]
 			q = q[1:]
-			for i := 0; i < 4; i++ {
-				x, y := p[0]+dirs[i], p[1]+dirs[i+1]
+			for k := 0; k < 4; k++ {
+				x, y := p[0]+dirs[k], p[1]+dirs[k+1]
 				if x >= 0 && x < n && y >= 0 && y < n && grid[x][y] == 0 {
-					valid = true
 					grid[x][y] = 1
-					q = append(q, []int{x, y})
+					q = append(q, [2]int{x, y})
 				}
 			}
 		}
+		ans++
 	}
-	if valid {
-		return ans
-	}
-	return -1
+	return ans
+}
+```
+
+### **TypeScript**
+
+```ts
+function maxDistance(grid: number[][]): number {
+    const n = grid.length;
+    const q: [number, number][] = [];
+    for (let i = 0; i < n; ++i) {
+        for (let j = 0; j < n; ++j) {
+            if (grid[i][j] === 1) {
+                q.push([i, j]);
+            }
+        }
+    }
+    let ans = -1;
+    if (q.length === 0 || q.length === n * n) {
+        return ans;
+    }
+    const dirs: number[] = [-1, 0, 1, 0, -1];
+    while (q.length > 0) {
+        for (let m = q.length; m; --m) {
+            const [i, j] = q.shift()!;
+            for (let k = 0; k < 4; ++k) {
+                const x = i + dirs[k];
+                const y = j + dirs[k + 1];
+                if (x >= 0 && x < n && y >= 0 && y < n && grid[x][y] === 0) {
+                    grid[x][y] = 1;
+                    q.push([x, y]);
+                }
+            }
+        }
+        ++ans;
+    }
+    return ans;
 }
 ```