Skip to content

Commit 0c7d3e6

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1120
No.1120.Maximum Average Subtree
1 parent 3c2ebb8 commit 0c7d3e6

File tree

6 files changed

+99
-94
lines changed

6 files changed

+99
-94
lines changed

Diff for: ‎solution/1100-1199/1120.Maximum Average Subtree/README.md

+43-32
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,21 @@
4141

4242
<!-- 这里可写通用的实现逻辑 -->
4343

44-
后序遍历获取每个子树的结点个数以及结点和，求每个结点平均值的最大值。
44+
**方法一：递归**
45+
46+
我们可以使用递归的方法，对于每个节点，计算以该节点为根的子树的节点和以及节点个数，然后计算平均值，与当前最大值比较，更新最大值。
47+
48+
因此，我们设计一个函数 $dfs(root)$，表示以 $root$ 为根的子树的节点和以及节点个数，返回值为一个长度为 $2$ 的数组，其中第一个元素表示节点和，第二个元素表示节点个数。
49+
50+
函数 $dfs(root)$ 的递归过程如下：
51+
52+
- 如果 $root$ 为空，返回 $[0, 0]$；
53+
- 否则，计算 $root$ 的左子树的节点和以及节点个数，记为 $[ls, ln]$；计算 $root$ 的右子树的节点和以及节点个数，记为 $[rs, rn]$。那么以 $root$ 为根的子树的节点和为 $root.val + ls + rs$，节点个数为 $1 + ln + rn$，计算平均值，与当前最大值比较，更新最大值；
54+
- 返回 $[root.val + ls + rs, 1 + ln + rn]$。
55+
56+
最后，返回最大值即可。
57+
58+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点个数。
4559

4660
<!-- tabs:start -->
4761

@@ -57,14 +71,14 @@
5771
# self.left = left
5872
# self.right = right
5973
class Solution:
60-
def maximumAverageSubtree(self, root: TreeNode) -> float:
74+
def maximumAverageSubtree(self, root: Optional[TreeNode]) -> float:
6175
def dfs(root):
6276
if root is None:
6377
return 0, 0
6478
ls, ln = dfs(root.left)
6579
rs, rn = dfs(root.right)
66-
s = ls + root.val + rs
67-
n = ln + 1 + rn
80+
s = root.val + ls + rs
81+
n = 1 + ln + rn
6882
nonlocal ans
6983
ans = max(ans, s / n)
7084
return s, n
@@ -98,19 +112,18 @@ class Solution {
98112
private double ans;
99113

100114
public double maximumAverageSubtree(TreeNode root) {
101-
ans = 0;
102115
dfs(root);
103116
return ans;
104117
}
105118

106119
private int[] dfs(TreeNode root) {
107120
if (root == null) {
108-
return new int[] {0, 0};
121+
return new int[2];
109122
}
110-
int[] l = dfs(root.left);
111-
int[] r = dfs(root.right);
112-
int s = l[0] + root.val + r[0];
113-
int n = l[1] + 1 + r[1];
123+
var l = dfs(root.left);
124+
var r = dfs(root.right);
125+
int s = root.val + l[0] + r[0];
126+
int n = 1 + l[1] + r[1];
114127
ans = Math.max(ans, s * 1.0 / n);
115128
return new int[] {s, n};
116129
}
@@ -133,23 +146,22 @@ class Solution {
133146
*/
134147
class Solution {
135148
public:
136-
double ans;
137-
138149
double maximumAverageSubtree(TreeNode* root) {
139-
ans = 0;
150+
double ans = 0;
151+
function<pair<int, int>(TreeNode*)> dfs = [&](TreeNode* root) -> pair<int, int> {
152+
if (!root) {
153+
return {0, 0};
154+
}
155+
auto [ls, ln] = dfs(root->left);
156+
auto [rs, rn] = dfs(root->right);
157+
int s = root->val + ls + rs;
158+
int n = 1 + ln + rn;
159+
ans = max(ans, s * 1.0 / n);
160+
return {s, n};
161+
};
140162
dfs(root);
141163
return ans;
142164
}
143-
144-
pair<int, int> dfs(TreeNode* root) {
145-
if (!root) return {0, 0};
146-
auto l = dfs(root->left);
147-
auto r = dfs(root->right);
148-
int s = l.first + root->val + r.first;
149-
int n = l.second + 1 + r.second;
150-
ans = max(ans, s * 1.0 / n);
151-
return {s, n};
152-
}
153165
};
154166
```
155167
@@ -164,21 +176,20 @@ public:
164176
* Right *TreeNode
165177
* }
166178
*/
167-
func maximumAverageSubtree(root *TreeNode) float64 {
168-
var ans float64
169-
var dfs func(root *TreeNode) []int
170-
dfs = func(root *TreeNode) []int {
179+
func maximumAverageSubtree(root *TreeNode) (ans float64) {
180+
var dfs func(*TreeNode) [2]int
181+
dfs = func(root *TreeNode) [2]int {
171182
if root == nil {
172-
return []int{0, 0}
183+
return [2]int{}
173184
}
174185
l, r := dfs(root.Left), dfs(root.Right)
175-
s := l[0] + root.Val + r[0]
176-
n := l[1] + 1 + r[1]
186+
s := root.Val + l[0] + r[0]
187+
n := 1 + l[1] + r[1]
177188
ans = math.Max(ans, float64(s)/float64(n))
178-
return []int{s, n}
189+
return [2]int{s, n}
179190
}
180191
dfs(root)
181-
return ans
192+
return
182193
}
183194
```
184195

Diff for: ‎solution/1100-1199/1120.Maximum Average Subtree/README_EN.md

+28-31
Original file line numberDiff line numberDiff line change
@@ -52,14 +52,14 @@ So the answer is 6 which is the maximum.
5252
# self.left = left
5353
# self.right = right
5454
class Solution:
55-
def maximumAverageSubtree(self, root: TreeNode) -> float:
55+
def maximumAverageSubtree(self, root: Optional[TreeNode]) -> float:
5656
def dfs(root):
5757
if root is None:
5858
return 0, 0
5959
ls, ln = dfs(root.left)
6060
rs, rn = dfs(root.right)
61-
s = ls + root.val + rs
62-
n = ln + 1 + rn
61+
s = root.val + ls + rs
62+
n = 1 + ln + rn
6363
nonlocal ans
6464
ans = max(ans, s / n)
6565
return s, n
@@ -91,19 +91,18 @@ class Solution {
9191
private double ans;
9292

9393
public double maximumAverageSubtree(TreeNode root) {
94-
ans = 0;
9594
dfs(root);
9695
return ans;
9796
}
9897

9998
private int[] dfs(TreeNode root) {
10099
if (root == null) {
101-
return new int[] {0, 0};
100+
return new int[2];
102101
}
103-
int[] l = dfs(root.left);
104-
int[] r = dfs(root.right);
105-
int s = l[0] + root.val + r[0];
106-
int n = l[1] + 1 + r[1];
102+
var l = dfs(root.left);
103+
var r = dfs(root.right);
104+
int s = root.val + l[0] + r[0];
105+
int n = 1 + l[1] + r[1];
107106
ans = Math.max(ans, s * 1.0 / n);
108107
return new int[] {s, n};
109108
}
@@ -126,23 +125,22 @@ class Solution {
126125
*/
127126
class Solution {
128127
public:
129-
double ans;
130-
131128
double maximumAverageSubtree(TreeNode* root) {
132-
ans = 0;
129+
double ans = 0;
130+
function<pair<int, int>(TreeNode*)> dfs = [&](TreeNode* root) -> pair<int, int> {
131+
if (!root) {
132+
return {0, 0};
133+
}
134+
auto [ls, ln] = dfs(root->left);
135+
auto [rs, rn] = dfs(root->right);
136+
int s = root->val + ls + rs;
137+
int n = 1 + ln + rn;
138+
ans = max(ans, s * 1.0 / n);
139+
return {s, n};
140+
};
133141
dfs(root);
134142
return ans;
135143
}
136-
137-
pair<int, int> dfs(TreeNode* root) {
138-
if (!root) return {0, 0};
139-
auto l = dfs(root->left);
140-
auto r = dfs(root->right);
141-
int s = l.first + root->val + r.first;
142-
int n = l.second + 1 + r.second;
143-
ans = max(ans, s * 1.0 / n);
144-
return {s, n};
145-
}
146144
};
147145
```
148146
@@ -157,21 +155,20 @@ public:
157155
* Right *TreeNode
158156
* }
159157
*/
160-
func maximumAverageSubtree(root *TreeNode) float64 {
161-
var ans float64
162-
var dfs func(root *TreeNode) []int
163-
dfs = func(root *TreeNode) []int {
158+
func maximumAverageSubtree(root *TreeNode) (ans float64) {
159+
var dfs func(*TreeNode) [2]int
160+
dfs = func(root *TreeNode) [2]int {
164161
if root == nil {
165-
return []int{0, 0}
162+
return [2]int{}
166163
}
167164
l, r := dfs(root.Left), dfs(root.Right)
168-
s := l[0] + root.Val + r[0]
169-
n := l[1] + 1 + r[1]
165+
s := root.Val + l[0] + r[0]
166+
n := 1 + l[1] + r[1]
170167
ans = math.Max(ans, float64(s)/float64(n))
171-
return []int{s, n}
168+
return [2]int{s, n}
172169
}
173170
dfs(root)
174-
return ans
171+
return
175172
}
176173
```
177174

Diff for: ‎solution/1100-1199/1120.Maximum Average Subtree/Solution.cpp

+12-13
Original file line numberDiff line numberDiff line change
@@ -11,21 +11,20 @@
1111
*/
1212
class Solution {
1313
public:
14-
double ans;
15-
1614
double maximumAverageSubtree(TreeNode* root) {
17-
ans = 0;
15+
double ans = 0;
16+
function<pair<int, int>(TreeNode*)> dfs = [&](TreeNode* root) -> pair<int, int> {
17+
if (!root) {
18+
return {0, 0};
19+
}
20+
auto [ls, ln] = dfs(root->left);
21+
auto [rs, rn] = dfs(root->right);
22+
int s = root->val + ls + rs;
23+
int n = 1 + ln + rn;
24+
ans = max(ans, s * 1.0 / n);
25+
return {s, n};
26+
};
1827
dfs(root);
1928
return ans;
2029
}
21-
22-
pair<int, int> dfs(TreeNode* root) {
23-
if (!root) return {0, 0};
24-
auto l = dfs(root->left);
25-
auto r = dfs(root->right);
26-
int s = l.first + root->val + r.first;
27-
int n = l.second + 1 + r.second;
28-
ans = max(ans, s * 1.0 / n);
29-
return {s, n};
30-
}
3130
};

Diff for: ‎solution/1100-1199/1120.Maximum Average Subtree/Solution.go

+8-9
Original file line numberDiff line numberDiff line change
@@ -6,19 +6,18 @@
66
* Right *TreeNode
77
* }
88
*/
9-
func maximumAverageSubtree(root *TreeNode) float64 {
10-
var ans float64
11-
var dfs func(root *TreeNode) []int
12-
dfs = func(root *TreeNode) []int {
9+
func maximumAverageSubtree(root *TreeNode) (ans float64) {
10+
var dfs func(*TreeNode) [2]int
11+
dfs = func(root *TreeNode) [2]int {
1312
if root == nil {
14-
return []int{0, 0}
13+
return [2]int{}
1514
}
1615
l, r := dfs(root.Left), dfs(root.Right)
17-
s := l[0] + root.Val + r[0]
18-
n := l[1] + 1 + r[1]
16+
s := root.Val + l[0] + r[0]
17+
n := 1 + l[1] + r[1]
1918
ans = math.Max(ans, float64(s)/float64(n))
20-
return []int{s, n}
19+
return [2]int{s, n}
2120
}
2221
dfs(root)
23-
return ans
22+
return
2423
}

Diff for: ‎solution/1100-1199/1120.Maximum Average Subtree/Solution.java

+5-6
Original file line numberDiff line numberDiff line change
@@ -17,19 +17,18 @@ class Solution {
1717
private double ans;
1818

1919
public double maximumAverageSubtree(TreeNode root) {
20-
ans = 0;
2120
dfs(root);
2221
return ans;
2322
}
2423

2524
private int[] dfs(TreeNode root) {
2625
if (root == null) {
27-
return new int[] {0, 0};
26+
return new int[2];
2827
}
29-
int[] l = dfs(root.left);
30-
int[] r = dfs(root.right);
31-
int s = l[0] + root.val + r[0];
32-
int n = l[1] + 1 + r[1];
28+
var l = dfs(root.left);
29+
var r = dfs(root.right);
30+
int s = root.val + l[0] + r[0];
31+
int n = 1 + l[1] + r[1];
3332
ans = Math.max(ans, s * 1.0 / n);
3433
return new int[] {s, n};
3534
}

Diff for: ‎solution/1100-1199/1120.Maximum Average Subtree/Solution.py

+3-3
Original file line numberDiff line numberDiff line change
@@ -5,14 +5,14 @@
55
# self.left = left
66
# self.right = right
77
class Solution:
8-
def maximumAverageSubtree(self, root: TreeNode) -> float:
8+
def maximumAverageSubtree(self, root: Optional[TreeNode]) -> float:
99
def dfs(root):
1010
if root is None:
1111
return 0, 0
1212
ls, ln = dfs(root.left)
1313
rs, rn = dfs(root.right)
14-
s = ls + root.val + rs
15-
n = ln + 1 + rn
14+
s = root.val + ls + rs
15+
n = 1 + ln + rn
1616
nonlocal ans
1717
ans = max(ans, s / n)
1818
return s, n

0 commit comments

Comments
 (0)