feat: add solutions to lc problems: No.2475~2477 (#2064)

Author: yanglbme

solution/2400-2499/2475.Number of Unequal Triplets in Array/README_EN.md

@@ -49,6 +49,28 @@ Note that (2, 0, 4) is not a valid triplet because 2 > 0.
 
 ## Solutions
 
+**Solution 1: Brute Force Enumeration**
+
+We can directly enumerate all triples $(i, j, k)$ and count all the ones that meet the conditions.
+
+The time complexity is $O(n^3)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.
+
+**Solution 2: Sorting + Enumeration of Middle Elements + Binary Search**
+
+We can also sort the array $nums$ first.
+
+Then traverse $nums$, enumerate the middle element $nums[j]$, and use binary search to find the nearest index $i$ on the left side of $nums[j]$ such that $nums[i] < nums[j]$; find the nearest index $k$ on the right side of $nums[j]$ such that $nums[k] > nums[j]$. Then the number of triples with $nums[j]$ as the middle element and meeting the conditions is $(i + 1) \times (n - k)$, which is added to the answer.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log n)$. Here, $n$ is the length of the array $nums$.
+
+**Solution 3: Hash Table**
+
+We can also use a hash table $cnt$ to count the number of each element in the array $nums$.
+
+Then traverse the hash table $cnt$, enumerate the number of middle elements $b$, and denote the number of elements on the left as $a$. Then the number of elements on the right is $c = n - a - b$. At this time, the number of triples that meet the conditions is $a \times b \times c$, which is added to the answer. Then update $a = a + b$ and continue to enumerate the number of middle elements $b$.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array $nums$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2400-2499/2476.Closest Nodes Queries in a Binary Search Tree/README.md

@@ -81,7 +81,7 @@ class Solution:
     def closestNodes(
         self, root: Optional[TreeNode], queries: List[int]
     ) -> List[List[int]]:
-        def dfs(root):
+        def dfs(root: Optional[TreeNode]):
             if root is None:
                 return
             dfs(root.left)
@@ -91,9 +91,9 @@ class Solution:
         nums = []
         dfs(root)
         ans = []
-        for v in queries:
-            i = bisect_right(nums, v) - 1
-            j = bisect_left(nums, v)
+        for x in queries:
+            i = bisect_left(nums, x + 1) - 1
+            j = bisect_left(nums, x)
             mi = nums[i] if 0 <= i < len(nums) else -1
             mx = nums[j] if 0 <= j < len(nums) else -1
             ans.append([mi, mx])
@@ -126,29 +126,18 @@ class Solution {
     public List<List<Integer>> closestNodes(TreeNode root, List<Integer> queries) {
         dfs(root);
         List<List<Integer>> ans = new ArrayList<>();
-        for (int v : queries) {
-            int i = search(v + 1) - 1;
-            int j = search(v);
+        for (int x : queries) {
+            int i = Collections.binarySearch(nums, x + 1);
+            int j = Collections.binarySearch(nums, x);
+            i = i < 0 ? -i - 2 : i - 1;
+            j = j < 0 ? -j - 1 : j;
             int mi = i >= 0 && i < nums.size() ? nums.get(i) : -1;
             int mx = j >= 0 && j < nums.size() ? nums.get(j) : -1;
-            ans.add(Arrays.asList(mi, mx));
+            ans.add(List.of(mi, mx));
         }
         return ans;
     }
 
-    private int search(int x) {
-        int left = 0, right = nums.size();
-        while (left < right) {
-            int mid = (left + right) >> 1;
-            if (nums.get(mid) >= x) {
-                right = mid;
-            } else {
-                left = mid + 1;
-            }
-        }
-        return left;
-    }
-
     private void dfs(TreeNode root) {
         if (root == null) {
             return;
@@ -178,18 +167,20 @@ class Solution {
 public:
     vector<vector<int>> closestNodes(TreeNode* root, vector<int>& queries) {
         vector<int> nums;
-        function<void(TreeNode * root)> dfs = [&](TreeNode* root) {
-            if (!root) return;
+        function<void(TreeNode*)> dfs = [&](TreeNode* root) {
+            if (!root) {
+                return;
+            }
             dfs(root->left);
-            nums.emplace_back(root->val);
+            nums.push_back(root->val);
             dfs(root->right);
         };
         dfs(root);
         vector<vector<int>> ans;
         int n = nums.size();
-        for (int& v : queries) {
-            int i = upper_bound(nums.begin(), nums.end(), v) - nums.begin() - 1;
-            int j = lower_bound(nums.begin(), nums.end(), v) - nums.begin();
+        for (int& x : queries) {
+            int i = lower_bound(nums.begin(), nums.end(), x + 1) - nums.begin() - 1;
+            int j = lower_bound(nums.begin(), nums.end(), x) - nums.begin();
             int mi = i >= 0 && i < n ? nums[i] : -1;
             int mx = j >= 0 && j < n ? nums[j] : -1;
             ans.push_back({mi, mx});
@@ -222,15 +213,14 @@ func closestNodes(root *TreeNode, queries []int) (ans [][]int) {
 		dfs(root.Right)
 	}
 	dfs(root)
-	n := len(nums)
-	for _, v := range queries {
-		i := sort.SearchInts(nums, v+1) - 1
-		j := sort.SearchInts(nums, v)
+	for _, x := range queries {
+		i := sort.SearchInts(nums, x+1) - 1
+		j := sort.SearchInts(nums, x)
 		mi, mx := -1, -1
-		if i >= 0 && i < n {
+		if i >= 0 {
 			mi = nums[i]
 		}
-		if j >= 0 && j < n {
+		if j < len(nums) {
 			mx = nums[j]
 		}
 		ans = append(ans, []int{mi, mx})
@@ -242,7 +232,53 @@ func closestNodes(root *TreeNode, queries []int) (ans [][]int) {
 ### **TypeScript**
 
 ```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
 
+function closestNodes(root: TreeNode | null, queries: number[]): number[][] {
+    const nums: number[] = [];
+    const dfs = (root: TreeNode | null) => {
+        if (!root) {
+            return;
+        }
+        dfs(root.left);
+        nums.push(root.val);
+        dfs(root.right);
+    };
+    const search = (x: number): number => {
+        let [l, r] = [0, nums.length];
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (nums[mid] >= x) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return l;
+    };
+    dfs(root);
+    const ans: number[][] = [];
+    for (const x of queries) {
+        const i = search(x + 1) - 1;
+        const j = search(x);
+        const mi = i >= 0 ? nums[i] : -1;
+        const mx = j < nums.length ? nums[j] : -1;
+        ans.push([mi, mx]);
+    }
+    return ans;
+}
 ```
 
 ### **...**

solution/2400-2499/2476.Closest Nodes Queries in a Binary Search Tree/README_EN.md

@@ -48,6 +48,12 @@
 
 ## Solutions
 
+**Solution 1: In-order Traversal + Binary Search**
+
+Since the problem provides a binary search tree, we can obtain a sorted array through in-order traversal. Then for each query, we can find the maximum value less than or equal to the query value and the minimum value greater than or equal to the query value through binary search.
+
+The time complexity is $O(n + m \times \log n)$, and the space complexity is $O(n)$. Here, $n$ and $m$ are the number of nodes in the binary search tree and the number of queries, respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -63,7 +69,7 @@ class Solution:
     def closestNodes(
         self, root: Optional[TreeNode], queries: List[int]
     ) -> List[List[int]]:
-        def dfs(root):
+        def dfs(root: Optional[TreeNode]):
             if root is None:
                 return
             dfs(root.left)
@@ -73,9 +79,9 @@ class Solution:
         nums = []
         dfs(root)
         ans = []
-        for v in queries:
-            i = bisect_right(nums, v) - 1
-            j = bisect_left(nums, v)
+        for x in queries:
+            i = bisect_left(nums, x + 1) - 1
+            j = bisect_left(nums, x)
             mi = nums[i] if 0 <= i < len(nums) else -1
             mx = nums[j] if 0 <= j < len(nums) else -1
             ans.append([mi, mx])
@@ -106,29 +112,18 @@ class Solution {
     public List<List<Integer>> closestNodes(TreeNode root, List<Integer> queries) {
         dfs(root);
         List<List<Integer>> ans = new ArrayList<>();
-        for (int v : queries) {
-            int i = search(v + 1) - 1;
-            int j = search(v);
+        for (int x : queries) {
+            int i = Collections.binarySearch(nums, x + 1);
+            int j = Collections.binarySearch(nums, x);
+            i = i < 0 ? -i - 2 : i - 1;
+            j = j < 0 ? -j - 1 : j;
             int mi = i >= 0 && i < nums.size() ? nums.get(i) : -1;
             int mx = j >= 0 && j < nums.size() ? nums.get(j) : -1;
-            ans.add(Arrays.asList(mi, mx));
+            ans.add(List.of(mi, mx));
         }
         return ans;
     }
 
-    private int search(int x) {
-        int left = 0, right = nums.size();
-        while (left < right) {
-            int mid = (left + right) >> 1;
-            if (nums.get(mid) >= x) {
-                right = mid;
-            } else {
-                left = mid + 1;
-            }
-        }
-        return left;
-    }
-
     private void dfs(TreeNode root) {
         if (root == null) {
             return;
@@ -158,18 +153,20 @@ class Solution {
 public:
     vector<vector<int>> closestNodes(TreeNode* root, vector<int>& queries) {
         vector<int> nums;
-        function<void(TreeNode * root)> dfs = [&](TreeNode* root) {
-            if (!root) return;
+        function<void(TreeNode*)> dfs = [&](TreeNode* root) {
+            if (!root) {
+                return;
+            }
             dfs(root->left);
-            nums.emplace_back(root->val);
+            nums.push_back(root->val);
             dfs(root->right);
         };
         dfs(root);
         vector<vector<int>> ans;
         int n = nums.size();
-        for (int& v : queries) {
-            int i = upper_bound(nums.begin(), nums.end(), v) - nums.begin() - 1;
-            int j = lower_bound(nums.begin(), nums.end(), v) - nums.begin();
+        for (int& x : queries) {
+            int i = lower_bound(nums.begin(), nums.end(), x + 1) - nums.begin() - 1;
+            int j = lower_bound(nums.begin(), nums.end(), x) - nums.begin();
             int mi = i >= 0 && i < n ? nums[i] : -1;
             int mx = j >= 0 && j < n ? nums[j] : -1;
             ans.push_back({mi, mx});
@@ -202,15 +199,14 @@ func closestNodes(root *TreeNode, queries []int) (ans [][]int) {
 		dfs(root.Right)
 	}
 	dfs(root)
-	n := len(nums)
-	for _, v := range queries {
-		i := sort.SearchInts(nums, v+1) - 1
-		j := sort.SearchInts(nums, v)
+	for _, x := range queries {
+		i := sort.SearchInts(nums, x+1) - 1
+		j := sort.SearchInts(nums, x)
 		mi, mx := -1, -1
-		if i >= 0 && i < n {
+		if i >= 0 {
 			mi = nums[i]
 		}
-		if j >= 0 && j < n {
+		if j < len(nums) {
 			mx = nums[j]
 		}
 		ans = append(ans, []int{mi, mx})
@@ -222,7 +218,53 @@ func closestNodes(root *TreeNode, queries []int) (ans [][]int) {
 ### **TypeScript**
 
 ```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
 
+function closestNodes(root: TreeNode | null, queries: number[]): number[][] {
+    const nums: number[] = [];
+    const dfs = (root: TreeNode | null) => {
+        if (!root) {
+            return;
+        }
+        dfs(root.left);
+        nums.push(root.val);
+        dfs(root.right);
+    };
+    const search = (x: number): number => {
+        let [l, r] = [0, nums.length];
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (nums[mid] >= x) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return l;
+    };
+    dfs(root);
+    const ans: number[][] = [];
+    for (const x of queries) {
+        const i = search(x + 1) - 1;
+        const j = search(x);
+        const mi = i >= 0 ? nums[i] : -1;
+        const mx = j < nums.length ? nums[j] : -1;
+        ans.push([mi, mx]);
+    }
+    return ans;
+}
 ```
 
 ### **...**