Skip to content

Commit 436938a

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1648
No.1648.Sell Diminishing-Valued Colored Balls
1 parent d8eb5b4 commit 436938a

File tree

6 files changed

+407
-2
lines changed

6 files changed

+407
-2
lines changed

‎solution/1600-1699/1648.Sell Diminishing-Valued Colored Balls/README.md

Lines changed: 144 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -63,22 +63,165 @@
6363

6464
<!-- 这里可写通用的实现逻辑 -->
6565

66+
**方法一：贪心 + 优化模拟**
67+
68+
要使得总价值最大，我们可以贪心地每次卖出数量最多的一种颜色的球。由于 `orders` 值域较大，如果直接简单地模拟，会超时。因此，我们需要优化模拟的过程。
69+
70+
实际上，我们不需要一次次进行模拟，我们可以跟踪数量最多的同色球的种类数 `cnt`，每一次可以卖出一批球，从而达到加速模拟的目的。
71+
72+
时间复杂度 $O(n\log n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `inventory` 的长度。
73+
6674
<!-- tabs:start -->
6775

6876
### **Python3**
6977

7078
<!-- 这里可写当前语言的特殊实现逻辑 -->
7179

7280
```python
73-
81+
class Solution:
82+
def maxProfit(self, inventory: List[int], orders: int) -> int:
83+
inventory.sort(reverse=True)
84+
mod = 10**9 + 7
85+
ans = i = 0
86+
n = len(inventory)
87+
while orders > 0:
88+
while i < n and inventory[i] >= inventory[0]:
89+
i += 1
90+
nxt = 0
91+
if i < n:
92+
nxt = inventory[i]
93+
cnt = i
94+
x = inventory[0] - nxt
95+
tot = cnt * x
96+
if tot > orders:
97+
decr = orders // cnt
98+
a1, an = inventory[0] - decr + 1, inventory[0]
99+
ans += (a1 + an) * decr // 2 * cnt
100+
ans += (inventory[0] - decr) * (orders % cnt)
101+
else:
102+
a1, an = nxt + 1, inventory[0]
103+
ans += (a1 + an) * x // 2 * cnt
104+
inventory[0] = nxt
105+
orders -= tot
106+
ans %= mod
107+
return ans
74108
```
75109

76110
### **Java**
77111

78112
<!-- 这里可写当前语言的特殊实现逻辑 -->
79113

80114
```java
115+
class Solution {
116+
private static final int MOD = (int) 1e9 + 7;
117+
118+
public int maxProfit(int[] inventory, int orders) {
119+
Arrays.sort(inventory);
120+
int n = inventory.length;
121+
for (int i = 0, j = n - 1; i < j; ++i, --j) {
122+
int t = inventory[i];
123+
inventory[i] = inventory[j];
124+
inventory[j] = t;
125+
}
126+
long ans = 0;
127+
int i = 0;
128+
while (orders > 0) {
129+
while (i < n && inventory[i] >= inventory[0]) {
130+
++i;
131+
}
132+
int nxt = i < n ? inventory[i] : 0;
133+
int cnt = i;
134+
long x = inventory[0] - nxt;
135+
long tot = cnt * x;
136+
if (tot > orders) {
137+
int decr = orders / cnt;
138+
long a1 = inventory[0] - decr + 1, an = inventory[0];
139+
ans += (a1 + an) * decr / 2 * cnt;
140+
ans += (a1 - 1) * (orders % cnt);
141+
} else {
142+
long a1 = nxt + 1, an = inventory[0];
143+
ans += (a1 + an) * x / 2 * cnt;
144+
inventory[0] = nxt;
145+
}
146+
orders -= tot;
147+
ans %= MOD;
148+
}
149+
return (int) ans;
150+
}
151+
}
152+
```
153+
154+
### **C++**
155+
156+
```cpp
157+
class Solution {
158+
public:
159+
int maxProfit(vector<int>& inventory, int orders) {
160+
long ans = 0, mod = 1e9 + 7;
161+
int i = 0, n = inventory.size();
162+
sort(inventory.rbegin(), inventory.rend());
163+
while (orders > 0) {
164+
while (i < n && inventory[i] >= inventory[0]) {
165+
++i;
166+
}
167+
int nxt = i < n ? inventory[i] : 0;
168+
int cnt = i;
169+
long x = inventory[0] - nxt;
170+
long tot = cnt * x;
171+
if (tot > orders) {
172+
int decr = orders / cnt;
173+
long a1 = inventory[0] - decr + 1, an = inventory[0];
174+
ans += (a1 + an) * decr / 2 * cnt;
175+
ans += (a1 - 1) * (orders % cnt);
176+
} else {
177+
long a1 = nxt + 1, an = inventory[0];
178+
ans += (a1 + an) * x / 2 * cnt;
179+
inventory[0] = nxt;
180+
}
181+
orders -= tot;
182+
ans %= mod;
183+
}
184+
return ans;
185+
}
186+
};
187+
```
81188
189+
### **Go**
190+
191+
```go
192+
func maxProfit(inventory []int, orders int) int {
193+
var mod int = 1e9 + 7
194+
i, n, ans := 0, len(inventory), 0
195+
sort.Ints(inventory)
196+
for i, j := 0, n-1; i < j; i, j = i+1, j-1 {
197+
inventory[i], inventory[j] = inventory[j], inventory[i]
198+
}
199+
for orders > 0 {
200+
for i < n && inventory[i] >= inventory[0] {
201+
i++
202+
}
203+
nxt := 0
204+
if i < n {
205+
nxt = inventory[i]
206+
}
207+
cnt := i
208+
x := inventory[0] - nxt
209+
tot := cnt * x
210+
if tot > orders {
211+
decr := orders / cnt
212+
a1, an := inventory[0]-decr+1, inventory[0]
213+
ans += (a1 + an) * decr / 2 * cnt
214+
ans += (a1 - 1) * (orders % cnt)
215+
} else {
216+
a1, an := nxt+1, inventory[0]
217+
ans += (a1 + an) * x / 2 * cnt
218+
inventory[0] = nxt
219+
}
220+
orders -= tot
221+
ans %= mod
222+
}
223+
return ans
224+
}
82225
```
83226

84227
### **...**

‎solution/1600-1699/1648.Sell Diminishing-Valued Colored Balls/README_EN.md

Lines changed: 136 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -47,13 +47,148 @@ The maximum total value is 3 + 2 + 5 + 4 + 3 + 2 = 19.
4747
### **Python3**
4848

4949
```python
50-
50+
class Solution:
51+
def maxProfit(self, inventory: List[int], orders: int) -> int:
52+
inventory.sort(reverse=True)
53+
mod = 10**9 + 7
54+
ans = i = 0
55+
n = len(inventory)
56+
while orders > 0:
57+
while i < n and inventory[i] >= inventory[0]:
58+
i += 1
59+
nxt = 0
60+
if i < n:
61+
nxt = inventory[i]
62+
cnt = i
63+
x = inventory[0] - nxt
64+
tot = cnt * x
65+
if tot > orders:
66+
decr = orders // cnt
67+
a1, an = inventory[0] - decr + 1, inventory[0]
68+
ans += (a1 + an) * decr // 2 * cnt
69+
ans += (inventory[0] - decr) * (orders % cnt)
70+
else:
71+
a1, an = nxt + 1, inventory[0]
72+
ans += (a1 + an) * x // 2 * cnt
73+
inventory[0] = nxt
74+
orders -= tot
75+
ans %= mod
76+
return ans
5177
```
5278

5379
### **Java**
5480

5581
```java
82+
class Solution {
83+
private static final int MOD = (int) 1e9 + 7;
84+
85+
public int maxProfit(int[] inventory, int orders) {
86+
Arrays.sort(inventory);
87+
int n = inventory.length;
88+
for (int i = 0, j = n - 1; i < j; ++i, --j) {
89+
int t = inventory[i];
90+
inventory[i] = inventory[j];
91+
inventory[j] = t;
92+
}
93+
long ans = 0;
94+
int i = 0;
95+
while (orders > 0) {
96+
while (i < n && inventory[i] >= inventory[0]) {
97+
++i;
98+
}
99+
int nxt = i < n ? inventory[i] : 0;
100+
int cnt = i;
101+
long x = inventory[0] - nxt;
102+
long tot = cnt * x;
103+
if (tot > orders) {
104+
int decr = orders / cnt;
105+
long a1 = inventory[0] - decr + 1, an = inventory[0];
106+
ans += (a1 + an) * decr / 2 * cnt;
107+
ans += (a1 - 1) * (orders % cnt);
108+
} else {
109+
long a1 = nxt + 1, an = inventory[0];
110+
ans += (a1 + an) * x / 2 * cnt;
111+
inventory[0] = nxt;
112+
}
113+
orders -= tot;
114+
ans %= MOD;
115+
}
116+
return (int) ans;
117+
}
118+
}
119+
```
120+
121+
### **C++**
122+
123+
```cpp
124+
class Solution {
125+
public:
126+
int maxProfit(vector<int>& inventory, int orders) {
127+
long ans = 0, mod = 1e9 + 7;
128+
int i = 0, n = inventory.size();
129+
sort(inventory.rbegin(), inventory.rend());
130+
while (orders > 0) {
131+
while (i < n && inventory[i] >= inventory[0]) {
132+
++i;
133+
}
134+
int nxt = i < n ? inventory[i] : 0;
135+
int cnt = i;
136+
long x = inventory[0] - nxt;
137+
long tot = cnt * x;
138+
if (tot > orders) {
139+
int decr = orders / cnt;
140+
long a1 = inventory[0] - decr + 1, an = inventory[0];
141+
ans += (a1 + an) * decr / 2 * cnt;
142+
ans += (a1 - 1) * (orders % cnt);
143+
} else {
144+
long a1 = nxt + 1, an = inventory[0];
145+
ans += (a1 + an) * x / 2 * cnt;
146+
inventory[0] = nxt;
147+
}
148+
orders -= tot;
149+
ans %= mod;
150+
}
151+
return ans;
152+
}
153+
};
154+
```
56155
156+
### **Go**
157+
158+
```go
159+
func maxProfit(inventory []int, orders int) int {
160+
var mod int = 1e9 + 7
161+
i, n, ans := 0, len(inventory), 0
162+
sort.Ints(inventory)
163+
for i, j := 0, n-1; i < j; i, j = i+1, j-1 {
164+
inventory[i], inventory[j] = inventory[j], inventory[i]
165+
}
166+
for orders > 0 {
167+
for i < n && inventory[i] >= inventory[0] {
168+
i++
169+
}
170+
nxt := 0
171+
if i < n {
172+
nxt = inventory[i]
173+
}
174+
cnt := i
175+
x := inventory[0] - nxt
176+
tot := cnt * x
177+
if tot > orders {
178+
decr := orders / cnt
179+
a1, an := inventory[0]-decr+1, inventory[0]
180+
ans += (a1 + an) * decr / 2 * cnt
181+
ans += (a1 - 1) * (orders % cnt)
182+
} else {
183+
a1, an := nxt+1, inventory[0]
184+
ans += (a1 + an) * x / 2 * cnt
185+
inventory[0] = nxt
186+
}
187+
orders -= tot
188+
ans %= mod
189+
}
190+
return ans
191+
}
57192
```
58193

59194
### **...**

‎solution/1600-1699/1648.Sell Diminishing-Valued Colored Balls/Solution.cpp

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
class Solution {
2+
public:
3+
int maxProfit(vector<int>& inventory, int orders) {
4+
long ans = 0, mod = 1e9 + 7;
5+
int i = 0, n = inventory.size();
6+
sort(inventory.rbegin(), inventory.rend());
7+
while (orders > 0) {
8+
while (i < n && inventory[i] >= inventory[0]) {
9+
++i;
10+
}
11+
int nxt = i < n ? inventory[i] : 0;
12+
int cnt = i;
13+
long x = inventory[0] - nxt;
14+
long tot = cnt * x;
15+
if (tot > orders) {
16+
int decr = orders / cnt;
17+
long a1 = inventory[0] - decr + 1, an = inventory[0];
18+
ans += (a1 + an) * decr / 2 * cnt;
19+
ans += (a1 - 1) * (orders % cnt);
20+
} else {
21+
long a1 = nxt + 1, an = inventory[0];
22+
ans += (a1 + an) * x / 2 * cnt;
23+
inventory[0] = nxt;
24+
}
25+
orders -= tot;
26+
ans %= mod;
27+
}
28+
return ans;
29+
}
30+
};

‎solution/1600-1699/1648.Sell Diminishing-Valued Colored Balls/Solution.go

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
func maxProfit(inventory []int, orders int) int {
2+
var mod int = 1e9 + 7
3+
i, n, ans := 0, len(inventory), 0
4+
sort.Ints(inventory)
5+
for i, j := 0, n-1; i < j; i, j = i+1, j-1 {
6+
inventory[i], inventory[j] = inventory[j], inventory[i]
7+
}
8+
for orders > 0 {
9+
for i < n && inventory[i] >= inventory[0] {
10+
i++
11+
}
12+
nxt := 0
13+
if i < n {
14+
nxt = inventory[i]
15+
}
16+
cnt := i
17+
x := inventory[0] - nxt
18+
tot := cnt * x
19+
if tot > orders {
20+
decr := orders / cnt
21+
a1, an := inventory[0]-decr+1, inventory[0]
22+
ans += (a1 + an) * decr / 2 * cnt
23+
ans += (a1 - 1) * (orders % cnt)
24+
} else {
25+
a1, an := nxt+1, inventory[0]
26+
ans += (a1 + an) * x / 2 * cnt
27+
inventory[0] = nxt
28+
}
29+
orders -= tot
30+
ans %= mod
31+
}
32+
return ans
33+
}

0 commit comments

Comments
 (0)