Skip to content

Commit 8ff978d

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.2136 (#1715)
No.2136.Earliest Possible Day of Full Bloom
1 parent 3375b53 commit 8ff978d

File tree

8 files changed

+187
-96
lines changed

8 files changed

+187
-96
lines changed

‎solution/2100-2199/2136.Earliest Possible Day of Full Bloom/README.md

+59-33
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,9 @@
6868

6969
**方法一：贪心 + 排序**
7070

71-
生长时间越长的种子，越先播种，因此将 $growTime$ 降序排列。
71+
根据题目描述，我们知道，每一天只能为一枚种子进行播种，因此不管什么播种顺序，所有种子的播种时间之和总是等于 $\sum_{i=0}^{n-1} plantTime[i]$。那么，为了让尽快让所有种子开花，我们应该尽快播种生长时间最长的种子。因此，我们可以对所有种子按照生长时间从大到小进行排序，然后依次进行播种。
72+
73+
时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 是种子的数量。
7274

7375
<!-- tabs:start -->
7476

@@ -80,9 +82,9 @@
8082
class Solution:
8183
def earliestFullBloom(self, plantTime: List[int], growTime: List[int]) -> int:
8284
ans = t = 0
83-
for a, b in sorted(zip(plantTime, growTime), key=lambda x: -x[1]):
84-
t += a
85-
ans = max(ans, t + b)
85+
for pt, gt in sorted(zip(plantTime, growTime), key=lambda x: -x[1]):
86+
t += pt
87+
ans = max(ans, t + gt)
8688
return ans
8789
```
8890

@@ -94,16 +96,15 @@ class Solution:
9496
class Solution {
9597
public int earliestFullBloom(int[] plantTime, int[] growTime) {
9698
int n = plantTime.length;
97-
int[][] arr = new int[n][2];
98-
for (int i = 0; i < n; ++i) {
99-
arr[i] = new int[] {plantTime[i], growTime[i]};
99+
Integer[] idx = new Integer[n];
100+
for (int i = 0; i < n; i++) {
101+
idx[i] = i;
100102
}
101-
Arrays.sort(arr, (a, b) -> b[1] - a[1]);
102-
int ans = 0;
103-
int t = 0;
104-
for (int[] e : arr) {
105-
t += e[0];
106-
ans = Math.max(ans, t + e[1]);
103+
Arrays.sort(idx, (i, j) -> growTime[j] - growTime[i]);
104+
int ans = 0, t = 0;
105+
for (int i : idx) {
106+
t += plantTime[i];
107+
ans = Math.max(ans, t + growTime[i]);
107108
}
108109
return ans;
109110
}
@@ -117,13 +118,13 @@ class Solution {
117118
public:
118119
int earliestFullBloom(vector<int>& plantTime, vector<int>& growTime) {
119120
int n = plantTime.size();
120-
vector<pair<int, int>> arr;
121-
for (int i = 0; i < n; ++i) arr.push_back({-growTime[i], plantTime[i]});
122-
sort(arr.begin(), arr.end());
121+
vector<int> idx(n);
122+
iota(idx.begin(), idx.end(), 0);
123+
sort(idx.begin(), idx.end(), [&](int i, int j) { return growTime[j] < growTime[i]; });
123124
int ans = 0, t = 0;
124-
for (auto [a, b] : arr) {
125-
t += b;
126-
ans = max(ans, t - a);
125+
for (int i : idx) {
126+
t += plantTime[i];
127+
ans = max(ans, t + growTime[i]);
127128
}
128129
return ans;
129130
}
@@ -133,20 +134,19 @@ public:
133134
### **Go**
134135
135136
```go
136-
func earliestFullBloom(plantTime []int, growTime []int) int {
137-
arr := [][]int{}
138-
for i, a := range plantTime {
139-
arr = append(arr, []int{a, growTime[i]})
137+
func earliestFullBloom(plantTime []int, growTime []int) (ans int) {
138+
n := len(plantTime)
139+
idx := make([]int, n)
140+
for i := range idx {
141+
idx[i] = i
140142
}
141-
sort.Slice(arr, func(i, j int) bool {
142-
return arr[i][1] > arr[j][1]
143-
})
144-
ans, t := 0, 0
145-
for _, e := range arr {
146-
t += e[0]
147-
ans = max(ans, t+e[1])
143+
sort.Slice(idx, func(i, j int) bool { return growTime[idx[j]] < growTime[idx[i]] })
144+
t := 0
145+
for _, i := range idx {
146+
t += plantTime[i]
147+
ans = max(ans, t+growTime[i])
148148
}
149-
return ans
149+
return
150150
}
151151
152152
func max(a, b int) int {
@@ -159,10 +159,36 @@ func max(a, b int) int {
159159

160160
### **TypeScript**
161161

162-
<!-- 这里可写当前语言的特殊实现逻辑 -->
163-
164162
```ts
163+
function earliestFullBloom(plantTime: number[], growTime: number[]): number {
164+
const n = plantTime.length;
165+
const idx: number[] = Array.from({ length: n }, (_, i) => i);
166+
idx.sort((i, j) => growTime[j] - growTime[i]);
167+
let [ans, t] = [0, 0];
168+
for (const i of idx) {
169+
t += plantTime[i];
170+
ans = Math.max(ans, t + growTime[i]);
171+
}
172+
return ans;
173+
}
174+
```
165175

176+
### **Rust**
177+
178+
```rust
179+
impl Solution {
180+
pub fn earliest_full_bloom(plant_time: Vec<i32>, grow_time: Vec<i32>) -> i32 {
181+
let mut idx: Vec<usize> = (0..plant_time.len()).collect();
182+
idx.sort_by_key(|&i| -&grow_time[i]);
183+
let mut ans = 0;
184+
let mut t = 0;
185+
for &i in &idx {
186+
t += plant_time[i];
187+
ans = ans.max(t + grow_time[i]);
188+
}
189+
ans
190+
}
191+
}
166192
```
167193

168194
### **...**

‎solution/2100-2199/2136.Earliest Possible Day of Full Bloom/README_EN.md

+56-30
Original file line numberDiff line numberDiff line change
@@ -71,9 +71,9 @@ Thus, on day 2, all the seeds are blooming.
7171
class Solution:
7272
def earliestFullBloom(self, plantTime: List[int], growTime: List[int]) -> int:
7373
ans = t = 0
74-
for a, b in sorted(zip(plantTime, growTime), key=lambda x: -x[1]):
75-
t += a
76-
ans = max(ans, t + b)
74+
for pt, gt in sorted(zip(plantTime, growTime), key=lambda x: -x[1]):
75+
t += pt
76+
ans = max(ans, t + gt)
7777
return ans
7878
```
7979

@@ -83,16 +83,15 @@ class Solution:
8383
class Solution {
8484
public int earliestFullBloom(int[] plantTime, int[] growTime) {
8585
int n = plantTime.length;
86-
int[][] arr = new int[n][2];
87-
for (int i = 0; i < n; ++i) {
88-
arr[i] = new int[] {plantTime[i], growTime[i]};
86+
Integer[] idx = new Integer[n];
87+
for (int i = 0; i < n; i++) {
88+
idx[i] = i;
8989
}
90-
Arrays.sort(arr, (a, b) -> b[1] - a[1]);
91-
int ans = 0;
92-
int t = 0;
93-
for (int[] e : arr) {
94-
t += e[0];
95-
ans = Math.max(ans, t + e[1]);
90+
Arrays.sort(idx, (i, j) -> growTime[j] - growTime[i]);
91+
int ans = 0, t = 0;
92+
for (int i : idx) {
93+
t += plantTime[i];
94+
ans = Math.max(ans, t + growTime[i]);
9695
}
9796
return ans;
9897
}
@@ -106,13 +105,13 @@ class Solution {
106105
public:
107106
int earliestFullBloom(vector<int>& plantTime, vector<int>& growTime) {
108107
int n = plantTime.size();
109-
vector<pair<int, int>> arr;
110-
for (int i = 0; i < n; ++i) arr.push_back({-growTime[i], plantTime[i]});
111-
sort(arr.begin(), arr.end());
108+
vector<int> idx(n);
109+
iota(idx.begin(), idx.end(), 0);
110+
sort(idx.begin(), idx.end(), [&](int i, int j) { return growTime[j] < growTime[i]; });
112111
int ans = 0, t = 0;
113-
for (auto [a, b] : arr) {
114-
t += b;
115-
ans = max(ans, t - a);
112+
for (int i : idx) {
113+
t += plantTime[i];
114+
ans = max(ans, t + growTime[i]);
116115
}
117116
return ans;
118117
}
@@ -122,20 +121,19 @@ public:
122121
### **Go**
123122
124123
```go
125-
func earliestFullBloom(plantTime []int, growTime []int) int {
126-
arr := [][]int{}
127-
for i, a := range plantTime {
128-
arr = append(arr, []int{a, growTime[i]})
124+
func earliestFullBloom(plantTime []int, growTime []int) (ans int) {
125+
n := len(plantTime)
126+
idx := make([]int, n)
127+
for i := range idx {
128+
idx[i] = i
129129
}
130-
sort.Slice(arr, func(i, j int) bool {
131-
return arr[i][1] > arr[j][1]
132-
})
133-
ans, t := 0, 0
134-
for _, e := range arr {
135-
t += e[0]
136-
ans = max(ans, t+e[1])
130+
sort.Slice(idx, func(i, j int) bool { return growTime[idx[j]] < growTime[idx[i]] })
131+
t := 0
132+
for _, i := range idx {
133+
t += plantTime[i]
134+
ans = max(ans, t+growTime[i])
137135
}
138-
return ans
136+
return
139137
}
140138
141139
func max(a, b int) int {
@@ -149,7 +147,35 @@ func max(a, b int) int {
149147
### **TypeScript**
150148

151149
```ts
150+
function earliestFullBloom(plantTime: number[], growTime: number[]): number {
151+
const n = plantTime.length;
152+
const idx: number[] = Array.from({ length: n }, (_, i) => i);
153+
idx.sort((i, j) => growTime[j] - growTime[i]);
154+
let [ans, t] = [0, 0];
155+
for (const i of idx) {
156+
t += plantTime[i];
157+
ans = Math.max(ans, t + growTime[i]);
158+
}
159+
return ans;
160+
}
161+
```
152162

163+
### **Rust**
164+
165+
```rust
166+
impl Solution {
167+
pub fn earliest_full_bloom(plant_time: Vec<i32>, grow_time: Vec<i32>) -> i32 {
168+
let mut idx: Vec<usize> = (0..plant_time.len()).collect();
169+
idx.sort_by_key(|&i| -&grow_time[i]);
170+
let mut ans = 0;
171+
let mut t = 0;
172+
for &i in &idx {
173+
t += plant_time[i];
174+
ans = ans.max(t + grow_time[i]);
175+
}
176+
ans
177+
}
178+
}
153179
```
154180

155181
### **...**

‎solution/2100-2199/2136.Earliest Possible Day of Full Bloom/Solution.cpp

+14-14
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,15 @@
1-
class Solution {
2-
public:
3-
int earliestFullBloom(vector<int>& plantTime, vector<int>& growTime) {
4-
int n = plantTime.size();
5-
vector<pair<int, int>> arr;
6-
for (int i = 0; i < n; ++i) arr.push_back({-growTime[i], plantTime[i]});
7-
sort(arr.begin(), arr.end());
8-
int ans = 0, t = 0;
9-
for (auto [a, b] : arr) {
10-
t += b;
11-
ans = max(ans, t - a);
12-
}
13-
return ans;
14-
}
1+
class Solution {
2+
public:
3+
int earliestFullBloom(vector<int>& plantTime, vector<int>& growTime) {
4+
int n = plantTime.size();
5+
vector<int> idx(n);
6+
iota(idx.begin(), idx.end(), 0);
7+
sort(idx.begin(), idx.end(), [&](int i, int j) { return growTime[j] < growTime[i]; });
8+
int ans = 0, t = 0;
9+
for (int i : idx) {
10+
t += plantTime[i];
11+
ans = max(ans, t + growTime[i]);
12+
}
13+
return ans;
14+
}
1515
};

‎solution/2100-2199/2136.Earliest Possible Day of Full Bloom/Solution.go

+11-12
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,16 @@
1-
func earliestFullBloom(plantTime []int, growTime []int) int {
2-
arr := [][]int{}
3-
for i, a := range plantTime {
4-
arr = append(arr, []int{a, growTime[i]})
1+
func earliestFullBloom(plantTime []int, growTime []int) (ans int) {
2+
n := len(plantTime)
3+
idx := make([]int, n)
4+
for i := range idx {
5+
idx[i] = i
56
}
6-
sort.Slice(arr, func(i, j int) bool {
7-
return arr[i][1] > arr[j][1]
8-
})
9-
ans, t := 0, 0
10-
for _, e := range arr {
11-
t += e[0]
12-
ans = max(ans, t+e[1])
7+
sort.Slice(idx, func(i, j int) bool { return growTime[idx[j]] < growTime[idx[i]] })
8+
t := 0
9+
for _, i := range idx {
10+
t += plantTime[i]
11+
ans = max(ans, t+growTime[i])
1312
}
14-
return ans
13+
return
1514
}
1615

1716
func max(a, b int) int {

‎solution/2100-2199/2136.Earliest Possible Day of Full Bloom/Solution.java

+16
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
class Solution {
2+
public int earliestFullBloom(int[] plantTime, int[] growTime) {
3+
int n = plantTime.length;
4+
Integer[] idx = new Integer[n];
5+
for (int i = 0; i < n; i++) {
6+
idx[i] = i;
7+
}
8+
Arrays.sort(idx, (i, j) -> growTime[j] - growTime[i]);
9+
int ans = 0, t = 0;
10+
for (int i : idx) {
11+
t += plantTime[i];
12+
ans = Math.max(ans, t + growTime[i]);
13+
}
14+
return ans;
15+
}
16+
}

‎solution/2100-2199/2136.Earliest Possible Day of Full Bloom/Solution.py

+7-7
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
1-
class Solution:
2-
def earliestFullBloom(self, plantTime: List[int], growTime: List[int]) -> int:
3-
ans = t = 0
4-
for a, b in sorted(zip(plantTime, growTime), key=lambda x: -x[1]):
5-
t += a
6-
ans = max(ans, t + b)
7-
return ans
1+
class Solution:
2+
def earliestFullBloom(self, plantTime: List[int], growTime: List[int]) -> int:
3+
ans = t = 0
4+
for pt, gt in sorted(zip(plantTime, growTime), key=lambda x: -x[1]):
5+
t += pt
6+
ans = max(ans, t + gt)
7+
return ans

‎solution/2100-2199/2136.Earliest Possible Day of Full Bloom/Solution.rs

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
impl Solution {
2+
pub fn earliest_full_bloom(plant_time: Vec<i32>, grow_time: Vec<i32>) -> i32 {
3+
let mut idx: Vec<usize> = (0..plant_time.len()).collect();
4+
idx.sort_by_key(|&i| -&grow_time[i]);
5+
let mut ans = 0;
6+
let mut t = 0;
7+
for &i in &idx {
8+
t += plant_time[i];
9+
ans = ans.max(t + grow_time[i]);
10+
}
11+
ans
12+
}
13+
}

‎solution/2100-2199/2136.Earliest Possible Day of Full Bloom/Solution.ts

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
function earliestFullBloom(plantTime: number[], growTime: number[]): number {
2+
const n = plantTime.length;
3+
const idx: number[] = Array.from({ length: n }, (_, i) => i);
4+
idx.sort((i, j) => growTime[j] - growTime[i]);
5+
let [ans, t] = [0, 0];
6+
for (const i of idx) {
7+
t += plantTime[i];
8+
ans = Math.max(ans, t + growTime[i]);
9+
}
10+
return ans;
11+
}

0 commit comments

Comments
 (0)