feat: add solutions to lc problems: No.2367~2370

* No.2367.Number of Arithmetic Triplets
* No.2368.Reachable Nodes With Restrictions
* No.2369.Check if There is a Valid Partition For The Array
* No.2370.Longest Ideal Subsequence

Author: yanglbme

solution/2300-2399/2367.Number of Arithmetic Triplets/README.md

@@ -47,13 +47,22 @@
 	<li><code>nums</code> <strong>严格</strong> 递增</li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
 **方法一：暴力枚举**
 
+直接暴力枚举 $i$, $j$, $k$，统计合法的三元组数目。
+
+时间复杂度 $O(n^3)$，空间复杂度 $O(1)$。
+
+**方法二：哈希表**
+
+由于 $nums$ 严格递增，那么对于 $nums$ 中的每个元素 $v$，判断 $v+diff$, $v+diff+diff$ 是否也在 $nums$ 中，若是，累加三元组数目。这里用哈希表实现元素的快速查找。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -73,6 +82,19 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def arithmeticTriplets(self, nums: List[int], diff: int) -> int:
+        return sum(b - a == diff and c - b == diff for a, b, c in combinations(nums, 3))
+```
+
+```python
+class Solution:
+    def arithmeticTriplets(self, nums: List[int], diff: int) -> int:
+        s = set(nums)
+        return sum(v + diff in s and v + diff + diff in s for v in nums)
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -96,6 +118,24 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int arithmeticTriplets(int[] nums, int diff) {
+        boolean[] vis = new boolean[310];
+        for (int v : nums) {
+            vis[v] = true;
+        }
+        int ans = 0;
+        for (int v : nums) {
+            if (vis[v + diff] && vis[v + diff + diff]) {
+                ++ans;
+            }
+        }
+        return ans;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -118,6 +158,19 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int arithmeticTriplets(vector<int>& nums, int diff) {
+        vector<bool> vis(310);
+        for (int v : nums) vis[v] = true;
+        int ans = 0;
+        for (int v : nums) ans += vis[v + diff] && vis[v + diff + diff];
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -137,6 +190,22 @@ func arithmeticTriplets(nums []int, diff int) int {
 }
 ```
 
+```go
+func arithmeticTriplets(nums []int, diff int) int {
+	vis := make([]bool, 310)
+	for _, v := range nums {
+		vis[v] = true
+	}
+	ans := 0
+	for _, v := range nums {
+		if vis[v+diff] && vis[v+diff+diff] {
+			ans++
+		}
+	}
+	return ans
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -159,6 +228,22 @@ function arithmeticTriplets(nums: number[], diff: number): number {
 }
 ```
 
+```ts
+function arithmeticTriplets(nums: number[], diff: number): number {
+    let vis = new Array(310).fill(false);
+    for (const v of nums) {
+        vis[v] = true;
+    }
+    let ans = 0;
+    for (const v of nums) {
+        if (vis[v + diff] && vis[v + diff + diff]) {
+            ++ans;
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2300-2399/2367.Number of Arithmetic Triplets/README_EN.md

@@ -65,6 +65,19 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def arithmeticTriplets(self, nums: List[int], diff: int) -> int:
+        return sum(b - a == diff and c - b == diff for a, b, c in combinations(nums, 3))
+```
+
+```python
+class Solution:
+    def arithmeticTriplets(self, nums: List[int], diff: int) -> int:
+        s = set(nums)
+        return sum(v + diff in s and v + diff + diff in s for v in nums)
+```
+
 ### **Java**
 
 ```java
@@ -86,6 +99,24 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int arithmeticTriplets(int[] nums, int diff) {
+        boolean[] vis = new boolean[310];
+        for (int v : nums) {
+            vis[v] = true;
+        }
+        int ans = 0;
+        for (int v : nums) {
+            if (vis[v + diff] && vis[v + diff + diff]) {
+                ++ans;
+            }
+        }
+        return ans;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -108,6 +139,19 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int arithmeticTriplets(vector<int>& nums, int diff) {
+        vector<bool> vis(310);
+        for (int v : nums) vis[v] = true;
+        int ans = 0;
+        for (int v : nums) ans += vis[v + diff] && vis[v + diff + diff];
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -127,6 +171,22 @@ func arithmeticTriplets(nums []int, diff int) int {
 }
 ```
 
+```go
+func arithmeticTriplets(nums []int, diff int) int {
+	vis := make([]bool, 310)
+	for _, v := range nums {
+		vis[v] = true
+	}
+	ans := 0
+	for _, v := range nums {
+		if vis[v+diff] && vis[v+diff+diff] {
+			ans++
+		}
+	}
+	return ans
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -149,6 +209,22 @@ function arithmeticTriplets(nums: number[], diff: number): number {
 }
 ```
 
+```ts
+function arithmeticTriplets(nums: number[], diff: number): number {
+    let vis = new Array(310).fill(false);
+    for (const v of nums) {
+        vis[v] = true;
+    }
+    let ans = 0;
+    for (const v of nums) {
+        if (vis[v + diff] && vis[v + diff + diff]) {
+            ++ans;
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2300-2399/2367.Number of Arithmetic Triplets/Solution.cpp

@@ -1,17 +1,10 @@
 class Solution {
 public:
     int arithmeticTriplets(vector<int>& nums, int diff) {
+        vector<bool> vis(310);
+        for (int v : nums) vis[v] = true;
         int ans = 0;
-        int n = nums.size();
-        for (int i = 0; i < n; ++i) {
-            for (int j = i + 1; j < n; ++j) {
-                for (int k = j + 1; k < n; ++k) {
-                    if (nums[j] - nums[i] == diff && nums[k] - nums[j] == diff) {
-                        ++ans;
-                    }
-                }
-            }
-        }
+        for (int v : nums) ans += vis[v + diff] && vis[v + diff + diff];
         return ans;
     }
 };

solution/2300-2399/2367.Number of Arithmetic Triplets/Solution.go

@@ -1,13 +1,12 @@
 func arithmeticTriplets(nums []int, diff int) int {
+	vis := make([]bool, 310)
+	for _, v := range nums {
+		vis[v] = true
+	}
 	ans := 0
-	n := len(nums)
-	for i := 0; i < n; i++ {
-		for j := i + 1; j < n; j++ {
-			for k := j + 1; k < n; k++ {
-				if nums[j]-nums[i] == diff && nums[k]-nums[j] == diff {
-					ans++
-				}
-			}
+	for _, v := range nums {
+		if vis[v+diff] && vis[v+diff+diff] {
+			ans++
 		}
 	}
 	return ans

solution/2300-2399/2367.Number of Arithmetic Triplets/Solution.java

@@ -1,14 +1,13 @@
 class Solution {
     public int arithmeticTriplets(int[] nums, int diff) {
+        boolean[] vis = new boolean[310];
+        for (int v : nums) {
+            vis[v] = true;
+        }
         int ans = 0;
-        int n = nums.length;
-        for (int i = 0; i < n; ++i) {
-            for (int j = i + 1; j < n; ++j) {
-                for (int k = j + 1; k < n; ++k) {
-                    if (nums[j] - nums[i] == diff && nums[k] - nums[j] == diff) {
-                        ++ans;
-                    }
-                }
+        for (int v : nums) {
+            if (vis[v + diff] && vis[v + diff + diff]) {
+                ++ans;
             }
         }
         return ans;

solution/2300-2399/2367.Number of Arithmetic Triplets/Solution.py

@@ -1,10 +1,4 @@
 class Solution:
     def arithmeticTriplets(self, nums: List[int], diff: int) -> int:
-        ans = 0
-        n = len(nums)
-        for i in range(n):
-            for j in range(i + 1, n):
-                for k in range(j + 1, n):
-                    if nums[j] - nums[i] == nums[k] - nums[j] == diff:
-                        ans += 1
-        return ans
+        s = set(nums)
+        return sum(v + diff in s and v + diff + diff in s for v in nums)

solution/2300-2399/2367.Number of Arithmetic Triplets/Solution.ts

@@ -1,17 +1,13 @@
 function arithmeticTriplets(nums: number[], diff: number): number {
-    let res = 0;
-    const n = nums.length;
-    for (let i = 0; i < n - 2; i++) {
-        for (let j = i + 1; j < n - 1; j++) {
-            for (let k = j + 1; k < n; k++) {
-                if (nums[k] - nums[j] > diff) {
-                    break;
-                }
-                if (nums[j] - nums[i] === diff && nums[k] - nums[j] === diff) {
-                    res++;
-                }
-            }
+    let vis = new Array(310).fill(false);
+    for (const v of nums) {
+        vis[v] = true;
+    }
+    let ans = 0;
+    for (const v of nums) {
+        if (vis[v + diff] && vis[v + diff + diff]) {
+            ++ans;
         }
     }
-    return res;
+    return ans;
 }