Skip to content

Commit 934b448

Browse files
author
rom.spiridonov
committed
feat: feat: add solutions to lc problem: No.3413
1 parent bfd23a2 commit 934b448

File tree

6 files changed

+501
-4
lines changed

6 files changed

+501
-4
lines changed

‎solution/3400-3499/3413.Maximum Coins From K Consecutive Bags/README.md

Lines changed: 169 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -86,7 +86,26 @@ tags:
8686
#### Python3
8787

8888
```python
89-
89+
class Solution:
90+
def maximumCoins(self, coins: List[List[int]], k: int) -> int:
91+
coins.sort(key=itemgetter(0))
92+
i, total, ans, n = 0, 0, 0, len(coins)
93+
l0, r0, c0 = coins[0]
94+
print(coins)
95+
for l, r, c in coins:
96+
while i < n and r - coins[i][0] + 1 >= k:
97+
# print(r,coins[i][0],total)
98+
l0, r0, c0 = coins[i]
99+
ans = max(total + max(k + l0 - l, 0) * c, ans)
100+
total -= (r0 - l0 + 1) * c0
101+
i += 1
102+
103+
total += (r - l + 1) * c
104+
# print(total,l,r)
105+
if i < n and coins[i][0] != l0:
106+
start_l = r - k + 1
107+
ans = max(total + max(r0 - start_l + 1, 0) * c0, ans)
108+
return max(ans, total)
90109
```
91110

92111
#### Java
@@ -98,13 +117,161 @@ tags:
98117
#### C++
99118

100119
```cpp
101-
120+
class Solution {
121+
private:
122+
struct interval {
123+
int start = -1, end = -1, value = 0;
124+
125+
interval() = default;
126+
interval(int _start, int _end, int _value) : start(_start), end(_end), value(_value) {}
127+
128+
bool operator < (const interval &other) const {
129+
return start < other.start || (start == other.start && end < other.end);
130+
}
131+
int64_t cost() const { return int64_t(value) * (end - start + 1); }
132+
int64_t cost(int len) const { return int64_t(value) * len; }
133+
};
134+
public:
135+
long long maximumCoins(vector<vector<int>>& coins, int k) {
136+
int N = int(coins.size());
137+
vector<interval> A(N);
138+
139+
for (int i = 0; i < N; i++) A[i] = {coins[i][0], coins[i][1], coins[i][2]};
140+
sort(A.begin(), A.end());
141+
142+
int64_t ans = 0LL;
143+
{
144+
int64_t value = 0LL;
145+
int right = 0;
146+
for (int left = 0; left < N; left++) {
147+
while (right < N && A[right].end - A[left].start < k) {
148+
value += A[right].cost();
149+
++right;
150+
}
151+
152+
if (right < N) {
153+
int64_t extra = (A[right].start - A[left].start <= k) ? A[right].cost(k - A[right].start + A[left].start) : 0LL;
154+
ans = max(ans, value + extra);
155+
}
156+
157+
value -= A[left].cost();
158+
}
159+
}
160+
161+
{
162+
int64_t value = 0LL;
163+
int left = 0;
164+
for (int right = 0; right < N; right++) {
165+
value += A[right].cost();
166+
while (A[right].end - A[left].end >= k) {
167+
value -= A[left].cost();
168+
left++;
169+
}
170+
171+
int64_t extra = (A[right].end - A[left].start >= k) ? A[left].cost(A[right].end - A[left].start - k + 1) : 0LL;
172+
ans = max(ans, value - extra);
173+
}
174+
}
175+
176+
return ans;
177+
}
178+
};
102179
```
103180

104181
#### Go
105182

106183
```go
184+
func maximumCoins(coins [][]int, k int) int64 {
185+
sort.Slice(coins, func(i, j int) bool {
186+
return coins[i][0] < coins[j][0]
187+
})
188+
189+
n := len(coins)
190+
var total int64 = 0
191+
var ans int64 = 0
192+
i := 0
193+
l0, r0, c0 := coins[0][0], coins[0][1], coins[0][2]
194+
195+
for _, seg := range coins {
196+
l, r, c := seg[0], seg[1], seg[2]
197+
198+
for i < n && r-coins[i][0]+1 >= k {
199+
l0, r0, c0 = coins[i][0], coins[i][1], coins[i][2]
200+
ans = max64(ans, total+int64(max(k+l0-l, 0))*int64(c))
201+
total -= int64(r0-l0+1) * int64(c0)
202+
i++
203+
}
204+
205+
total += int64(r-l+1) * int64(c)
206+
207+
if i < n && coins[i][0] != l0 {
208+
startL := r - k + 1
209+
ans = max64(ans, total+int64(max(r0-startL+1, 0))*int64(c0))
210+
}
211+
}
212+
if total > ans {
213+
ans = total
214+
}
215+
return ans
216+
}
217+
218+
func max64(a, b int64) int64 {
219+
if a > b {
220+
return a
221+
}
222+
return b
223+
}
224+
225+
func max(a, b int) int {
226+
if a > b {
227+
return a
228+
}
229+
return b
230+
}
231+
```
107232

233+
#### Rust
234+
235+
```rust
236+
use std::cmp::{min, max};
237+
fn f(coins: &[(i32, i32, i32)], k: i32) -> i64 {
238+
let mut result = 0;
239+
let mut sum = 0;
240+
let mut r = 0;
241+
242+
for l in 0..coins.len() {
243+
while r < coins.len() && coins[l].0 + k > coins[r].1 {
244+
sum += (coins[r].1 - coins[r].0 + 1) as i64 * coins[r].2 as i64;
245+
r += 1;
246+
}
247+
result = max(result, sum);
248+
if r == coins.len() {
249+
break;
250+
}
251+
let cnt = coins[l].0 + k - coins[r].0;
252+
result = max(result, sum + max(cnt, 0) as i64 * coins[r].2 as i64);
253+
sum -= (coins[l].1 - coins[l].0 + 1) as i64 * coins[l].2 as i64;
254+
}
255+
256+
result
257+
}
258+
259+
impl Solution {
260+
pub fn maximum_coins(mut coins: Vec<Vec<i32>>, k: i32) -> i64 {
261+
let mut coins: Vec<_> = coins.into_iter()
262+
.map(|xs| (xs[0], xs[1], xs[2]))
263+
.collect();
264+
coins.sort();
265+
let a = f(&coins, k);
266+
coins.reverse();
267+
for i in 0..coins.len() {
268+
(coins[i].0, coins[i].1) = (-coins[i].1, -coins[i].0);
269+
}
270+
let b = f(&coins, k);
271+
272+
max(a, b)
273+
}
274+
}
108275
```
109276

110277
<!-- tabs:end -->

‎solution/3400-3499/3413.Maximum Coins From K Consecutive Bags/README_EN.md

Lines changed: 169 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -83,7 +83,26 @@ tags:
8383
#### Python3
8484

8585
```python
86-
86+
class Solution:
87+
def maximumCoins(self, coins: List[List[int]], k: int) -> int:
88+
coins.sort(key=itemgetter(0))
89+
i, total, ans, n = 0, 0, 0, len(coins)
90+
l0, r0, c0 = coins[0]
91+
print(coins)
92+
for l, r, c in coins:
93+
while i < n and r - coins[i][0] + 1 >= k:
94+
# print(r,coins[i][0],total)
95+
l0, r0, c0 = coins[i]
96+
ans = max(total + max(k + l0 - l, 0) * c, ans)
97+
total -= (r0 - l0 + 1) * c0
98+
i += 1
99+
100+
total += (r - l + 1) * c
101+
# print(total,l,r)
102+
if i < n and coins[i][0] != l0:
103+
start_l = r - k + 1
104+
ans = max(total + max(r0 - start_l + 1, 0) * c0, ans)
105+
return max(ans, total)
87106
```
88107

89108
#### Java
@@ -95,13 +114,161 @@ tags:
95114
#### C++
96115

97116
```cpp
98-
117+
class Solution {
118+
private:
119+
struct interval {
120+
int start = -1, end = -1, value = 0;
121+
122+
interval() = default;
123+
interval(int _start, int _end, int _value) : start(_start), end(_end), value(_value) {}
124+
125+
bool operator < (const interval &other) const {
126+
return start < other.start || (start == other.start && end < other.end);
127+
}
128+
int64_t cost() const { return int64_t(value) * (end - start + 1); }
129+
int64_t cost(int len) const { return int64_t(value) * len; }
130+
};
131+
public:
132+
long long maximumCoins(vector<vector<int>>& coins, int k) {
133+
int N = int(coins.size());
134+
vector<interval> A(N);
135+
136+
for (int i = 0; i < N; i++) A[i] = {coins[i][0], coins[i][1], coins[i][2]};
137+
sort(A.begin(), A.end());
138+
139+
int64_t ans = 0LL;
140+
{
141+
int64_t value = 0LL;
142+
int right = 0;
143+
for (int left = 0; left < N; left++) {
144+
while (right < N && A[right].end - A[left].start < k) {
145+
value += A[right].cost();
146+
++right;
147+
}
148+
149+
if (right < N) {
150+
int64_t extra = (A[right].start - A[left].start <= k) ? A[right].cost(k - A[right].start + A[left].start) : 0LL;
151+
ans = max(ans, value + extra);
152+
}
153+
154+
value -= A[left].cost();
155+
}
156+
}
157+
158+
{
159+
int64_t value = 0LL;
160+
int left = 0;
161+
for (int right = 0; right < N; right++) {
162+
value += A[right].cost();
163+
while (A[right].end - A[left].end >= k) {
164+
value -= A[left].cost();
165+
left++;
166+
}
167+
168+
int64_t extra = (A[right].end - A[left].start >= k) ? A[left].cost(A[right].end - A[left].start - k + 1) : 0LL;
169+
ans = max(ans, value - extra);
170+
}
171+
}
172+
173+
return ans;
174+
}
175+
};
99176
```
100177

101178
#### Go
102179

103180
```go
181+
func maximumCoins(coins [][]int, k int) int64 {
182+
sort.Slice(coins, func(i, j int) bool {
183+
return coins[i][0] < coins[j][0]
184+
})
185+
186+
n := len(coins)
187+
var total int64 = 0
188+
var ans int64 = 0
189+
i := 0
190+
l0, r0, c0 := coins[0][0], coins[0][1], coins[0][2]
191+
192+
for _, seg := range coins {
193+
l, r, c := seg[0], seg[1], seg[2]
194+
195+
for i < n && r-coins[i][0]+1 >= k {
196+
l0, r0, c0 = coins[i][0], coins[i][1], coins[i][2]
197+
ans = max64(ans, total+int64(max(k+l0-l, 0))*int64(c))
198+
total -= int64(r0-l0+1) * int64(c0)
199+
i++
200+
}
201+
202+
total += int64(r-l+1) * int64(c)
203+
204+
if i < n && coins[i][0] != l0 {
205+
startL := r - k + 1
206+
ans = max64(ans, total+int64(max(r0-startL+1, 0))*int64(c0))
207+
}
208+
}
209+
if total > ans {
210+
ans = total
211+
}
212+
return ans
213+
}
214+
215+
func max64(a, b int64) int64 {
216+
if a > b {
217+
return a
218+
}
219+
return b
220+
}
221+
222+
func max(a, b int) int {
223+
if a > b {
224+
return a
225+
}
226+
return b
227+
}
228+
```
104229

230+
#### Rust
231+
232+
```rust
233+
use std::cmp::{min, max};
234+
fn f(coins: &[(i32, i32, i32)], k: i32) -> i64 {
235+
let mut result = 0;
236+
let mut sum = 0;
237+
let mut r = 0;
238+
239+
for l in 0..coins.len() {
240+
while r < coins.len() && coins[l].0 + k > coins[r].1 {
241+
sum += (coins[r].1 - coins[r].0 + 1) as i64 * coins[r].2 as i64;
242+
r += 1;
243+
}
244+
result = max(result, sum);
245+
if r == coins.len() {
246+
break;
247+
}
248+
let cnt = coins[l].0 + k - coins[r].0;
249+
result = max(result, sum + max(cnt, 0) as i64 * coins[r].2 as i64);
250+
sum -= (coins[l].1 - coins[l].0 + 1) as i64 * coins[l].2 as i64;
251+
}
252+
253+
result
254+
}
255+
256+
impl Solution {
257+
pub fn maximum_coins(mut coins: Vec<Vec<i32>>, k: i32) -> i64 {
258+
let mut coins: Vec<_> = coins.into_iter()
259+
.map(|xs| (xs[0], xs[1], xs[2]))
260+
.collect();
261+
coins.sort();
262+
let a = f(&coins, k);
263+
coins.reverse();
264+
for i in 0..coins.len() {
265+
(coins[i].0, coins[i].1) = (-coins[i].1, -coins[i].0);
266+
}
267+
let b = f(&coins, k);
268+
269+
max(a, b)
270+
}
271+
}
105272
```
106273

107274
<!-- tabs:end -->

0 commit comments

Comments
 (0)