From e554e6cf887cf5266f7893748588ec433e131123 Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Sun, 14 Sep 2025 23:04:45 +0800 Subject: [PATCH] feat: add solutions to lc problems: No.3683,3684 --- .../README.md | 45 +++++++++- .../README_EN.md | 45 +++++++++- .../Solution.cpp | 10 +++ .../Solution.go | 7 ++ .../Solution.java | 9 ++ .../Solution.py | 3 + .../Solution.ts | 3 + .../README.md | 90 ++++++++++++++++++- .../README_EN.md | 90 ++++++++++++++++++- .../Solution.cpp | 18 ++++ .../Solution.go | 14 +++ .../Solution.java | 17 ++++ .../Solution.py | 13 +++ .../Solution.ts | 15 ++++ 14 files changed, 363 insertions(+), 16 deletions(-) create mode 100644 solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.cpp create mode 100644 solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.go create mode 100644 solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.java create mode 100644 solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.py create mode 100644 solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.ts create mode 100644 solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.cpp create mode 100644 solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.go create mode 100644 solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.java create mode 100644 solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.py create mode 100644 solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.ts diff --git a/solution/3600-3699/3683.Earliest Time to Finish One Task/README.md b/solution/3600-3699/3683.Earliest Time to Finish One Task/README.md index 65bd7f8df3e8e..c12d37c94ba98 100644 --- a/solution/3600-3699/3683.Earliest Time to Finish One Task/README.md +++ b/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 -### 方法一 +### 方法一：一次遍历 + +我们遍历 $\textit{tasks}$ 数组，对于每个任务，计算其完成时间 $s_i + t_i$，求出所有任务完成时间的最小值，即为至少完成一个任务的最早时间。 + +时间复杂度 $O(n)$，其中 $n$ 为 $\textit{tasks}$ 数组的长度。空间复杂度 $O(1)$。 #### 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>& 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])); +} ``` diff --git a/solution/3600-3699/3683.Earliest Time to Finish One Task/README_EN.md b/solution/3600-3699/3683.Earliest Time to Finish One Task/README_EN.md index 09132624f70f9..9c4ed4a300c1e 100644 --- a/solution/3600-3699/3683.Earliest Time to Finish One Task/README_EN.md +++ b/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 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)$. #### 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>& 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])); +} ``` diff --git a/solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.cpp b/solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.cpp new file mode 100644 index 0000000000000..db5b7ebdf2c69 --- /dev/null +++ b/solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.cpp @@ -0,0 +1,10 @@ +class Solution { +public: + int earliestTime(vector>& tasks) { + int ans = 200; + for (const auto& task : tasks) { + ans = min(ans, task[0] + task[1]); + } + return ans; + } +}; diff --git a/solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.go b/solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.go new file mode 100644 index 0000000000000..cc6b79107fd2b --- /dev/null +++ b/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 +} diff --git a/solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.java b/solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.java new file mode 100644 index 0000000000000..4db1f67fe61b4 --- /dev/null +++ b/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; + } +} diff --git a/solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.py b/solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.py new file mode 100644 index 0000000000000..3f53018333898 --- /dev/null +++ b/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) diff --git a/solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.ts b/solution/3600-3699/3683.Earliest Time to Finish One Task/Solution.ts new file mode 100644 index 0000000000000..cc2ed825ea228 --- /dev/null +++ b/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])); +} diff --git a/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/README.md b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/README.md index 8caf52a0ffa99..93a158a117681 100644 --- a/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/README.md +++ b/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 -### 方法一 +### 方法一：排序 + +我们先对数组 $\textit{nums}$ 进行排序，然后从后向前遍历，选择最大的 $k$ 个不同的元素。由于我们需要严格递减的顺序，因此在选择时需要跳过重复的元素。 + +时间复杂度 $O(n \times \log n)$，其中 $n$ 为 $\textit{nums}$ 数组的长度。忽略答案的空间消耗，空间复杂度 $O(\log n)$。 #### 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 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 maxKDistinct(vector& nums, int k) { + ranges::sort(nums); + int n = nums.size(); + vector 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; +} ``` diff --git a/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/README_EN.md b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/README_EN.md index 7916d95ef5111..f0fe7b78f86e0 100644 --- a/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/README_EN.md +++ b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/README_EN.md @@ -72,32 +72,114 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3684.Ma -### Solution 1 +### Solution 1: Sorting + +We first sort the array $\textit{nums}$, then iterate from the end to the beginning, selecting the largest $k$ distinct elements. Since we require a strictly decreasing order, we skip duplicate elements during selection. + +The time complexity is $O(n \times \log n)$, where $n$ is the length of the $\textit{nums}$ array. Ignoring the space used for the answer, the space complexity is $O(\log n)$. #### 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 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 maxKDistinct(vector& nums, int k) { + ranges::sort(nums); + int n = nums.size(); + vector 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; +} ``` diff --git a/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.cpp b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.cpp new file mode 100644 index 0000000000000..ae90f959c171c --- /dev/null +++ b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.cpp @@ -0,0 +1,18 @@ +class Solution { +public: + vector maxKDistinct(vector& nums, int k) { + ranges::sort(nums); + int n = nums.size(); + vector 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; + } +}; diff --git a/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.go b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.go new file mode 100644 index 0000000000000..6f1342e31acf9 --- /dev/null +++ b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.go @@ -0,0 +1,14 @@ +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 +} diff --git a/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.java b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.java new file mode 100644 index 0000000000000..c1802a947c6d2 --- /dev/null +++ b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.java @@ -0,0 +1,17 @@ +class Solution { + public int[] maxKDistinct(int[] nums, int k) { + Arrays.sort(nums); + int n = nums.length; + List 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(); + } +} diff --git a/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.py b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.py new file mode 100644 index 0000000000000..8abb1039a6ef8 --- /dev/null +++ b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.py @@ -0,0 +1,13 @@ +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 diff --git a/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.ts b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.ts new file mode 100644 index 0000000000000..7090bfd480211 --- /dev/null +++ b/solution/3600-3699/3684.Maximize Sum of At Most K Distinct Elements/Solution.ts @@ -0,0 +1,15 @@ +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; +}