feat: add solutions to lc problems (doocs#2026)

Author: yanglbme

solution/1000-1099/1094.Car Pooling/README.md

@@ -46,9 +46,9 @@
 
 **方法一：差分数组**
 
-我们可以利用差分数组的思想，将每个行程的乘客数加到起点，减去终点，最后遍历差分数组，若当前乘客数大于容量，则返回 `false`，否则返回 `true`。
+我们可以利用差分数组的思想，将每个行程的乘客数加到起点，减去终点，最后我们只需要判断差分数组的前缀和是否都不大于车的最大载客量即可。
 
-时间复杂度 $O(n)$，空间复杂度 $O(m)$。其中 $n$ 和 $m$ 分别为行程数和行程中的最大终点。
+时间复杂度 $O(n)$，空间复杂度 $O(M)$。其中 $n$ 是行程数，而 $M$ 是行程中最大的终点，本题中 $M \le 1000$。
 
 <!-- tabs:start -->
 
@@ -59,7 +59,8 @@
 ```python
 class Solution:
     def carPooling(self, trips: List[List[int]], capacity: int) -> bool:
-        d = [0] * 1001
+        mx = max(e[2] for e in trips)
+        d = [0] * (mx + 1)
         for x, f, t in trips:
             d[f] += x
             d[t] -= x
@@ -145,7 +146,8 @@ func carPooling(trips [][]int, capacity int) bool {
  * @return {boolean}
  */
 var carPooling = function (trips, capacity) {
-    const d = new Array(1001).fill(0);
+    const mx = Math.max(...trips.map(([, , t]) => t));
+    const d = Array(mx + 1).fill(0);
     for (const [x, f, t] of trips) {
         d[f] += x;
         d[t] -= x;
@@ -165,7 +167,8 @@ var carPooling = function (trips, capacity) {
 
 ```ts
 function carPooling(trips: number[][], capacity: number): boolean {
-    const d = new Array(1001).fill(0);
+    const mx = Math.max(...trips.map(([, , t]) => t));
+    const d = Array(mx + 1).fill(0);
     for (const [x, f, t] of trips) {
         d[f] += x;
         d[t] -= x;
@@ -181,6 +184,56 @@ function carPooling(trips: number[][], capacity: number): boolean {
 }
 ```
 
+### **C#**
+
+```cs
+public class Solution {
+    public bool CarPooling(int[][] trips, int capacity) {
+        int mx = trips.Max(x => x[2]);
+        int[] d = new int[mx + 1];
+        foreach (var trip in trips) {
+            int x = trip[0], f = trip[1], t = trip[2];
+            d[f] += x;
+            d[t] -= x;
+        }
+        int s = 0;
+        foreach (var x in d) {
+            s += x;
+            if (s > capacity) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn car_pooling(trips: Vec<Vec<i32>>, capacity: i32) -> bool {
+        let mx = trips
+            .iter()
+            .map(|e| e[2])
+            .max()
+            .unwrap_or(0) as usize;
+        let mut d = vec![0; mx + 1];
+        for trip in &trips {
+            let (x, f, t) = (trip[0], trip[1] as usize, trip[2] as usize);
+            d[f] += x;
+            d[t] -= x;
+        }
+        d.iter()
+            .scan(0, |acc, &x| {
+                *acc += x;
+                Some(*acc)
+            })
+            .all(|s| s <= capacity)
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1000-1099/1094.Car Pooling/README_EN.md

@@ -38,14 +38,21 @@
 
 ## Solutions
 
+**Solution 1: Difference Array**
+
+We can use the idea of a difference array, adding the number of passengers to the starting point of each trip and subtracting from the end point. Finally, we just need to check whether the prefix sum of the difference array does not exceed the maximum passenger capacity of the car.
+
+The time complexity is $O(n)$, and the space complexity is $O(M)$. Here, $n$ is the number of trips, and $M$ is the maximum end point in the trips. In this problem, $M \le 1000$.
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
 class Solution:
     def carPooling(self, trips: List[List[int]], capacity: int) -> bool:
-        d = [0] * 1001
+        mx = max(e[2] for e in trips)
+        d = [0] * (mx + 1)
         for x, f, t in trips:
             d[f] += x
             d[t] -= x
@@ -129,7 +136,8 @@ func carPooling(trips [][]int, capacity int) bool {
  * @return {boolean}
  */
 var carPooling = function (trips, capacity) {
-    const d = new Array(1001).fill(0);
+    const mx = Math.max(...trips.map(([, , t]) => t));
+    const d = Array(mx + 1).fill(0);
     for (const [x, f, t] of trips) {
         d[f] += x;
         d[t] -= x;
@@ -149,7 +157,8 @@ var carPooling = function (trips, capacity) {
 
 ```ts
 function carPooling(trips: number[][], capacity: number): boolean {
-    const d = new Array(1001).fill(0);
+    const mx = Math.max(...trips.map(([, , t]) => t));
+    const d = Array(mx + 1).fill(0);
     for (const [x, f, t] of trips) {
         d[f] += x;
         d[t] -= x;
@@ -165,6 +174,56 @@ function carPooling(trips: number[][], capacity: number): boolean {
 }
 ```
 
+### **C#**
+
+```cs
+public class Solution {
+    public bool CarPooling(int[][] trips, int capacity) {
+        int mx = trips.Max(x => x[2]);
+        int[] d = new int[mx + 1];
+        foreach (var trip in trips) {
+            int x = trip[0], f = trip[1], t = trip[2];
+            d[f] += x;
+            d[t] -= x;
+        }
+        int s = 0;
+        foreach (var x in d) {
+            s += x;
+            if (s > capacity) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn car_pooling(trips: Vec<Vec<i32>>, capacity: i32) -> bool {
+        let mx = trips
+            .iter()
+            .map(|e| e[2])
+            .max()
+            .unwrap_or(0) as usize;
+        let mut d = vec![0; mx + 1];
+        for trip in &trips {
+            let (x, f, t) = (trip[0], trip[1] as usize, trip[2] as usize);
+            d[f] += x;
+            d[t] -= x;
+        }
+        d.iter()
+            .scan(0, |acc, &x| {
+                *acc += x;
+                Some(*acc)
+            })
+            .all(|s| s <= capacity)
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1000-1099/1094.Car Pooling/Solution.cs

@@ -0,0 +1,19 @@
+public class Solution {
+    public bool CarPooling(int[][] trips, int capacity) {
+        int mx = trips.Max(x => x[2]);
+        int[] d = new int[mx + 1];
+        foreach (var trip in trips) {
+            int x = trip[0], f = trip[1], t = trip[2];
+            d[f] += x;
+            d[t] -= x;
+        }
+        int s = 0;
+        foreach (var x in d) {
+            s += x;
+            if (s > capacity) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

solution/1000-1099/1094.Car Pooling/Solution.go

@@ -1,5 +1,6 @@
 func carPooling(trips [][]int, capacity int) bool {
-	d := [1001]int{}
+	mx := slices.Max(trips, func(i int) int { return trips[i][2] })
+	d := make([]int, mx+1)
 	for _, trip := range trips {
 		x, f, t := trip[0], trip[1], trip[2]
 		d[f] += x

solution/1000-1099/1094.Car Pooling/Solution.js

@@ -4,7 +4,8 @@
  * @return {boolean}
  */
 var carPooling = function (trips, capacity) {
-    const d = new Array(1001).fill(0);
+    const mx = Math.max(...trips.map(([, , t]) => t));
+    const d = Array(mx + 1).fill(0);
     for (const [x, f, t] of trips) {
         d[f] += x;
         d[t] -= x;

solution/1000-1099/1094.Car Pooling/Solution.py

@@ -1,6 +1,7 @@
 class Solution:
     def carPooling(self, trips: List[List[int]], capacity: int) -> bool:
-        d = [0] * 1001
+        mx = max(e[2] for e in trips)
+        d = [0] * (mx + 1)
         for x, f, t in trips:
             d[f] += x
             d[t] -= x

solution/1000-1099/1094.Car Pooling/Solution.rs

@@ -0,0 +1,21 @@
+impl Solution {
+    pub fn car_pooling(trips: Vec<Vec<i32>>, capacity: i32) -> bool {
+        let mx = trips
+            .iter()
+            .map(|e| e[2])
+            .max()
+            .unwrap_or(0) as usize;
+        let mut d = vec![0; mx + 1];
+        for trip in &trips {
+            let (x, f, t) = (trip[0], trip[1] as usize, trip[2] as usize);
+            d[f] += x;
+            d[t] -= x;
+        }
+        d.iter()
+            .scan(0, |acc, &x| {
+                *acc += x;
+                Some(*acc)
+            })
+            .all(|s| s <= capacity)
+    }
+}

solution/1000-1099/1094.Car Pooling/Solution.ts

@@ -1,5 +1,6 @@
 function carPooling(trips: number[][], capacity: number): boolean {
-    const d = new Array(1001).fill(0);
+    const mx = Math.max(...trips.map(([, , t]) => t));
+    const d = Array(mx + 1).fill(0);
     for (const [x, f, t] of trips) {
         d[f] += x;
         d[t] -= x;

solution/1000-1099/1099.Two Sum Less Than K/README_EN.md

@@ -34,6 +34,26 @@
 
 ## Solutions
 
+**Solution 1: Sorting + Binary Search**
+
+We can first sort the array $nums$, and initialize the answer as $-1$.
+
+Next, we enumerate each element $nums[i]$ in the array, and find the maximum $nums[j]$ in the array that satisfies $nums[j] + nums[i] < k$. Here, we can use binary search to speed up the search process. If we find such a $nums[j]$, then we can update the answer, i.e., $ans = \max(ans, nums[i] + nums[j])$.
+
+After the enumeration ends, return 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 2: Sorting + Two Pointers**
+
+Similar to Method 1, we can first sort the array $nums$, and initialize the answer as $-1$.
+
+Next, we use two pointers $i$ and $j$ to point to the left and right ends of the array, respectively. Each time we judge whether $s = nums[i] + nums[j]$ is less than $k$. If it is less than $k$, then we can update the answer, i.e., $ans = \max(ans, s)$, and move $i$ one step to the right, otherwise move $j$ one step to the left.
+
+After the enumeration ends, return 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$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1100-1199/1100.Find K-Length Substrings With No Repeated Characters/README_EN.md

@@ -34,6 +34,18 @@
 
 ## Solutions
 
+**Solution 1: Two Pointers + Counter**
+
+We observe that all characters are lowercase letters, so there are at most $26$ different characters. Therefore, if $k > 26$ or $k > n$, it is impossible to find any substring of length $k$ without repeated characters, and we can directly return $0$.
+
+Next, we use two pointers $j$ and $i$ to maintain a sliding window, where $j$ is the left endpoint of the sliding window, $i$ is the right endpoint of the sliding window, and a counter $cnt$ is used to count the number of occurrences of each character in the sliding window.
+
+We traverse the string $s$, each time adding $s[i]$ to the sliding window, i.e., $cnt[s[i]]++$. If at this time $cnt[s[i]] > 1$ or $i - j + 1 > k$, then we loop to remove $s[j]$ from the sliding window, i.e., $cnt[s[j]]--$, and move $j$ to the right. If after moving $j$ to the right, the window size $i - j + 1$ is exactly equal to $k$, it means that the string in the sliding window is a substring that meets the requirements of the problem, and we increment the result by one.
+
+After the traversal ends, we can get the number of all substrings that meet the requirements of the problem.
+
+The time complexity is $O(n)$, and the space complexity is $O(C)$. Here, $n$ is the length of the string $s$, and $C$ is the size of the character set. In this problem, $C = 26$.
+
 <!-- tabs:start -->
 
 ### **Python3**