Skip to content

Commit c8a425f

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1043
No.1043.Partition Array for Maximum Sum
1 parent b74d5af commit c8a425f

File tree

6 files changed

+209
-12
lines changed

6 files changed

+209
-12
lines changed

‎solution/1000-1099/1043.Partition Array for Maximum Sum/README.md

+78-1
Original file line numberDiff line numberDiff line change
@@ -53,22 +53,99 @@
5353

5454
<!-- 这里可写通用的实现逻辑 -->
5555

56+
**方法一：动态规划**
57+
58+
我们定义 $f[i]$ 表示将数组的前 $i$ 个元素分隔成若干个子数组，最终的最大元素和。那么 $f[i + 1]$ 的值可以通过枚举 $j$ 的值得到，其中 $j$ 的取值范围为 $[i - k + 1, i]$，对于每个 $j$，我们都可以将 $[j, i]$ 这一段分隔出来，这一段的最大值为 $mx$，那么 $f[i + 1]$ 的值可以通过 $f[j] + mx * (i - j + 1)$ 得到。最后的答案即为 $f[n]$。
59+
60+
时间复杂度 $O(n \times k)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。
61+
5662
<!-- tabs:start -->
5763

5864
### **Python3**
5965

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

6268
```python
63-
69+
class Solution:
70+
def maxSumAfterPartitioning(self, arr: List[int], k: int) -> int:
71+
n = len(arr)
72+
f = [0] * (n + 1)
73+
for i in range(n):
74+
mx = 0
75+
for j in range(i, max(-1, i - k), -1):
76+
mx = max(mx, arr[j])
77+
t = mx * (i - j + 1) + f[j]
78+
f[i + 1] = max(f[i + 1], t)
79+
return f[n]
6480
```
6581

6682
### **Java**
6783

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

7086
```java
87+
class Solution {
88+
public int maxSumAfterPartitioning(int[] arr, int k) {
89+
int n = arr.length;
90+
int[] f = new int[n + 1];
91+
for (int i = 0; i < n; ++i) {
92+
int mx = 0;
93+
for (int j = i; j >= Math.max(0, i - k + 1); --j) {
94+
mx = Math.max(mx, arr[j]);
95+
int t = mx * (i - j + 1) + f[j];
96+
f[i + 1] = Math.max(f[i + 1], t);
97+
}
98+
}
99+
return f[n];
100+
}
101+
}
102+
```
103+
104+
### **C++**
105+
106+
```cpp
107+
class Solution {
108+
public:
109+
int maxSumAfterPartitioning(vector<int>& arr, int k) {
110+
int n = arr.size();
111+
int f[n + 1];
112+
memset(f, 0, sizeof f);
113+
for (int i = 0; i < n; ++i) {
114+
int mx = 0;
115+
for (int j = i; j >= max(0, i - k + 1); --j) {
116+
mx = max(mx, arr[j]);
117+
int t = mx * (i - j + 1) + f[j];
118+
f[i + 1] = max(f[i + 1], t);
119+
}
120+
}
121+
return f[n];
122+
}
123+
};
124+
```
71125
126+
### **Go**
127+
128+
```go
129+
func maxSumAfterPartitioning(arr []int, k int) int {
130+
n := len(arr)
131+
f := make([]int, n+1)
132+
for i := 0; i < n; i++ {
133+
mx := 0
134+
for j := i; j >= max(0, i-k+1); j-- {
135+
mx = max(mx, arr[j])
136+
t := mx*(i-j+1) + f[j]
137+
f[i+1] = max(f[i+1], t)
138+
}
139+
}
140+
return f[n]
141+
}
142+
143+
func max(a, b int) int {
144+
if a > b {
145+
return a
146+
}
147+
return b
148+
}
72149
```
73150

74151
### **...**

‎solution/1000-1099/1043.Partition Array for Maximum Sum/README_EN.md

+72-1
Original file line numberDiff line numberDiff line change
@@ -47,13 +47,84 @@
4747
### **Python3**
4848

4949
```python
50-
50+
class Solution:
51+
def maxSumAfterPartitioning(self, arr: List[int], k: int) -> int:
52+
n = len(arr)
53+
f = [0] * (n + 1)
54+
for i in range(n):
55+
mx = 0
56+
for j in range(i, max(-1, i - k), -1):
57+
mx = max(mx, arr[j])
58+
t = mx * (i - j + 1) + f[j]
59+
f[i + 1] = max(f[i + 1], t)
60+
return f[n]
5161
```
5262

5363
### **Java**
5464

5565
```java
66+
class Solution {
67+
public int maxSumAfterPartitioning(int[] arr, int k) {
68+
int n = arr.length;
69+
int[] f = new int[n + 1];
70+
for (int i = 0; i < n; ++i) {
71+
int mx = 0;
72+
for (int j = i; j >= Math.max(0, i - k + 1); --j) {
73+
mx = Math.max(mx, arr[j]);
74+
int t = mx * (i - j + 1) + f[j];
75+
f[i + 1] = Math.max(f[i + 1], t);
76+
}
77+
}
78+
return f[n];
79+
}
80+
}
81+
```
82+
83+
### **C++**
84+
85+
```cpp
86+
class Solution {
87+
public:
88+
int maxSumAfterPartitioning(vector<int>& arr, int k) {
89+
int n = arr.size();
90+
int f[n + 1];
91+
memset(f, 0, sizeof f);
92+
for (int i = 0; i < n; ++i) {
93+
int mx = 0;
94+
for (int j = i; j >= max(0, i - k + 1); --j) {
95+
mx = max(mx, arr[j]);
96+
int t = mx * (i - j + 1) + f[j];
97+
f[i + 1] = max(f[i + 1], t);
98+
}
99+
}
100+
return f[n];
101+
}
102+
};
103+
```
56104
105+
### **Go**
106+
107+
```go
108+
func maxSumAfterPartitioning(arr []int, k int) int {
109+
n := len(arr)
110+
f := make([]int, n+1)
111+
for i := 0; i < n; i++ {
112+
mx := 0
113+
for j := i; j >= max(0, i-k+1); j-- {
114+
mx = max(mx, arr[j])
115+
t := mx*(i-j+1) + f[j]
116+
f[i+1] = max(f[i+1], t)
117+
}
118+
}
119+
return f[n]
120+
}
121+
122+
func max(a, b int) int {
123+
if a > b {
124+
return a
125+
}
126+
return b
127+
}
57128
```
58129

59130
### **...**

‎solution/1000-1099/1043.Partition Array for Maximum Sum/Solution.cpp

+17
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
class Solution {
2+
public:
3+
int maxSumAfterPartitioning(vector<int>& arr, int k) {
4+
int n = arr.size();
5+
int f[n + 1];
6+
memset(f, 0, sizeof f);
7+
for (int i = 0; i < n; ++i) {
8+
int mx = 0;
9+
for (int j = i; j >= max(0, i - k + 1); --j) {
10+
mx = max(mx, arr[j]);
11+
int t = mx * (i - j + 1) + f[j];
12+
f[i + 1] = max(f[i + 1], t);
13+
}
14+
}
15+
return f[n];
16+
}
17+
};

‎solution/1000-1099/1043.Partition Array for Maximum Sum/Solution.go

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
func maxSumAfterPartitioning(arr []int, k int) int {
2+
n := len(arr)
3+
f := make([]int, n+1)
4+
for i := 0; i < n; i++ {
5+
mx := 0
6+
for j := i; j >= max(0, i-k+1); j-- {
7+
mx = max(mx, arr[j])
8+
t := mx*(i-j+1) + f[j]
9+
f[i+1] = max(f[i+1], t)
10+
}
11+
}
12+
return f[n]
13+
}
14+
15+
func max(a, b int) int {
16+
if a > b {
17+
return a
18+
}
19+
return b
20+
}

‎solution/1000-1099/1043.Partition Array for Maximum Sum/Solution.java

+11-10
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,15 @@
11
class Solution {
2-
public int maxSumAfterPartitioning(int[] A, int K) {
3-
int[] dp = new int[A.length];
4-
int max = 0;
5-
for (int i = 0; i < A.length; i++) {
6-
max = 0;
7-
for (int k = 0; k < K && i - k >= 0; k++) {
8-
max = Math.max(max, A[i - k]);
9-
dp[i] = Math.max(dp[i], (i - 1 >= k ? dp[i - k - 1] : 0) + max * (k + 1));
2+
public int maxSumAfterPartitioning(int[] arr, int k) {
3+
int n = arr.length;
4+
int[] f = new int[n + 1];
5+
for (int i = 0; i < n; ++i) {
6+
int mx = 0;
7+
for (int j = i; j >= Math.max(0, i - k + 1); --j) {
8+
mx = Math.max(mx, arr[j]);
9+
int t = mx * (i - j + 1) + f[j];
10+
f[i + 1] = Math.max(f[i + 1], t);
1011
}
1112
}
12-
return dp[A.length - 1];
13+
return f[n];
1314
}
14-
}
15+
}

‎solution/1000-1099/1043.Partition Array for Maximum Sum/Solution.py

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
class Solution:
2+
def maxSumAfterPartitioning(self, arr: List[int], k: int) -> int:
3+
n = len(arr)
4+
f = [0] * (n + 1)
5+
for i in range(n):
6+
mx = 0
7+
for j in range(i, max(-1, i - k), -1):
8+
mx = max(mx, arr[j])
9+
t = mx * (i - j + 1) + f[j]
10+
f[i + 1] = max(f[i + 1], t)
11+
return f[n]

0 commit comments

Comments
 (0)