From cb9748a5997e9c822208c88fca70cc072f56b1b8 Mon Sep 17 00:00:00 2001
From: thinkasany <480968828@qq.com>
Date: Fri, 1 Sep 2023 00:34:35 +0800
Subject: [PATCH 1/2] feat: add js solution to lc problem: No.270

---
 .../README.md                                 | 34 +++++++++++++++++++
 .../README_EN.md                              | 34 +++++++++++++++++++
 2 files changed, 68 insertions(+)

diff --git a/solution/0200-0299/0270.Closest Binary Search Tree Value/README.md b/solution/0200-0299/0270.Closest Binary Search Tree Value/README.md
index 28d329386d2f7..96902429a8ae1 100644
--- a/solution/0200-0299/0270.Closest Binary Search Tree Value/README.md	
+++ b/solution/0200-0299/0270.Closest Binary Search Tree Value/README.md	
@@ -144,6 +144,40 @@ var closestValue = function (root, target) {
 };
 ```
 
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} target
+ * @return {number}
+ */
+var closestValue = function (root, target) {
+    let mi = Infinity,
+        ans = root.val;
+    const dfs = (root, target) => {
+        if (!root) {
+            return;
+        }
+        dfs(root.left, target);
+        const t = Math.abs(root.val - target);
+        if (t < mi) {
+            mi = t;
+            ans = root.val;
+        }
+        dfs(root.right, target);
+    };
+    dfs(root, target);
+    return ans;
+};
+```
+
 ### **C++**
 
 ```cpp
diff --git a/solution/0200-0299/0270.Closest Binary Search Tree Value/README_EN.md b/solution/0200-0299/0270.Closest Binary Search Tree Value/README_EN.md
index e5d0b4bd596e9..29ae7393308b5 100644
--- a/solution/0200-0299/0270.Closest Binary Search Tree Value/README_EN.md	
+++ b/solution/0200-0299/0270.Closest Binary Search Tree Value/README_EN.md	
@@ -134,6 +134,40 @@ var closestValue = function (root, target) {
 };
 ```
 
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} target
+ * @return {number}
+ */
+var closestValue = function (root, target) {
+    let mi = Infinity,
+        ans = root.val;
+    const dfs = (root, target) => {
+        if (!root) {
+            return;
+        }
+        dfs(root.left, target);
+        const t = Math.abs(root.val - target);
+        if (t < mi) {
+            mi = t;
+            ans = root.val;
+        }
+        dfs(root.right, target);
+    };
+    dfs(root, target);
+    return ans;
+};
+```
+
 ### **C++**
 
 ```cpp

From 36673be08ec3b5216918de3f22ef93e1759df4dc Mon Sep 17 00:00:00 2001
From: Yang Libin <contact@yanglibin.info>
Date: Fri, 1 Sep 2023 01:03:54 +0000
Subject: [PATCH 2/2] feat: add solutions to lc problem: No.0270

No.0270.Closest Binary Search Tree Value
---
 .../README.md                                 | 287 +++++++++++++-----
 .../README_EN.md                              | 271 ++++++++++++-----
 .../Solution.cpp                              |   7 +-
 .../Solution.go                               |   2 +-
 .../Solution.java                             |   2 +-
 .../Solution.js                               |   2 +-
 .../Solution.py                               |   2 +-
 .../README.md                                 |   2 +-
 8 files changed, 428 insertions(+), 147 deletions(-)

diff --git a/solution/0200-0299/0270.Closest Binary Search Tree Value/README.md b/solution/0200-0299/0270.Closest Binary Search Tree Value/README.md
index 96902429a8ae1..bb28af9bfdc1e 100644
--- a/solution/0200-0299/0270.Closest Binary Search Tree Value/README.md	
+++ b/solution/0200-0299/0270.Closest Binary Search Tree Value/README.md	
@@ -38,7 +38,21 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-二分查找。
+**方法一：中序遍历**
+
+我们用一个变量 $mi$ 维护最小的差值，用一个变量 $ans$ 维护答案。初始时 $mi=\infty$, $ans=root.val$。
+
+接下来，进行中序遍历，每次计算当前节点与目标值 $target$ 的差的绝对值 $t$。如果 $t \lt mi$，或者 $t = mi$ 且当前节点的值小于 $ans$，则更新 $mi$ 和 $ans$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉搜索树的节点数。
+
+**方法二：二分查找**
+
+与方法一类似，我们用一个变量 $mi$ 维护最小的差值，用一个变量 $ans$ 维护答案。初始时 $mi=\infty$, $ans=root.val$。
+
+接下来，进行二分查找，每次计算当前节点与目标值 $target$ 的差的绝对值 $t$。如果 $t \lt mi$，或者 $t = mi$ 且当前节点的值小于 $ans$，则更新 $mi$ 和 $ans$。如果当前节点的值大于 $target$，则查找左子树，否则查找右子树。当我们遍历到叶子节点时，就可以结束二分查找了。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 是二叉搜索树的节点数。
 
 <!-- tabs:start -->
 
@@ -46,6 +60,31 @@
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def closestValue(self, root: Optional[TreeNode], target: float) -> int:
+        def dfs(root):
+            if root is None:
+                return
+            dfs(root.left)
+            nonlocal ans, mi
+            t = abs(root.val - target)
+            if t < mi:
+                mi = t
+                ans = root.val
+            dfs(root.right)
+
+        ans, mi = root.val, inf
+        dfs(root)
+        return ans
+```
+
 ```python
 # Definition for a binary tree node.
 # class TreeNode:
@@ -58,7 +97,7 @@ class Solution:
         ans, mi = root.val, inf
         while root:
             t = abs(root.val - target)
-            if t < mi:
+            if t < mi or (t == mi and root.val < ans):
                 mi = t
                 ans = root.val
             if root.val > target:
@@ -72,6 +111,48 @@ class Solution:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    private int ans;
+    private double target;
+    private double mi = Double.MAX_VALUE;
+
+    public int closestValue(TreeNode root, double target) {
+        this.target = target;
+        dfs(root);
+        return ans;
+    }
+
+    private void dfs(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        dfs(root.left);
+        double t = Math.abs(root.val - target);
+        if (t < mi) {
+            mi = t;
+            ans = root.val;
+        }
+        dfs(root.right);
+    }
+}
+```
+
 ```java
 /**
  * Definition for a binary tree node.
@@ -94,7 +175,7 @@ class Solution {
         double mi = Double.MAX_VALUE;
         while (root != null) {
             double t = Math.abs(root.val - target);
-            if (t < mi) {
+            if (t < mi || (t == mi && root.val < ans)) {
                 mi = t;
                 ans = root.val;
             }
@@ -109,77 +190,43 @@ class Solution {
 }
 ```
 
-### **JavaScript**
+### **C++**
 
-```js
+```cpp
 /**
  * Definition for a binary tree node.
- * function TreeNode(val, left, right) {
- *     this.val = (val===undefined ? 0 : val)
- *     this.left = (left===undefined ? null : left)
- *     this.right = (right===undefined ? null : right)
- * }
- */
-/**
- * @param {TreeNode} root
- * @param {number} target
- * @return {number}
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
  */
-var closestValue = function (root, target) {
-    let ans = root.val;
-    let mi = Number.MAX_VALUE;
-    while (root) {
-        const t = Math.abs(root.val - target);
-        if (t < mi) {
-            mi = t;
-            ans = root.val;
-        }
-        if (root.val > target) {
-            root = root.left;
-        } else {
-            root = root.right;
-        }
+class Solution {
+public:
+    int closestValue(TreeNode* root, double target) {
+        int ans = root->val;
+        double mi = INT_MAX;
+        function<void(TreeNode*)> dfs = [&](TreeNode* root) {
+            if (!root) {
+                return;
+            }
+            dfs(root->left);
+            double t = abs(root->val - target);
+            if (t < mi) {
+                mi = t;
+                ans = root->val;
+            }
+            dfs(root->right);
+        };
+        dfs(root);
+        return ans;
     }
-    return ans;
-};
-```
-
-```js
-/**
- * Definition for a binary tree node.
- * function TreeNode(val, left, right) {
- *     this.val = (val===undefined ? 0 : val)
- *     this.left = (left===undefined ? null : left)
- *     this.right = (right===undefined ? null : right)
- * }
- */
-/**
- * @param {TreeNode} root
- * @param {number} target
- * @return {number}
- */
-var closestValue = function (root, target) {
-    let mi = Infinity,
-        ans = root.val;
-    const dfs = (root, target) => {
-        if (!root) {
-            return;
-        }
-        dfs(root.left, target);
-        const t = Math.abs(root.val - target);
-        if (t < mi) {
-            mi = t;
-            ans = root.val;
-        }
-        dfs(root.right, target);
-    };
-    dfs(root, target);
-    return ans;
 };
 ```
 
-### **C++**
-
 ```cpp
 /**
  * Definition for a binary tree node.
@@ -199,14 +246,15 @@ public:
         double mi = INT_MAX;
         while (root) {
             double t = abs(root->val - target);
-            if (t < mi) {
+            if (t < mi || (t == mi && root->val < ans)) {
                 mi = t;
                 ans = root->val;
             }
-            if (root->val > target)
+            if (root->val > target) {
                 root = root->left;
-            else
+            } else {
                 root = root->right;
+            }
         }
         return ans;
     }
@@ -227,12 +275,42 @@ public:
 func closestValue(root *TreeNode, target float64) int {
 	ans := root.Val
 	mi := math.MaxFloat64
-	for root != nil {
+	var dfs func(*TreeNode)
+	dfs = func(root *TreeNode) {
+		if root == nil {
+			return
+		}
+		dfs(root.Left)
 		t := math.Abs(float64(root.Val) - target)
 		if t < mi {
 			mi = t
 			ans = root.Val
 		}
+		dfs(root.Right)
+	}
+	dfs(root)
+	return ans
+}
+```
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func closestValue(root *TreeNode, target float64) int {
+	ans := root.Val
+	mi := math.MaxFloat64
+	for root != nil {
+		t := math.Abs(float64(root.Val) - target)
+		if t < mi || (t == mi && root.Val < ans) {
+			mi = t
+			ans = root.Val
+		}
 		if float64(root.Val) > target {
 			root = root.Left
 		} else {
@@ -243,6 +321,75 @@ func closestValue(root *TreeNode, target float64) int {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} target
+ * @return {number}
+ */
+var closestValue = function (root, target) {
+    let mi = Infinity;
+    let ans = root.val;
+    const dfs = root => {
+        if (!root) {
+            return;
+        }
+        dfs(root.left);
+        const t = Math.abs(root.val - target);
+        if (t < mi) {
+            mi = t;
+            ans = root.val;
+        }
+        dfs(root.right);
+    };
+    dfs(root);
+    return ans;
+};
+```
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} target
+ * @return {number}
+ */
+var closestValue = function (root, target) {
+    let ans = root.val;
+    let mi = Number.MAX_VALUE;
+    while (root) {
+        const t = Math.abs(root.val - target);
+        if (t < mi || (t === mi && root.val < ans)) {
+            mi = t;
+            ans = root.val;
+        }
+        if (root.val > target) {
+            root = root.left;
+        } else {
+            root = root.right;
+        }
+    }
+    return ans;
+};
+```
+
 ### **...**
 
 ```
diff --git a/solution/0200-0299/0270.Closest Binary Search Tree Value/README_EN.md b/solution/0200-0299/0270.Closest Binary Search Tree Value/README_EN.md
index 29ae7393308b5..90f22e254d7c0 100644
--- a/solution/0200-0299/0270.Closest Binary Search Tree Value/README_EN.md	
+++ b/solution/0200-0299/0270.Closest Binary Search Tree Value/README_EN.md	
@@ -38,6 +38,31 @@ Binary search.
 
 ### **Python3**
 
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def closestValue(self, root: Optional[TreeNode], target: float) -> int:
+        def dfs(root):
+            if root is None:
+                return
+            dfs(root.left)
+            nonlocal ans, mi
+            t = abs(root.val - target)
+            if t < mi:
+                mi = t
+                ans = root.val
+            dfs(root.right)
+
+        ans, mi = root.val, inf
+        dfs(root)
+        return ans
+```
+
 ```python
 # Definition for a binary tree node.
 # class TreeNode:
@@ -50,7 +75,7 @@ class Solution:
         ans, mi = root.val, inf
         while root:
             t = abs(root.val - target)
-            if t < mi:
+            if t < mi or (t == mi and root.val < ans):
                 mi = t
                 ans = root.val
             if root.val > target:
@@ -62,6 +87,48 @@ class Solution:
 
 ### **Java**
 
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    private int ans;
+    private double target;
+    private double mi = Double.MAX_VALUE;
+
+    public int closestValue(TreeNode root, double target) {
+        this.target = target;
+        dfs(root);
+        return ans;
+    }
+
+    private void dfs(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        dfs(root.left);
+        double t = Math.abs(root.val - target);
+        if (t < mi) {
+            mi = t;
+            ans = root.val;
+        }
+        dfs(root.right);
+    }
+}
+```
+
 ```java
 /**
  * Definition for a binary tree node.
@@ -84,7 +151,7 @@ class Solution {
         double mi = Double.MAX_VALUE;
         while (root != null) {
             double t = Math.abs(root.val - target);
-            if (t < mi) {
+            if (t < mi || (t == mi && root.val < ans)) {
                 mi = t;
                 ans = root.val;
             }
@@ -99,77 +166,43 @@ class Solution {
 }
 ```
 
-### **JavaScript**
+### **C++**
 
-```js
+```cpp
 /**
  * Definition for a binary tree node.
- * function TreeNode(val, left, right) {
- *     this.val = (val===undefined ? 0 : val)
- *     this.left = (left===undefined ? null : left)
- *     this.right = (right===undefined ? null : right)
- * }
- */
-/**
- * @param {TreeNode} root
- * @param {number} target
- * @return {number}
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
  */
-var closestValue = function (root, target) {
-    let ans = root.val;
-    let mi = Number.MAX_VALUE;
-    while (root) {
-        const t = Math.abs(root.val - target);
-        if (t < mi) {
-            mi = t;
-            ans = root.val;
-        }
-        if (root.val > target) {
-            root = root.left;
-        } else {
-            root = root.right;
-        }
+class Solution {
+public:
+    int closestValue(TreeNode* root, double target) {
+        int ans = root->val;
+        double mi = INT_MAX;
+        function<void(TreeNode*)> dfs = [&](TreeNode* root) {
+            if (!root) {
+                return;
+            }
+            dfs(root->left);
+            double t = abs(root->val - target);
+            if (t < mi) {
+                mi = t;
+                ans = root->val;
+            }
+            dfs(root->right);
+        };
+        dfs(root);
+        return ans;
     }
-    return ans;
 };
 ```
 
-```js
-/**
- * Definition for a binary tree node.
- * function TreeNode(val, left, right) {
- *     this.val = (val===undefined ? 0 : val)
- *     this.left = (left===undefined ? null : left)
- *     this.right = (right===undefined ? null : right)
- * }
- */
-/**
- * @param {TreeNode} root
- * @param {number} target
- * @return {number}
- */
-var closestValue = function (root, target) {
-    let mi = Infinity,
-        ans = root.val;
-    const dfs = (root, target) => {
-        if (!root) {
-            return;
-        }
-        dfs(root.left, target);
-        const t = Math.abs(root.val - target);
-        if (t < mi) {
-            mi = t;
-            ans = root.val;
-        }
-        dfs(root.right, target);
-    };
-    dfs(root, target);
-    return ans;
-};
-```
-
-### **C++**
-
 ```cpp
 /**
  * Definition for a binary tree node.
@@ -189,14 +222,15 @@ public:
         double mi = INT_MAX;
         while (root) {
             double t = abs(root->val - target);
-            if (t < mi) {
+            if (t < mi || (t == mi && root->val < ans)) {
                 mi = t;
                 ans = root->val;
             }
-            if (root->val > target)
+            if (root->val > target) {
                 root = root->left;
-            else
+            } else {
                 root = root->right;
+            }
         }
         return ans;
     }
@@ -217,12 +251,42 @@ public:
 func closestValue(root *TreeNode, target float64) int {
 	ans := root.Val
 	mi := math.MaxFloat64
-	for root != nil {
+	var dfs func(*TreeNode)
+	dfs = func(root *TreeNode) {
+		if root == nil {
+			return
+		}
+		dfs(root.Left)
 		t := math.Abs(float64(root.Val) - target)
 		if t < mi {
 			mi = t
 			ans = root.Val
 		}
+		dfs(root.Right)
+	}
+	dfs(root)
+	return ans
+}
+```
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func closestValue(root *TreeNode, target float64) int {
+	ans := root.Val
+	mi := math.MaxFloat64
+	for root != nil {
+		t := math.Abs(float64(root.Val) - target)
+		if t < mi || (t == mi && root.Val < ans) {
+			mi = t
+			ans = root.Val
+		}
 		if float64(root.Val) > target {
 			root = root.Left
 		} else {
@@ -233,6 +297,75 @@ func closestValue(root *TreeNode, target float64) int {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} target
+ * @return {number}
+ */
+var closestValue = function (root, target) {
+    let mi = Infinity;
+    let ans = root.val;
+    const dfs = root => {
+        if (!root) {
+            return;
+        }
+        dfs(root.left);
+        const t = Math.abs(root.val - target);
+        if (t < mi) {
+            mi = t;
+            ans = root.val;
+        }
+        dfs(root.right);
+    };
+    dfs(root);
+    return ans;
+};
+```
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} target
+ * @return {number}
+ */
+var closestValue = function (root, target) {
+    let ans = root.val;
+    let mi = Number.MAX_VALUE;
+    while (root) {
+        const t = Math.abs(root.val - target);
+        if (t < mi || (t === mi && root.val < ans)) {
+            mi = t;
+            ans = root.val;
+        }
+        if (root.val > target) {
+            root = root.left;
+        } else {
+            root = root.right;
+        }
+    }
+    return ans;
+};
+```
+
 ### **...**
 
 ```
diff --git a/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.cpp b/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.cpp
index a6098344e028e..c2fab05399bc6 100644
--- a/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.cpp	
+++ b/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.cpp	
@@ -16,14 +16,15 @@ class Solution {
         double mi = INT_MAX;
         while (root) {
             double t = abs(root->val - target);
-            if (t < mi) {
+            if (t < mi || (t == mi && root->val < ans)) {
                 mi = t;
                 ans = root->val;
             }
-            if (root->val > target)
+            if (root->val > target) {
                 root = root->left;
-            else
+            } else {
                 root = root->right;
+            }
         }
         return ans;
     }
diff --git a/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.go b/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.go
index ebd7211488d6e..8a8758813ce63 100644
--- a/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.go	
+++ b/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.go	
@@ -11,7 +11,7 @@ func closestValue(root *TreeNode, target float64) int {
 	mi := math.MaxFloat64
 	for root != nil {
 		t := math.Abs(float64(root.Val) - target)
-		if t < mi {
+		if t < mi || (t == mi && root.Val < ans) {
 			mi = t
 			ans = root.Val
 		}
diff --git a/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.java b/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.java
index 3ebd2ade526fc..ae5cebd683662 100644
--- a/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.java	
+++ b/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.java	
@@ -19,7 +19,7 @@ public int closestValue(TreeNode root, double target) {
         double mi = Double.MAX_VALUE;
         while (root != null) {
             double t = Math.abs(root.val - target);
-            if (t < mi) {
+            if (t < mi || (t == mi && root.val < ans)) {
                 mi = t;
                 ans = root.val;
             }
diff --git a/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.js b/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.js
index 3c00f3d1bcdef..1638d5543d566 100644
--- a/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.js	
+++ b/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.js	
@@ -16,7 +16,7 @@ var closestValue = function (root, target) {
     let mi = Number.MAX_VALUE;
     while (root) {
         const t = Math.abs(root.val - target);
-        if (t < mi) {
+        if (t < mi || (t === mi && root.val < ans)) {
             mi = t;
             ans = root.val;
         }
diff --git a/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.py b/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.py
index 1df2023451483..a978b3389c646 100644
--- a/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.py	
+++ b/solution/0200-0299/0270.Closest Binary Search Tree Value/Solution.py	
@@ -9,7 +9,7 @@ def closestValue(self, root: Optional[TreeNode], target: float) -> int:
         ans, mi = root.val, inf
         while root:
             t = abs(root.val - target)
-            if t < mi:
+            if t < mi or (t == mi and root.val < ans):
                 mi = t
                 ans = root.val
             if root.val > target:
diff --git a/solution/2200-2299/2240.Number of Ways to Buy Pens and Pencils/README.md b/solution/2200-2299/2240.Number of Ways to Buy Pens and Pencils/README.md
index 017499fc681be..61454afcf1db9 100644
--- a/solution/2200-2299/2240.Number of Ways to Buy Pens and Pencils/README.md	
+++ b/solution/2200-2299/2240.Number of Ways to Buy Pens and Pencils/README.md	
@@ -44,7 +44,7 @@
 
 **方法一：枚举**
 
-我们可以枚举购买钢笔的数量 $x$，那么对于每个 $x$，我们最多可以购买铅笔的数量为 $\frac{total - x \times cost1}{cost2}$，那么方案数为 $y + 1$。我们累加所有的 $x$ 的方案数，即为答案。
+我们可以枚举购买钢笔的数量 $x$，对于每个 $x$，我们最多可以购买铅笔的数量为 $\frac{total - x \times cost1}{cost2}$，那么数量加 $1$ 即为 $x$ 的方案数。我们累加所有的 $x$ 的方案数，即为答案。
 
 时间复杂度 $O(\frac{total}{cost1})$，空间复杂度 $O(1)$。