feat: add solutions to lc problems: No.3683,3684

solution/3600-3699/3683.Earliest Time to Finish One Task/README.md

@@ -62,32 +62,69 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3683.Ea
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：一次遍历
+
+我们遍历 $\textit{tasks}$ 数组，对于每个任务，计算其完成时间 $s_i + t_i$，求出所有任务完成时间的最小值，即为至少完成一个任务的最早时间。
+
+时间复杂度 $O(n)$，其中 $n$ 为 $\textit{tasks}$ 数组的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def earliestTime(self, tasks: List[List[int]]) -> int:
+        return min(s + t for s, t in tasks)
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int earliestTime(int[][] tasks) {
+        int ans = 200;
+        for (var task : tasks) {
+            ans = Math.min(ans, task[0] + task[1]);
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int earliestTime(vector<vector<int>>& tasks) {
+        int ans = 200;
+        for (const auto& task : tasks) {
+            ans = min(ans, task[0] + task[1]);
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func earliestTime(tasks [][]int) int {
+	ans := 200
+	for _, task := range tasks {
+		ans = min(ans, task[0]+task[1])
+	}
+	return ans
+}
+```
+
+#### TypeScript
 
+```ts
+function earliestTime(tasks: number[][]): number {
+    return Math.min(...tasks.map(task => task[0] + task[1]));
+}
 ```
 
 <!-- tabs:end -->

solution/3600-3699/3683.Earliest Time to Finish One Task/README_EN.md

@@ -60,32 +60,69 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3683.Ea
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Single Pass
+
+We iterate through the $\textit{tasks}$ array and, for each task, calculate its completion time $s_i + t_i$. The minimum of all task completion times is the earliest time to finish at least one task.
+
+The time complexity is $O(n)$, where $n$ is the length of the $\textit{tasks}$ array. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def earliestTime(self, tasks: List[List[int]]) -> int:
+        return min(s + t for s, t in tasks)
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int earliestTime(int[][] tasks) {
+        int ans = 200;
+        for (var task : tasks) {
+            ans = Math.min(ans, task[0] + task[1]);
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int earliestTime(vector<vector<int>>& tasks) {
+        int ans = 200;
+        for (const auto& task : tasks) {
+            ans = min(ans, task[0] + task[1]);
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func earliestTime(tasks [][]int) int {
+	ans := 200
+	for _, task := range tasks {
+		ans = min(ans, task[0]+task[1])
+	}
+	return ans
+}
+```
+
+#### TypeScript
 
+```ts
+function earliestTime(tasks: number[][]): number {
+    return Math.min(...tasks.map(task => task[0] + task[1]));
+}
 ```
 
 <!-- tabs:end -->

solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.cpp

@@ -0,0 +1,10 @@
+class Solution {
+public:
+    int earliestTime(vector<vector<int>>& tasks) {
+        int ans = 200;
+        for (const auto& task : tasks) {
+            ans = min(ans, task[0] + task[1]);
+        }
+        return ans;
+    }
+};

solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.go

@@ -0,0 +1,7 @@
+func earliestTime(tasks [][]int) int {
+	ans := 200
+	for _, task := range tasks {
+		ans = min(ans, task[0]+task[1])
+	}
+	return ans
+}

solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.java

@@ -0,0 +1,9 @@
+class Solution {
+    public int earliestTime(int[][] tasks) {
+        int ans = 200;
+        for (var task : tasks) {
+            ans = Math.min(ans, task[0] + task[1]);
+        }
+        return ans;
+    }
+}

solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.py

@@ -0,0 +1,3 @@
+class Solution:
+    def earliestTime(self, tasks: List[List[int]]) -> int:
+        return min(s + t for s, t in tasks)

solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.ts

@@ -0,0 +1,3 @@
+function earliestTime(tasks: number[][]): number {
+    return Math.min(...tasks.map(task => task[0] + task[1]));
+}

solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/README.md

@@ -75,32 +75,114 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3684.Ma
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：排序
+
+我们先对数组 $\textit{nums}$ 进行排序，然后从后向前遍历，选择最大的 $k$ 个不同的元素。由于我们需要严格递减的顺序，因此在选择时需要跳过重复的元素。
+
+时间复杂度 $O(n \times \log n)$，其中 $n$ 为 $\textit{nums}$ 数组的长度。忽略答案的空间消耗，空间复杂度 $O(\log n)$。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def maxKDistinct(self, nums: List[int], k: int) -> List[int]:
+        nums.sort()
+        n = len(nums)
+        ans = []
+        for i in range(n - 1, -1, -1):
+            if i + 1 < n and nums[i] == nums[i + 1]:
+                continue
+            ans.append(nums[i])
+            k -= 1
+            if k == 0:
+                break
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int[] maxKDistinct(int[] nums, int k) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        List<Integer> ans = new ArrayList<>();
+        for (int i = n - 1; i >= 0; --i) {
+            if (i + 1 < n && nums[i] == nums[i + 1]) {
+                continue;
+            }
+            ans.add(nums[i]);
+            if (--k == 0) {
+                break;
+            }
+        }
+        return ans.stream().mapToInt(x -> x).toArray();
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    vector<int> maxKDistinct(vector<int>& nums, int k) {
+        ranges::sort(nums);
+        int n = nums.size();
+        vector<int> ans;
+        for (int i = n - 1; ~i; --i) {
+            if (i + 1 < n && nums[i] == nums[i + 1]) {
+                continue;
+            }
+            ans.push_back(nums[i]);
+            if (--k == 0) {
+                break;
+            }
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func maxKDistinct(nums []int, k int) (ans []int) {
+	slices.Sort(nums)
+	n := len(nums)
+	for i := n - 1; i >= 0; i-- {
+		if i+1 < n && nums[i] == nums[i+1] {
+			continue
+		}
+		ans = append(ans, nums[i])
+		if k--; k == 0 {
+			break
+		}
+	}
+	return
+}
+```
 
+#### TypeScript
+
+```ts
+function maxKDistinct(nums: number[], k: number): number[] {
+    nums.sort((a, b) => a - b);
+    const ans: number[] = [];
+    const n = nums.length;
+    for (let i = n - 1; ~i; --i) {
+        if (i + 1 < n && nums[i] === nums[i + 1]) {
+            continue;
+        }
+        ans.push(nums[i]);
+        if (--k === 0) {
+            break;
+        }
+    }
+    return ans;
+}
 ```
 
 <!-- tabs:end -->