Skip to content

Commit 8c56e29

Browse files
samarthswami1016samarthswami1016
authoredApr 8, 2025
feat: add solutions to lc problem: No.3500
1 parent 10d7d3a commit 8c56e29

File tree

6 files changed

+443
-0
lines changed

6 files changed

+443
-0
lines changed
 

Diff for: ‎solution/3500-3599/3500.Minimum Cost to Divide Array Into Subarrays/README.md

+149
Original file line numberDiff line numberDiff line change
@@ -93,24 +93,173 @@ tags:
9393

9494
```python
9595

96+
class Solution:
97+
def minimumCost(self, nums: List[int], cost: List[int], k: int) -> int:
98+
n = len(nums)
99+
sumN = [0] * (n + 1)
100+
sumC = [0] * (n + 1)
101+
102+
for i in range(1, n + 1):
103+
sumN[i] = sumN[i - 1] + nums[i - 1]
104+
sumC[i] = sumC[i - 1] + cost[i - 1]
105+
106+
prevDp = [sys.maxsize] * (n + 1)
107+
prevDp[0] = 0
108+
109+
minCost = sys.maxsize
110+
111+
for m in range(1, n + 1):
112+
currentDp = [sys.maxsize] * (n + 1)
113+
queue = []
114+
115+
for r in range(m, n + 1):
116+
l = r - 1
117+
if l >= m - 1:
118+
x = sumC[l]
119+
y = prevDp[l]
120+
121+
while len(queue) >= 2:
122+
x1, y1 = queue[-2][0], queue[-2][1]
123+
x2, y2 = queue[-1][0], queue[-1][1]
124+
if (x2 - x1) * (y - y2) <= (x - x2) * (y2 - y1):
125+
queue.pop()
126+
else:
127+
break
128+
queue.append((x, y, l))
129+
130+
a = -(sumN[r] + k * m)
131+
132+
while len(queue) >= 2:
133+
x1, y1 = queue[0][0], queue[0][1]
134+
x2, y2 = queue[1][0], queue[1][1]
135+
if a * x1 + y1 >= a * x2 + y2:
136+
queue.pop(0)
137+
else:
138+
break
139+
140+
if queue:
141+
x, y = queue[0][0], queue[0][1]
142+
best = a * x + y
143+
currentCost = (sumN[r] + k * m) * sumC[r]
144+
currentCost += best
145+
if currentCost < currentDp[r]:
146+
currentDp[r] = currentCost
147+
148+
if currentDp[n] < minCost:
149+
minCost = currentDp[n]
150+
prevDp = currentDp
151+
152+
return minCost
153+
96154
```
97155

98156
#### Java
99157

100158
```java
101159

160+
class Solution {
161+
public long minimumCost(int[] nums, int[] cost, int k) {
162+
int n = nums.length;
163+
long[] prefixNums = new long[n];
164+
long[] prefixCosts = new long[n];
165+
prefixNums[0] = nums[0];
166+
for (int i = 1; i < n; i++) {
167+
prefixNums[i] = prefixNums[i - 1] + nums[i];
168+
}
169+
170+
prefixCosts[0] = cost[0];
171+
for (int i = 1; i < n; i++) {
172+
prefixCosts[i] = prefixCosts[i - 1] + cost[i];
173+
}
174+
175+
Long[][] dp = new Long[n][n];
176+
long ans = solve(0, 0, k, prefixNums, prefixCosts, dp);
177+
return ans;
178+
}
179+
180+
public long solve(int start, int end, int k, long[] prefixNums, long[] prefixCosts, Long[][] dp) {
181+
int n = prefixNums.length;
182+
if (end == n) {
183+
if (start == n) return 0;
184+
return Long.MAX_VALUE;
185+
}
186+
187+
if (dp[start][end] != null) return dp[start][end];
188+
189+
long currentNumsSum = prefixNums[end], currentCostSum = prefixCosts[n - 1];
190+
191+
if (start != 0){
192+
currentNumsSum = prefixNums[end] - prefixNums[start - 1];
193+
currentCostSum = prefixCosts[n - 1] - prefixCosts[start - 1];
194+
}
195+
196+
long currentSubarrayCost = (currentNumsSum + k) * currentCostSum;
197+
198+
long costIfCutHere = currentSubarrayCost + solve(end + 1, end + 1, k, prefixNums, prefixCosts, dp);
199+
long costIfExtend = solve(start, end + 1, k, prefixNums, prefixCosts, dp);
200+
201+
return dp[start][end] = Math.min(costIfCutHere, costIfExtend);
202+
}
203+
}
204+
102205
```
103206

104207
#### C++
105208

106209
```cpp
107210

211+
class Solution {
212+
public:
213+
long long minimumCost(vector<int>& nums, vector<int>& cost, int K) {
214+
int n = nums.size();
215+
216+
long long sn[n + 1], sc[n + 1];
217+
sn[0] = sc[0] = 0;
218+
for (int i = 1; i <= n; i++) {
219+
sn[i] = sn[i - 1] + nums[i - 1];
220+
sc[i] = sc[i - 1] + cost[i - 1];
221+
}
222+
223+
const long long INF = 1e18;
224+
long long f[n + 1];
225+
for (int i = 0; i <= n; i++) f[i] = INF;
226+
f[0] = 0;
227+
for (int i = 1; i <= n; i++) for (int j = 0; j < i; j++) {
228+
long long t = sn[i] * (sc[i] - sc[j]) + K * (sc[n] - sc[j]);
229+
f[i] = min(f[i], f[j] + t);
230+
}
231+
232+
return f[n];
233+
}
234+
};
235+
108236
```
109237
110238
#### Go
111239
112240
```go
113241
242+
func minimumCost(a []int, b []int, k int) int64 {
243+
n := len(a)
244+
dp := make([]int, n + 1)
245+
for i := range n {
246+
dp[i] = math.MaxInt / 4
247+
}
248+
prea := make([]int, n + 1)
249+
preb := make([]int, n + 1)
250+
for i := range n {
251+
prea[i + 1] = prea[i] + a[i]
252+
preb[i + 1] = preb[i] + b[i]
253+
}
254+
for i := n - 1; i >= 0; i-- {
255+
for j := i; j < n; j++ {
256+
tot := (preb[j + 1] - preb[i]) * (prea[j + 1] - prea[0]) + (preb[n] - preb[i]) * k
257+
dp[i] = min(dp[i], tot + dp[j + 1])
258+
}
259+
}
260+
return int64(dp[0])
261+
}
262+
114263
```
115264

116265
<!-- tabs:end -->

Diff for: ‎solution/3500-3599/3500.Minimum Cost to Divide Array Into Subarrays/README_EN.md

+149
Original file line numberDiff line numberDiff line change
@@ -88,24 +88,173 @@ The minimum total cost possible can be achieved by dividing <code>nums</code> in
8888

8989
```python
9090

91+
class Solution:
92+
def minimumCost(self, nums: List[int], cost: List[int], k: int) -> int:
93+
n = len(nums)
94+
sumN = [0] * (n + 1)
95+
sumC = [0] * (n + 1)
96+
97+
for i in range(1, n + 1):
98+
sumN[i] = sumN[i - 1] + nums[i - 1]
99+
sumC[i] = sumC[i - 1] + cost[i - 1]
100+
101+
prevDp = [sys.maxsize] * (n + 1)
102+
prevDp[0] = 0
103+
104+
minCost = sys.maxsize
105+
106+
for m in range(1, n + 1):
107+
currentDp = [sys.maxsize] * (n + 1)
108+
queue = []
109+
110+
for r in range(m, n + 1):
111+
l = r - 1
112+
if l >= m - 1:
113+
x = sumC[l]
114+
y = prevDp[l]
115+
116+
while len(queue) >= 2:
117+
x1, y1 = queue[-2][0], queue[-2][1]
118+
x2, y2 = queue[-1][0], queue[-1][1]
119+
if (x2 - x1) * (y - y2) <= (x - x2) * (y2 - y1):
120+
queue.pop()
121+
else:
122+
break
123+
queue.append((x, y, l))
124+
125+
a = -(sumN[r] + k * m)
126+
127+
while len(queue) >= 2:
128+
x1, y1 = queue[0][0], queue[0][1]
129+
x2, y2 = queue[1][0], queue[1][1]
130+
if a * x1 + y1 >= a * x2 + y2:
131+
queue.pop(0)
132+
else:
133+
break
134+
135+
if queue:
136+
x, y = queue[0][0], queue[0][1]
137+
best = a * x + y
138+
currentCost = (sumN[r] + k * m) * sumC[r]
139+
currentCost += best
140+
if currentCost < currentDp[r]:
141+
currentDp[r] = currentCost
142+
143+
if currentDp[n] < minCost:
144+
minCost = currentDp[n]
145+
prevDp = currentDp
146+
147+
return minCost
148+
91149
```
92150

93151
#### Java
94152

95153
```java
96154

155+
class Solution {
156+
public long minimumCost(int[] nums, int[] cost, int k) {
157+
int n = nums.length;
158+
long[] prefixNums = new long[n];
159+
long[] prefixCosts = new long[n];
160+
prefixNums[0] = nums[0];
161+
for (int i = 1; i < n; i++) {
162+
prefixNums[i] = prefixNums[i - 1] + nums[i];
163+
}
164+
165+
prefixCosts[0] = cost[0];
166+
for (int i = 1; i < n; i++) {
167+
prefixCosts[i] = prefixCosts[i - 1] + cost[i];
168+
}
169+
170+
Long[][] dp = new Long[n][n];
171+
long ans = solve(0, 0, k, prefixNums, prefixCosts, dp);
172+
return ans;
173+
}
174+
175+
public long solve(int start, int end, int k, long[] prefixNums, long[] prefixCosts, Long[][] dp) {
176+
int n = prefixNums.length;
177+
if (end == n) {
178+
if (start == n) return 0;
179+
return Long.MAX_VALUE;
180+
}
181+
182+
if (dp[start][end] != null) return dp[start][end];
183+
184+
long currentNumsSum = prefixNums[end], currentCostSum = prefixCosts[n - 1];
185+
186+
if (start != 0){
187+
currentNumsSum = prefixNums[end] - prefixNums[start - 1];
188+
currentCostSum = prefixCosts[n - 1] - prefixCosts[start - 1];
189+
}
190+
191+
long currentSubarrayCost = (currentNumsSum + k) * currentCostSum;
192+
193+
long costIfCutHere = currentSubarrayCost + solve(end + 1, end + 1, k, prefixNums, prefixCosts, dp);
194+
long costIfExtend = solve(start, end + 1, k, prefixNums, prefixCosts, dp);
195+
196+
return dp[start][end] = Math.min(costIfCutHere, costIfExtend);
197+
}
198+
}
199+
97200
```
98201

99202
#### C++
100203

101204
```cpp
102205

206+
class Solution {
207+
public:
208+
long long minimumCost(vector<int>& nums, vector<int>& cost, int K) {
209+
int n = nums.size();
210+
211+
long long sn[n + 1], sc[n + 1];
212+
sn[0] = sc[0] = 0;
213+
for (int i = 1; i <= n; i++) {
214+
sn[i] = sn[i - 1] + nums[i - 1];
215+
sc[i] = sc[i - 1] + cost[i - 1];
216+
}
217+
218+
const long long INF = 1e18;
219+
long long f[n + 1];
220+
for (int i = 0; i <= n; i++) f[i] = INF;
221+
f[0] = 0;
222+
for (int i = 1; i <= n; i++) for (int j = 0; j < i; j++) {
223+
long long t = sn[i] * (sc[i] - sc[j]) + K * (sc[n] - sc[j]);
224+
f[i] = min(f[i], f[j] + t);
225+
}
226+
227+
return f[n];
228+
}
229+
};
230+
103231
```
104232
105233
#### Go
106234
107235
```go
108236
237+
func minimumCost(a []int, b []int, k int) int64 {
238+
n := len(a)
239+
dp := make([]int, n + 1)
240+
for i := range n {
241+
dp[i] = math.MaxInt / 4
242+
}
243+
prea := make([]int, n + 1)
244+
preb := make([]int, n + 1)
245+
for i := range n {
246+
prea[i + 1] = prea[i] + a[i]
247+
preb[i + 1] = preb[i] + b[i]
248+
}
249+
for i := n - 1; i >= 0; i-- {
250+
for j := i; j < n; j++ {
251+
tot := (preb[j + 1] - preb[i]) * (prea[j + 1] - prea[0]) + (preb[n] - preb[i]) * k
252+
dp[i] = min(dp[i], tot + dp[j + 1])
253+
}
254+
}
255+
return int64(dp[0])
256+
}
257+
109258
```
110259

111260
<!-- tabs:end -->

Diff for: ‎solution/3500-3599/3500.Minimum Cost to Divide Array Into Subarrays/solution.cpp

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
long long minimumCost(vector<int>& nums, vector<int>& cost, int K) {
4+
int n = nums.size();
5+
6+
long long sn[n + 1], sc[n + 1];
7+
sn[0] = sc[0] = 0;
8+
for (int i = 1; i <= n; i++) {
9+
sn[i] = sn[i - 1] + nums[i - 1];
10+
sc[i] = sc[i - 1] + cost[i - 1];
11+
}
12+
13+
const long long INF = 1e18;
14+
long long f[n + 1];
15+
for (int i = 0; i <= n; i++) f[i] = INF;
16+
f[0] = 0;
17+
for (int i = 1; i <= n; i++) for (int j = 0; j < i; j++) {
18+
long long t = sn[i] * (sc[i] - sc[j]) + K * (sc[n] - sc[j]);
19+
f[i] = min(f[i], f[j] + t);
20+
}
21+
22+
return f[n];
23+
}
24+
};

Diff for: ‎solution/3500-3599/3500.Minimum Cost to Divide Array Into Subarrays/solution.go

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
func minimumCost(a []int, b []int, k int) int64 {
2+
n := len(a)
3+
dp := make([]int, n + 1)
4+
for i := range n {
5+
dp[i] = math.MaxInt / 4
6+
}
7+
prea := make([]int, n + 1)
8+
preb := make([]int, n + 1)
9+
for i := range n {
10+
prea[i + 1] = prea[i] + a[i]
11+
preb[i + 1] = preb[i] + b[i]
12+
}
13+
for i := n - 1; i >= 0; i-- {
14+
for j := i; j < n; j++ {
15+
tot := (preb[j + 1] - preb[i]) * (prea[j + 1] - prea[0]) + (preb[n] - preb[i]) * k
16+
dp[i] = min(dp[i], tot + dp[j + 1])
17+
}
18+
}
19+
return int64(dp[0])
20+
}

0 commit comments

Comments
 (0)