Skip to content

Commit b0a399e

Browse files
samarthswami1016samarthswami1016
authored
feat: add solutions to lc problem: No.3139
1 parent c24de6c commit b0a399e

File tree

6 files changed

+424
-6
lines changed

6 files changed

+424
-6
lines changed

‎solution/3100-3199/3139.Minimum Cost to Equalize Array/README.md

Lines changed: 142 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,9 +5,9 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3139.Mi
55
rating: 2666
66
source: 第 396 场周赛 Q4
77
tags:
8-
- 贪心
9-
- 数组
10-
- 枚举
8+
- 贪心
9+
- 数组
10+
- 枚举
1111
---
1212

1313
<!-- problem:start -->
@@ -121,24 +121,163 @@ tags:
121121

122122
```python
123123

124+
class Solution:
125+
MOD = 10 ** 9 + 7
126+
127+
def solve(self, k):
128+
sumDifferences = k * len(self.nums) - self.sumNums
129+
130+
ones = max(2 * (k - self.minNums) - sumDifferences, 0)
131+
if (sumDifferences - ones) & 1 != 0:
132+
ones += 1
133+
134+
return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2
135+
136+
def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:
137+
cost2 = min(2 * cost1, cost2)
138+
139+
self.nums = nums
140+
self.minNums = min(nums)
141+
self.sumNums = sum(nums)
142+
self.cost1 = cost1
143+
self.cost2 = cost2
144+
145+
m = max(nums)
146+
147+
sameParity = range(m, 10 ** 18, 2)
148+
diffParity = range(m + 1, 10 ** 18, 2)
149+
i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))
150+
j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))
151+
152+
return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD
153+
124154
```
125155

126156
#### Java
127157

128158
```java
129159

160+
class Solution {
161+
public int minCostToEqualizeArray(int[] A, int c1, int c2) {
162+
int ma = A[0], mi = A[0], n = A.length, mod = 1000000007;
163+
long total = 0;
164+
for (int a: A) {
165+
mi = Math.min(mi, a);
166+
ma = Math.max(ma, a);
167+
total += a;
168+
}
169+
total = 1l * ma * n - total;
170+
171+
if (c1 * 2 <= c2 || n <= 2) {
172+
return (int) ((total * c1) % mod);
173+
}
174+
175+
long op1 = Math.max(0L, (ma - mi) * 2L - total);
176+
long op2 = total - op1;
177+
long res = (op1 + op2 % 2) * c1 + op2 / 2 * c2;
178+
179+
total += op1 / (n - 2) * n;
180+
op1 %= n - 2;
181+
op2 = total - op1;
182+
res = Math.min(res, (op1 + op2 % 2) * c1 + op2 / 2 * c2);
183+
184+
for (int i = 0; i < 2; i++) {
185+
total += n;
186+
res = Math.min(res, total % 2 * c1 + total / 2 * c2);
187+
}
188+
return (int) (res % mod);
189+
}
190+
}
191+
130192
```
131193

132194
#### C++
133195

134196
```cpp
135197

198+
class Solution {
199+
public:
200+
int minCostToEqualizeArray(vector<int>& A, int c1, int c2) {
201+
int ma = *max_element(A.begin(), A.end());
202+
int mi = *min_element(A.begin(), A.end());
203+
int n = A.size(), mod = 1000000007;
204+
long long su = accumulate(A.begin(), A.end(), 0LL);
205+
long long total = 1LL * ma * n - su;
206+
207+
if (c1 * 2 <= c2 || n <= 2) {
208+
return (total * c1) % mod;
209+
}
210+
211+
long long op1 = max(0LL, (ma - mi) * 2 - total);
212+
long long op2 = total - op1;
213+
long long res = (op1 + op2 % 2) * c1 + op2 / 2 * c2;
214+
215+
total += op1 / (n - 2) * n;
216+
op1 %= n - 2;
217+
op2 = total - op1;
218+
res = min(res, (op1 + op2 % 2) * c1 + op2 / 2 * c2);
219+
220+
for (int i = 0; i < 2; i++) {
221+
total += n;
222+
res = min(res, total % 2 * c1 + total / 2 * c2);
223+
}
224+
225+
return res % mod;
226+
}
227+
};
228+
229+
136230
```
137231

138232
#### Go
139233

140234
```go
141235

236+
func minCostToEqualizeArray(nums []int, cost1 int, cost2 int) int {
237+
mx, mod := 0, int(1e9)+7
238+
for _, v := range nums {
239+
if v > mx {
240+
mx = v
241+
}
242+
}
243+
mv, cnt := 0, 0
244+
for _, v := range nums {
245+
d := mx - v
246+
if cnt += d; d > mv {
247+
mv = d
248+
}
249+
}
250+
ans := find(mv, cnt, cost1, cost2)
251+
if len(nums) <= 2 {
252+
return ans % mod
253+
}
254+
for (mv<<1) > cnt {
255+
mv, cnt = mv + 1, cnt + len(nums)
256+
ans = min(ans, find(mv, cnt, cost1, cost2))
257+
}
258+
mv, cnt = mv + 1, cnt + len(nums)
259+
ans = min(ans, find(mv, cnt, cost1, cost2))
260+
return ans % mod
261+
}
262+
263+
func find(mv, cnt, c1, c2 int) int {
264+
switch {
265+
case c1<<1 <= c2:
266+
return cnt * c1
267+
case mv<<1 <= cnt:
268+
return (cnt>>1)*c2 + (cnt&1)*c1
269+
}
270+
return (cnt-mv)*c2 + (mv<<1-cnt)*c1
271+
}
272+
273+
func min(x, y int) int {
274+
if x < y {
275+
return x
276+
}
277+
return y
278+
}
279+
280+
142281
```
143282

144283
<!-- tabs:end -->

‎solution/3100-3199/3139.Minimum Cost to Equalize Array/README_EN.md

Lines changed: 142 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,9 +5,9 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3139.Mi
55
rating: 2666
66
source: Weekly Contest 396 Q4
77
tags:
8-
- Greedy
9-
- Array
10-
- Enumeration
8+
- Greedy
9+
- Array
10+
- Enumeration
1111
---
1212

1313
<!-- problem:start -->
@@ -119,24 +119,163 @@ tags:
119119

120120
```python
121121

122+
class Solution:
123+
MOD = 10 ** 9 + 7
124+
125+
def solve(self, k):
126+
sumDifferences = k * len(self.nums) - self.sumNums
127+
128+
ones = max(2 * (k - self.minNums) - sumDifferences, 0)
129+
if (sumDifferences - ones) & 1 != 0:
130+
ones += 1
131+
132+
return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2
133+
134+
def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:
135+
cost2 = min(2 * cost1, cost2)
136+
137+
self.nums = nums
138+
self.minNums = min(nums)
139+
self.sumNums = sum(nums)
140+
self.cost1 = cost1
141+
self.cost2 = cost2
142+
143+
m = max(nums)
144+
145+
sameParity = range(m, 10 ** 18, 2)
146+
diffParity = range(m + 1, 10 ** 18, 2)
147+
i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))
148+
j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))
149+
150+
return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD
151+
122152
```
123153

124154
#### Java
125155

126156
```java
127157

158+
class Solution {
159+
public int minCostToEqualizeArray(int[] A, int c1, int c2) {
160+
int ma = A[0], mi = A[0], n = A.length, mod = 1000000007;
161+
long total = 0;
162+
for (int a: A) {
163+
mi = Math.min(mi, a);
164+
ma = Math.max(ma, a);
165+
total += a;
166+
}
167+
total = 1l * ma * n - total;
168+
169+
if (c1 * 2 <= c2 || n <= 2) {
170+
return (int) ((total * c1) % mod);
171+
}
172+
173+
long op1 = Math.max(0L, (ma - mi) * 2L - total);
174+
long op2 = total - op1;
175+
long res = (op1 + op2 % 2) * c1 + op2 / 2 * c2;
176+
177+
total += op1 / (n - 2) * n;
178+
op1 %= n - 2;
179+
op2 = total - op1;
180+
res = Math.min(res, (op1 + op2 % 2) * c1 + op2 / 2 * c2);
181+
182+
for (int i = 0; i < 2; i++) {
183+
total += n;
184+
res = Math.min(res, total % 2 * c1 + total / 2 * c2);
185+
}
186+
return (int) (res % mod);
187+
}
188+
}
189+
128190
```
129191

130192
#### C++
131193

132194
```cpp
133195

196+
class Solution {
197+
public:
198+
int minCostToEqualizeArray(vector<int>& A, int c1, int c2) {
199+
int ma = *max_element(A.begin(), A.end());
200+
int mi = *min_element(A.begin(), A.end());
201+
int n = A.size(), mod = 1000000007;
202+
long long su = accumulate(A.begin(), A.end(), 0LL);
203+
long long total = 1LL * ma * n - su;
204+
205+
if (c1 * 2 <= c2 || n <= 2) {
206+
return (total * c1) % mod;
207+
}
208+
209+
long long op1 = max(0LL, (ma - mi) * 2 - total);
210+
long long op2 = total - op1;
211+
long long res = (op1 + op2 % 2) * c1 + op2 / 2 * c2;
212+
213+
total += op1 / (n - 2) * n;
214+
op1 %= n - 2;
215+
op2 = total - op1;
216+
res = min(res, (op1 + op2 % 2) * c1 + op2 / 2 * c2);
217+
218+
for (int i = 0; i < 2; i++) {
219+
total += n;
220+
res = min(res, total % 2 * c1 + total / 2 * c2);
221+
}
222+
223+
return res % mod;
224+
}
225+
};
226+
227+
134228
```
135229

136230
#### Go
137231

138232
```go
139233

234+
func minCostToEqualizeArray(nums []int, cost1 int, cost2 int) int {
235+
mx, mod := 0, int(1e9)+7
236+
for _, v := range nums {
237+
if v > mx {
238+
mx = v
239+
}
240+
}
241+
mv, cnt := 0, 0
242+
for _, v := range nums {
243+
d := mx - v
244+
if cnt += d; d > mv {
245+
mv = d
246+
}
247+
}
248+
ans := find(mv, cnt, cost1, cost2)
249+
if len(nums) <= 2 {
250+
return ans % mod
251+
}
252+
for (mv<<1) > cnt {
253+
mv, cnt = mv + 1, cnt + len(nums)
254+
ans = min(ans, find(mv, cnt, cost1, cost2))
255+
}
256+
mv, cnt = mv + 1, cnt + len(nums)
257+
ans = min(ans, find(mv, cnt, cost1, cost2))
258+
return ans % mod
259+
}
260+
261+
func find(mv, cnt, c1, c2 int) int {
262+
switch {
263+
case c1<<1 <= c2:
264+
return cnt * c1
265+
case mv<<1 <= cnt:
266+
return (cnt>>1)*c2 + (cnt&1)*c1
267+
}
268+
return (cnt-mv)*c2 + (mv<<1-cnt)*c1
269+
}
270+
271+
func min(x, y int) int {
272+
if x < y {
273+
return x
274+
}
275+
return y
276+
}
277+
278+
140279
```
141280

142281
<!-- tabs:end -->

‎solution/3100-3199/3139.Minimum Cost to Equalize Array/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 minCostToEqualizeArray(std::vector<int> &A, int c1, int c2) {
4+
int ma = *std::max_element(A.begin(), A.end());
5+
int mi = *std::min_element(A.begin(), A.end());
6+
int n = A.size(), mod = 1000000007;
7+
long long su = std::accumulate(A.begin(), A.end(), 0LL);
8+
long long total = 1LL * ma * n - su;
9+
10+
if (c1 * 2 <= c2 || n <= 2) {
11+
return (total * c1) % mod;
12+
}
13+
14+
long long op1 = std::max(0LL, (ma - mi) * 2 - total);
15+
long long op2 = total - op1;
16+
long long res = (op1 + op2 % 2) * c1 + op2 / 2 * c2;
17+
18+
total += op1 / (n - 2) * n;
19+
op1 %= n - 2;
20+
op2 = total - op1;
21+
res = std::min(res, (op1 + op2 % 2) * c1 + op2 / 2 * c2);
22+
23+
for (int i = 0; i < 2; i++) {
24+
total += n;
25+
res = std::min(res, total % 2 * c1 + total / 2 * c2);
26+
}
27+
28+
return res % mod;
29+
}
30+
};

0 commit comments

Comments
 (0)