Skip to content

Commit 6a71c12

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0813
No.0813.Largest Sum of Averages
1 parent bbce022 commit 6a71c12

File tree

6 files changed

+403
-2
lines changed

6 files changed

+403
-2
lines changed

‎solution/0800-0899/0813.Largest Sum of Averages/README.md

Lines changed: 148 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -46,22 +46,169 @@ nums 的最优分组是[9], [1, 2, 3], [9]. 得到的分数是 9 + (1 + 2 + 3) /
4646

4747
<!-- 这里可写通用的实现逻辑 -->
4848

49+
**方法一：记忆化搜索**
50+
51+
定义 $n$ 表示数组 `nums` 的长度。
52+
53+
我们设计函数 $dfs(i, k)$，表示从数组下标 $i$ 开始，最多分成 $k$ 组的最大平均值和。答案为 $dfs(0, k)$。
54+
55+
当 $i=n$ 时，表示已经遍历到数组末尾，此时返回 $0$。
56+
57+
当 $k=1$ 时，表示只剩下一组，此时返回从下标 $i$ 开始到数组末尾的平均值。
58+
59+
否则，我们在 $[i, ..n-1]$ 的范围内枚举分组的结束位置 $j$，计算从下标 $i$ 到下标 $j$ 的平均值，以及从下标 $j+1$ 开始，最多分成 $k-1$ 组的最大平均值和，取二者之和的最大值。
60+
61+
为了避免重复计算，我们用数组 $f$ 记忆化函数 $dfs(i, k)$ 的返回值。
62+
63+
时间复杂度 $O(n^2\times k)$。其中 $n$ 表示数组 `nums` 的长度。
64+
4965
<!-- tabs:start -->
5066

5167
### **Python3**
5268

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

5571
```python
56-
72+
class Solution:
73+
def largestSumOfAverages(self, nums: List[int], k: int) -> float:
74+
@cache
75+
def dfs(i, k):
76+
if i == n:
77+
return 0
78+
if k == 1:
79+
return (s[-1] - s[i]) / (n - i)
80+
ans = 0
81+
for j in range(i, n):
82+
t = (s[j + 1] - s[i]) / (j - i + 1) + dfs(j + 1, k - 1)
83+
ans = max(ans, t)
84+
return ans
85+
86+
n = len(nums)
87+
s = list(accumulate(nums, initial=0))
88+
return dfs(0, k)
5789
```
5890

5991
### **Java**
6092

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

6395
```java
96+
class Solution {
97+
private double[][] f;
98+
private int[] s;
99+
private int n;
100+
101+
public double largestSumOfAverages(int[] nums, int k) {
102+
n = nums.length;
103+
s = new int[n + 1];
104+
f = new double[n + 1][k + 1];
105+
for (var e : f) {
106+
Arrays.fill(e, -1);
107+
}
108+
for (int i = 0; i < n; ++i) {
109+
s[i + 1] = s[i] + nums[i];
110+
}
111+
return dfs(0, k);
112+
}
113+
114+
private double dfs(int i, int k) {
115+
if (i == n) {
116+
return 0;
117+
}
118+
if (k == 1) {
119+
return (s[n] - s[i]) * 1.0 / (n - i);
120+
}
121+
if (f[i][k] >= 0) {
122+
return f[i][k];
123+
}
124+
double ans = 0;
125+
for (int j = i; j < n; ++j) {
126+
double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
127+
ans = Math.max(ans, t);
128+
}
129+
f[i][k] = ans;
130+
return ans;
131+
}
132+
}
133+
```
134+
135+
### **C++**
136+
137+
```cpp
138+
class Solution {
139+
public:
140+
double f[110][110];
141+
int s[110];
142+
int n;
143+
144+
double largestSumOfAverages(vector<int>& nums, int k) {
145+
n = nums.size();
146+
s[0] = 0;
147+
for (int i = 0; i < n; ++i) {
148+
s[i + 1] = s[i] + nums[i];
149+
}
150+
memset(f, -1, sizeof f);
151+
return dfs(0, k);
152+
}
153+
154+
double dfs(int i, int k) {
155+
if (i == n) {
156+
return 0;
157+
}
158+
if (k == 1) {
159+
return (s[n] - s[i]) * 1.0 / (n - i);
160+
}
161+
if (f[i][k] >= 0) {
162+
return f[i][k];
163+
}
164+
double ans = 0;
165+
for (int j = i; j < n; ++j) {
166+
double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
167+
ans = max(ans, t);
168+
}
169+
f[i][k] = ans;
170+
return ans;
171+
}
172+
};
173+
```
64174
175+
### **Go**
176+
177+
```go
178+
func largestSumOfAverages(nums []int, k int) float64 {
179+
n := len(nums)
180+
s := make([]int, n+1)
181+
f := make([][]float64, n+1)
182+
for i := range f {
183+
f[i] = make([]float64, k+1)
184+
for j := range f[i] {
185+
f[i][j] = -1
186+
}
187+
}
188+
for i, v := range nums {
189+
s[i+1] = s[i] + v
190+
}
191+
var dfs func(i, k int) float64
192+
dfs = func(i, k int) float64 {
193+
if i == n {
194+
return 0
195+
}
196+
if k == 1 {
197+
return float64(s[n]-s[i]) / float64(n-i)
198+
}
199+
if f[i][k] >= 0 {
200+
return f[i][k]
201+
}
202+
var ans float64
203+
for j := i; j < n; j++ {
204+
t := float64(s[j+1]-s[i])/float64(j-i+1) + dfs(j+1, k-1)
205+
ans = math.Max(ans, t)
206+
}
207+
f[i][k] = ans
208+
return ans
209+
}
210+
return dfs(0, k)
211+
}
65212
```
66213

67214
### **...**

‎solution/0800-0899/0813.Largest Sum of Averages/README_EN.md

Lines changed: 132 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -45,13 +45,144 @@ That partition would lead to a score of 5 + 2 + 6 = 13, which is worse.
4545
### **Python3**
4646

4747
```python
48-
48+
class Solution:
49+
def largestSumOfAverages(self, nums: List[int], k: int) -> float:
50+
@cache
51+
def dfs(i, k):
52+
if i == n:
53+
return 0
54+
if k == 1:
55+
return (s[-1] - s[i]) / (n - i)
56+
ans = 0
57+
for j in range(i, n):
58+
t = (s[j + 1] - s[i]) / (j - i + 1) + dfs(j + 1, k - 1)
59+
ans = max(ans, t)
60+
return ans
61+
62+
n = len(nums)
63+
s = list(accumulate(nums, initial=0))
64+
return dfs(0, k)
4965
```
5066

5167
### **Java**
5268

5369
```java
70+
class Solution {
71+
private double[][] f;
72+
private int[] s;
73+
private int n;
74+
75+
public double largestSumOfAverages(int[] nums, int k) {
76+
n = nums.length;
77+
s = new int[n + 1];
78+
f = new double[n + 1][k + 1];
79+
for (var e : f) {
80+
Arrays.fill(e, -1);
81+
}
82+
for (int i = 0; i < n; ++i) {
83+
s[i + 1] = s[i] + nums[i];
84+
}
85+
return dfs(0, k);
86+
}
87+
88+
private double dfs(int i, int k) {
89+
if (i == n) {
90+
return 0;
91+
}
92+
if (k == 1) {
93+
return (s[n] - s[i]) * 1.0 / (n - i);
94+
}
95+
if (f[i][k] >= 0) {
96+
return f[i][k];
97+
}
98+
double ans = 0;
99+
for (int j = i; j < n; ++j) {
100+
double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
101+
ans = Math.max(ans, t);
102+
}
103+
f[i][k] = ans;
104+
return ans;
105+
}
106+
}
107+
```
108+
109+
### **C++**
110+
111+
```cpp
112+
class Solution {
113+
public:
114+
double f[110][110];
115+
int s[110];
116+
int n;
117+
118+
double largestSumOfAverages(vector<int>& nums, int k) {
119+
n = nums.size();
120+
s[0] = 0;
121+
for (int i = 0; i < n; ++i) {
122+
s[i + 1] = s[i] + nums[i];
123+
}
124+
memset(f, -1, sizeof f);
125+
return dfs(0, k);
126+
}
127+
128+
double dfs(int i, int k) {
129+
if (i == n) {
130+
return 0;
131+
}
132+
if (k == 1) {
133+
return (s[n] - s[i]) * 1.0 / (n - i);
134+
}
135+
if (f[i][k] >= 0) {
136+
return f[i][k];
137+
}
138+
double ans = 0;
139+
for (int j = i; j < n; ++j) {
140+
double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
141+
ans = max(ans, t);
142+
}
143+
f[i][k] = ans;
144+
return ans;
145+
}
146+
};
147+
```
54148
149+
### **Go**
150+
151+
```go
152+
func largestSumOfAverages(nums []int, k int) float64 {
153+
n := len(nums)
154+
s := make([]int, n+1)
155+
f := make([][]float64, n+1)
156+
for i := range f {
157+
f[i] = make([]float64, k+1)
158+
for j := range f[i] {
159+
f[i][j] = -1
160+
}
161+
}
162+
for i, v := range nums {
163+
s[i+1] = s[i] + v
164+
}
165+
var dfs func(i, k int) float64
166+
dfs = func(i, k int) float64 {
167+
if i == n {
168+
return 0
169+
}
170+
if k == 1 {
171+
return float64(s[n]-s[i]) / float64(n-i)
172+
}
173+
if f[i][k] >= 0 {
174+
return f[i][k]
175+
}
176+
var ans float64
177+
for j := i; j < n; j++ {
178+
t := float64(s[j+1]-s[i])/float64(j-i+1) + dfs(j+1, k-1)
179+
ans = math.Max(ans, t)
180+
}
181+
f[i][k] = ans
182+
return ans
183+
}
184+
return dfs(0, k)
185+
}
55186
```
56187

57188
### **...**

‎solution/0800-0899/0813.Largest Sum of Averages/Solution.cpp

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
class Solution {
2+
public:
3+
double f[110][110];
4+
int s[110];
5+
int n;
6+
7+
double largestSumOfAverages(vector<int>& nums, int k) {
8+
n = nums.size();
9+
s[0] = 0;
10+
for (int i = 0; i < n; ++i) {
11+
s[i + 1] = s[i] + nums[i];
12+
}
13+
memset(f, -1, sizeof f);
14+
return dfs(0, k);
15+
}
16+
17+
double dfs(int i, int k) {
18+
if (i == n) {
19+
return 0;
20+
}
21+
if (k == 1) {
22+
return (s[n] - s[i]) * 1.0 / (n - i);
23+
}
24+
if (f[i][k] >= 0) {
25+
return f[i][k];
26+
}
27+
double ans = 0;
28+
for (int j = i; j < n; ++j) {
29+
double t = (s[j + 1] - s[i]) * 1.0 / (j - i + 1) + dfs(j + 1, k - 1);
30+
ans = max(ans, t);
31+
}
32+
f[i][k] = ans;
33+
return ans;
34+
}
35+
};

‎solution/0800-0899/0813.Largest Sum of Averages/Solution.go

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
func largestSumOfAverages(nums []int, k int) float64 {
2+
n := len(nums)
3+
s := make([]int, n+1)
4+
f := make([][]float64, n+1)
5+
for i := range f {
6+
f[i] = make([]float64, k+1)
7+
for j := range f[i] {
8+
f[i][j] = -1
9+
}
10+
}
11+
for i, v := range nums {
12+
s[i+1] = s[i] + v
13+
}
14+
var dfs func(i, k int) float64
15+
dfs = func(i, k int) float64 {
16+
if i == n {
17+
return 0
18+
}
19+
if k == 1 {
20+
return float64(s[n]-s[i]) / float64(n-i)
21+
}
22+
if f[i][k] >= 0 {
23+
return f[i][k]
24+
}
25+
var ans float64
26+
for j := i; j < n; j++ {
27+
t := float64(s[j+1]-s[i])/float64(j-i+1) + dfs(j+1, k-1)
28+
ans = math.Max(ans, t)
29+
}
30+
f[i][k] = ans
31+
return ans
32+
}
33+
return dfs(0, k)
34+
}

0 commit comments

Comments
 (0)