Merge branch 'doocs:main' into main

Author: Nothing-avil

lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/README.md

@@ -317,6 +317,51 @@ var convertBST = function (root) {
 };
 ```
 
+#### Swift
+
+```swift
+/* class TreeNode {
+*     var val: Int
+*     var left: TreeNode?
+*     var right: TreeNode?
+*     init() {
+*         self.val = 0
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int) {
+*         self.val = val
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+*         self.val = val
+*         self.left = left
+*         self.right = right
+*     }
+* }
+*/
+
+class Solution {
+    private var s = 0
+
+    func convertBST(_ root: TreeNode?) -> TreeNode? {
+        dfs(root)
+        return root
+    }
+
+    private func dfs(_ root: TreeNode?) {
+        guard let node = root else {
+            return
+        }
+        dfs(node.right)
+        s += node.val
+        node.val = s
+        dfs(node.left)
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

lcof2/剑指 Offer II 054. 所有大于等于节点的值之和/Solution.swift

@@ -0,0 +1,40 @@
+/* class TreeNode {
+*     var val: Int
+*     var left: TreeNode?
+*     var right: TreeNode?
+*     init() {
+*         self.val = 0
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int) {
+*         self.val = val
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+*         self.val = val
+*         self.left = left
+*         self.right = right
+*     }
+* }
+*/
+
+class Solution {
+    private var s = 0
+
+    func convertBST(_ root: TreeNode?) -> TreeNode? {
+        dfs(root)
+        return root
+    }
+
+    private func dfs(_ root: TreeNode?) {
+        guard let node = root else {
+            return
+        }
+        dfs(node.right)
+        s += node.val
+        node.val = s
+        dfs(node.left)
+    }
+}

lcof2/剑指 Offer II 055. 二叉搜索树迭代器/README.md

@@ -431,6 +431,60 @@ BSTIterator.prototype.hasNext = function () {
  */
 ```
 
+#### Swift
+
+```swift
+/* class TreeNode {
+*     var val: Int
+*     var left: TreeNode?
+*     var right: TreeNode?
+*     init() {
+*         self.val = 0
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int) {
+*         self.val = val
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+*         self.val = val
+*         self.left = left
+*         self.right = right
+*     }
+* }
+*/
+
+class BSTIterator {
+    private var cur = 0
+    private var vals = [Int]()
+
+    init(_ root: TreeNode?) {
+        inorder(root)
+    }
+
+    func next() -> Int {
+        let value = vals[cur]
+        cur += 1
+        return value
+    }
+
+    func hasNext() -> Bool {
+        return cur < vals.count
+    }
+
+    private func inorder(_ root: TreeNode?) {
+        guard let node = root else {
+            return
+        }
+        inorder(node.left)
+        vals.append(node.val)
+        inorder(node.right)
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

lcof2/剑指 Offer II 055. 二叉搜索树迭代器/Solution.swift

@@ -0,0 +1,49 @@
+/* class TreeNode {
+*     var val: Int
+*     var left: TreeNode?
+*     var right: TreeNode?
+*     init() {
+*         self.val = 0
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int) {
+*         self.val = val
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+*         self.val = val
+*         self.left = left
+*         self.right = right
+*     }
+* }
+*/
+
+class BSTIterator {
+    private var cur = 0
+    private var vals = [Int]()
+
+    init(_ root: TreeNode?) {
+        inorder(root)
+    }
+
+    func next() -> Int {
+        let value = vals[cur]
+        cur += 1
+        return value
+    }
+
+    func hasNext() -> Bool {
+        return cur < vals.count
+    }
+
+    private func inorder(_ root: TreeNode?) {
+        guard let node = root else {
+            return
+        }
+        inorder(node.left)
+        vals.append(node.val)
+        inorder(node.right)
+    }
+}

lcof2/剑指 Offer II 056. 二叉搜索树中两个节点之和/README.md

@@ -208,6 +208,52 @@ function find(root: TreeNode | null, k: number, nodes: Set<number>): boolean {
 }
 ```
 
+#### Swift
+
+```swift
+/* class TreeNode {
+*     var val: Int
+*     var left: TreeNode?
+*     var right: TreeNode?
+*     init() {
+*         self.val = 0
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int) {
+*         self.val = val
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+*         self.val = val
+*         self.left = left
+*         self.right = right
+*     }
+* }
+*/
+
+class Solution {
+    private var nodes: Set<Int> = []
+
+    func findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
+        nodes = []
+        return find(root, k)
+    }
+
+    private func find(_ root: TreeNode?, _ k: Int) -> Bool {
+        guard let node = root else {
+            return false
+        }
+        if nodes.contains(k - node.val) {
+            return true
+        }
+        nodes.insert(node.val)
+        return find(node.left, k) || find(node.right, k)
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

lcof2/剑指 Offer II 056. 二叉搜索树中两个节点之和/Solution.swift

@@ -0,0 +1,41 @@
+/* class TreeNode {
+*     var val: Int
+*     var left: TreeNode?
+*     var right: TreeNode?
+*     init() {
+*         self.val = 0
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int) {
+*         self.val = val
+*         self.left = nil
+*         self.right = nil
+*     }
+*     init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+*         self.val = val
+*         self.left = left
+*         self.right = right
+*     }
+* }
+*/
+
+class Solution {
+    private var nodes: Set<Int> = []
+
+    func findTarget(_ root: TreeNode?, _ k: Int) -> Bool {
+        nodes = []
+        return find(root, k)
+    }
+
+    private func find(_ root: TreeNode?, _ k: Int) -> Bool {
+        guard let node = root else {
+            return false
+        }
+        if nodes.contains(k - node.val) {
+            return true
+        }
+        nodes.insert(node.val)
+        return find(node.left, k) || find(node.right, k)
+    }
+}

solution/0100-0199/0130.Surrounded Regions/README.md

@@ -20,35 +20,46 @@ tags:
 
 <!-- description:start -->
 
-给你一个 <code>m x n</code> 的矩阵 <code>board</code> ，由若干字符 <code>'X'</code> 和 <code>'O'</code> ，找到所有被 <code>'X'</code> 围绕的区域，并将这些区域里所有的  <code>'O'</code> 用 <code>'X'</code> 填充。
+<p>给你一个 <code>m x n</code> 的矩阵 <code>board</code> ，由若干字符 <code>'X'</code> 和 <code>'O'</code>&nbsp;组成，<strong>捕获</strong> 所有 <strong>被围绕的区域</strong>：</p>
+
+<ul>
+	<li><strong>连接：</strong>一个单元格与水平或垂直方向上相邻的单元格连接。</li>
+	<li><strong>区域：连接所有&nbsp;</strong><code>'0'</code>&nbsp;的单元格来形成一个区域。</li>
+	<li><strong>围绕：</strong>如果您可以用&nbsp;<code>'X'</code>&nbsp;单元格 <strong>连接这个区域</strong>，并且区域中没有任何单元格位于&nbsp;<code>board</code> 边缘，则该区域被 <code>'X'</code>&nbsp;单元格围绕。</li>
+</ul>
 
 <div class="original__bRMd">
 <div>
-<p> </p>
+<p>&nbsp;</p>
 
-<p><strong>示例 1：</strong></p>
-<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0130.Surrounded%20Regions/images/xogrid.jpg" style="width: 550px; height: 237px;" />
-<pre>
-<strong>输入：</strong>board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
-<strong>输出：</strong>[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
-<strong>解释：</strong>被围绕的区间不会存在于边界上，换句话说，任何边界上的 <code>'O'</code> 都不会被填充为 <code>'X'</code>。 任何不在边界上，或不与边界上的 <code>'O'</code> 相连的 <code>'O'</code> 最终都会被填充为 <code>'X'</code>。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
-</pre>
+<p><strong class="example">示例 1：</strong></p>
 
-<p><strong>示例 2：</strong></p>
+<div class="example-block">
+<p><strong>输入：</strong><span class="example-io">board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]</span></p>
 
-<pre>
-<strong>输入：</strong>board = [["X"]]
-<strong>输出：</strong>[["X"]]
-</pre>
+<p><b>输出：</b><span class="example-io">[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]</span></p>
+
+<p><strong>解释：</strong></p>
+<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0130.Surrounded%20Regions/images/1718167191-XNjUTG-image.png" style="width: 367px; height: 158px;" />
+<p>在上图中，底部的区域没有被捕获，因为它在 board 的边缘并且不能被围绕。</p>
+</div>
+
+<p><strong class="example">示例 2：</strong></p>
+
+<div class="example-block">
+<p><strong>输入：</strong><span class="example-io">board = [["X"]]</span></p>
+
+<p><strong>输出：</strong><span class="example-io">[["X"]]</span></p>
+</div>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
 <ul>
 	<li><code>m == board.length</code></li>
 	<li><code>n == board[i].length</code></li>
-	<li><code>1 <= m, n <= 200</code></li>
+	<li><code>1 &lt;= m, n &lt;= 200</code></li>
 	<li><code>board[i][j]</code> 为 <code>'X'</code> 或 <code>'O'</code></li>
 </ul>
 </div>