Skip to content

Commit 0c9a8c9

Browse files
samarthswami1016samarthswami1016
authored
Push
1 parent 5890b5c commit 0c9a8c9

File tree

5 files changed

+486
-0
lines changed

5 files changed

+486
-0
lines changed

‎solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/README.md

+167
Original file line numberDiff line numberDiff line change
@@ -91,18 +91,185 @@ tags:
9191

9292
```python
9393

94+
95+
from sortedcontainers import SortedList as SL
96+
fmin = lambda a, b: a if a < b else b
97+
class Solution:
98+
def minOperations(self, nums: List[int], l: int, k: int) -> int:
99+
n = len(nums)
100+
lt, gt = SL(), SL()
101+
ls, gs = 0, 0
102+
def add(x):
103+
nonlocal ls, gs
104+
if not lt or x <= lt[-1]:
105+
lt.add(x)
106+
ls += x
107+
else:
108+
gt.add(x)
109+
gs += x
110+
def remove(x):
111+
nonlocal ls, gs
112+
if x <= lt[-1]:
113+
lt.remove(x)
114+
ls -= x
115+
else:
116+
gt.remove(x)
117+
gs -= x
118+
def adjust():
119+
nonlocal ls, gs
120+
if len(lt) - len(gt) > 1:
121+
x = lt.pop(-1)
122+
ls -= x
123+
gt.add(x)
124+
gs += x
125+
elif len(gt) - len(lt) > 0:
126+
x = gt.pop(0)
127+
gs -= x
128+
lt.add(x)
129+
ls += x
130+
def getmed():
131+
return lt[-1]
132+
cost = [0] * (n-l+1)
133+
for i, x in enumerate(nums):
134+
add(x)
135+
adjust()
136+
if i >= l:
137+
remove(nums[i-l])
138+
adjust()
139+
if i >= l-1:
140+
med = getmed()
141+
cur = gs - med*(len(gt)) + med*len(lt) - ls
142+
cost[i-l+1] = cur
143+
# print(cost)
144+
dp = [[inf] * (k+1) for _ in range(n+1)]
145+
dp[0][0] = 0
146+
for i in range(1, n+1):
147+
for j in range(k+1):
148+
dp[i][j] = dp[i-1][j]
149+
if i-l >= 0 and k > 0:
150+
dp[i][j] = fmin(dp[i][j], dp[i-l][j-1] + cost[i-l])
151+
152+
return dp[n][k]
153+
154+
94155
```
95156

96157
#### Java
97158

98159
```java
99160

161+
162+
class Solution {
163+
164+
public long minOperations(int[] nums, int x, int k) {
165+
TreeSet<Integer> set1 = new TreeSet<>((o, p) -> nums[o] == nums[p] ? o - p : nums[o] - nums[p]), set2 = new TreeSet<>((o, p) -> nums[o] == nums[p] ? o - p : nums[o] - nums[p]);
166+
long sum[] = new long[nums.length - x + 1], left = 0, right = 0;
167+
for (int i = 0; i < nums.length; i++) {
168+
set2.add(i);
169+
left += nums[set2.first()];
170+
right += nums[i] - nums[set2.first()];
171+
set1.add(set2.pollFirst());
172+
if (set1.size() > set2.size()) {
173+
left -= nums[set1.last()];
174+
right += nums[set1.last()];
175+
set2.add(set1.pollLast());
176+
}
177+
if (i >= x - 1) {
178+
sum[i - x + 1] = nums[set2.first()] * (set1.size() - set2.size()) - left + right;
179+
left -= set1.remove(i - x + 1) ? nums[i - x + 1] : 0;
180+
right -= set2.remove(i - x + 1) ? nums[i - x + 1] : 0;
181+
}
182+
}
183+
long[][] dp = new long[sum.length + x][k + 1];
184+
for (int i = 0; i < sum.length + x; i++) {
185+
for (int j = 1; j <= k; j++) {
186+
dp[i][j] = 1000000000000000000L;
187+
}
188+
}
189+
for (int i = 0; i < sum.length; i++) {
190+
for (int j = 1; j <= k; j++) {
191+
dp[i + x][j] = Math.min(dp[i + x - 1][j], sum[i] + dp[i][j - 1]);
192+
}
193+
}
194+
return dp[sum.length + x - 1][k];
195+
}
196+
}
197+
198+
100199
```
101200

102201
#### C++
103202

104203
```cpp
105204

205+
206+
class Solution
207+
{
208+
public:
209+
#define ll long long
210+
ll f[100003][23];
211+
long long minOperations(vector<int> &a, int x, int k)
212+
{
213+
int n = a.size();
214+
for (int j = 0; j <= n; ++j)
215+
for (int i = 0; i <= k; ++i)
216+
f[j][i] = 1e18;
217+
f[0][0] = 0;
218+
multiset<int> A, B;
219+
ll as = 0, bs = 0;
220+
for (int i = 0; i < n; ++i)
221+
{
222+
if (B.empty())
223+
as += a[i], A.insert(a[i]);
224+
else if (A.empty())
225+
bs += a[i], B.insert(a[i]);
226+
else if (a[i] <= *A.rbegin())
227+
as += a[i], A.insert(a[i]);
228+
else
229+
bs += a[i], B.insert(a[i]);
230+
if (i - x >= 0)
231+
{
232+
if (A.find(a[i - x]) != A.end())
233+
{
234+
as -= a[i - x], A.erase(A.find(a[i - x]));
235+
}
236+
else
237+
{
238+
bs -= a[i - x], B.erase(B.find(a[i - x]));
239+
}
240+
}
241+
int sa = A.size(), sb = B.size();
242+
while (sa - sb >= 2)
243+
{
244+
int o = *A.rbegin();
245+
as -= o, bs += o;
246+
B.insert(*A.rbegin()), A.erase(prev(A.end()));
247+
--sa, ++sb;
248+
}
249+
while (sa < sb)
250+
{
251+
int o = *B.begin();
252+
bs -= o, as += o;
253+
A.insert(*B.begin()), B.erase(B.begin());
254+
++sa, --sb;
255+
}
256+
// 3 2
257+
// 3 3
258+
for (int j = 0; j <= k; ++j)
259+
f[i + 1][j] = f[i][j];
260+
if (i >= x - 1)
261+
{
262+
ll Z = *A.rbegin();
263+
ll cost = Z * A.size() - as + bs - Z * B.size();
264+
for (int j = 1; j <= k; ++j)
265+
f[i + 1][j] = min(f[i + 1][j], f[i - x + 1][j - 1] + cost);
266+
}
267+
}
268+
return f[n][k];
269+
}
270+
};
271+
272+
106273
```
107274

108275
#### Go

‎solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/README_EN.md

+167
Original file line numberDiff line numberDiff line change
@@ -86,18 +86,185 @@ tags:
8686

8787
```python
8888

89+
90+
from sortedcontainers import SortedList as SL
91+
fmin = lambda a, b: a if a < b else b
92+
class Solution:
93+
def minOperations(self, nums: List[int], l: int, k: int) -> int:
94+
n = len(nums)
95+
lt, gt = SL(), SL()
96+
ls, gs = 0, 0
97+
def add(x):
98+
nonlocal ls, gs
99+
if not lt or x <= lt[-1]:
100+
lt.add(x)
101+
ls += x
102+
else:
103+
gt.add(x)
104+
gs += x
105+
def remove(x):
106+
nonlocal ls, gs
107+
if x <= lt[-1]:
108+
lt.remove(x)
109+
ls -= x
110+
else:
111+
gt.remove(x)
112+
gs -= x
113+
def adjust():
114+
nonlocal ls, gs
115+
if len(lt) - len(gt) > 1:
116+
x = lt.pop(-1)
117+
ls -= x
118+
gt.add(x)
119+
gs += x
120+
elif len(gt) - len(lt) > 0:
121+
x = gt.pop(0)
122+
gs -= x
123+
lt.add(x)
124+
ls += x
125+
def getmed():
126+
return lt[-1]
127+
cost = [0] * (n-l+1)
128+
for i, x in enumerate(nums):
129+
add(x)
130+
adjust()
131+
if i >= l:
132+
remove(nums[i-l])
133+
adjust()
134+
if i >= l-1:
135+
med = getmed()
136+
cur = gs - med*(len(gt)) + med*len(lt) - ls
137+
cost[i-l+1] = cur
138+
# print(cost)
139+
dp = [[inf] * (k+1) for _ in range(n+1)]
140+
dp[0][0] = 0
141+
for i in range(1, n+1):
142+
for j in range(k+1):
143+
dp[i][j] = dp[i-1][j]
144+
if i-l >= 0 and k > 0:
145+
dp[i][j] = fmin(dp[i][j], dp[i-l][j-1] + cost[i-l])
146+
147+
return dp[n][k]
148+
149+
89150
```
90151

91152
#### Java
92153

93154
```java
94155

156+
157+
class Solution {
158+
159+
public long minOperations(int[] nums, int x, int k) {
160+
TreeSet<Integer> set1 = new TreeSet<>((o, p) -> nums[o] == nums[p] ? o - p : nums[o] - nums[p]), set2 = new TreeSet<>((o, p) -> nums[o] == nums[p] ? o - p : nums[o] - nums[p]);
161+
long sum[] = new long[nums.length - x + 1], left = 0, right = 0;
162+
for (int i = 0; i < nums.length; i++) {
163+
set2.add(i);
164+
left += nums[set2.first()];
165+
right += nums[i] - nums[set2.first()];
166+
set1.add(set2.pollFirst());
167+
if (set1.size() > set2.size()) {
168+
left -= nums[set1.last()];
169+
right += nums[set1.last()];
170+
set2.add(set1.pollLast());
171+
}
172+
if (i >= x - 1) {
173+
sum[i - x + 1] = nums[set2.first()] * (set1.size() - set2.size()) - left + right;
174+
left -= set1.remove(i - x + 1) ? nums[i - x + 1] : 0;
175+
right -= set2.remove(i - x + 1) ? nums[i - x + 1] : 0;
176+
}
177+
}
178+
long[][] dp = new long[sum.length + x][k + 1];
179+
for (int i = 0; i < sum.length + x; i++) {
180+
for (int j = 1; j <= k; j++) {
181+
dp[i][j] = 1000000000000000000L;
182+
}
183+
}
184+
for (int i = 0; i < sum.length; i++) {
185+
for (int j = 1; j <= k; j++) {
186+
dp[i + x][j] = Math.min(dp[i + x - 1][j], sum[i] + dp[i][j - 1]);
187+
}
188+
}
189+
return dp[sum.length + x - 1][k];
190+
}
191+
}
192+
193+
95194
```
96195

97196
#### C++
98197

99198
```cpp
100199

200+
201+
class Solution
202+
{
203+
public:
204+
#define ll long long
205+
ll f[100003][23];
206+
long long minOperations(vector<int> &a, int x, int k)
207+
{
208+
int n = a.size();
209+
for (int j = 0; j <= n; ++j)
210+
for (int i = 0; i <= k; ++i)
211+
f[j][i] = 1e18;
212+
f[0][0] = 0;
213+
multiset<int> A, B;
214+
ll as = 0, bs = 0;
215+
for (int i = 0; i < n; ++i)
216+
{
217+
if (B.empty())
218+
as += a[i], A.insert(a[i]);
219+
else if (A.empty())
220+
bs += a[i], B.insert(a[i]);
221+
else if (a[i] <= *A.rbegin())
222+
as += a[i], A.insert(a[i]);
223+
else
224+
bs += a[i], B.insert(a[i]);
225+
if (i - x >= 0)
226+
{
227+
if (A.find(a[i - x]) != A.end())
228+
{
229+
as -= a[i - x], A.erase(A.find(a[i - x]));
230+
}
231+
else
232+
{
233+
bs -= a[i - x], B.erase(B.find(a[i - x]));
234+
}
235+
}
236+
int sa = A.size(), sb = B.size();
237+
while (sa - sb >= 2)
238+
{
239+
int o = *A.rbegin();
240+
as -= o, bs += o;
241+
B.insert(*A.rbegin()), A.erase(prev(A.end()));
242+
--sa, ++sb;
243+
}
244+
while (sa < sb)
245+
{
246+
int o = *B.begin();
247+
bs -= o, as += o;
248+
A.insert(*B.begin()), B.erase(B.begin());
249+
++sa, --sb;
250+
}
251+
// 3 2
252+
// 3 3
253+
for (int j = 0; j <= k; ++j)
254+
f[i + 1][j] = f[i][j];
255+
if (i >= x - 1)
256+
{
257+
ll Z = *A.rbegin();
258+
ll cost = Z * A.size() - as + bs - Z * B.size();
259+
for (int j = 1; j <= k; ++j)
260+
f[i + 1][j] = min(f[i + 1][j], f[i - x + 1][j - 1] + cost);
261+
}
262+
}
263+
return f[n][k];
264+
}
265+
};
266+
267+
101268
```
102269

103270
#### Go

0 commit comments

Comments
 (0)