Skip to content

Commit 41a2a00

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1120
No.1120.Maximum Average Subtree
1 parent ba60030 commit 41a2a00

File tree

6 files changed

+359
-2
lines changed

6 files changed

+359
-2
lines changed

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

Lines changed: 124 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -41,22 +41,145 @@
4141

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

44+
后序遍历获取每个子树的结点个数以及结点和，求每个结点平均值的最大值。
45+
4446
<!-- tabs:start -->
4547

4648
### **Python3**
4749

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

5052
```python
51-
53+
# Definition for a binary tree node.
54+
# class TreeNode:
55+
# def __init__(self, val=0, left=None, right=None):
56+
# self.val = val
57+
# self.left = left
58+
# self.right = right
59+
class Solution:
60+
def maximumAverageSubtree(self, root: TreeNode) -> float:
61+
def dfs(root):
62+
if root is None:
63+
return 0, 0
64+
ls, ln = dfs(root.left)
65+
rs, rn = dfs(root.right)
66+
s = ls + root.val + rs
67+
n = ln + 1 + rn
68+
nonlocal ans
69+
ans = max(ans, s / n)
70+
return s, n
71+
72+
ans = 0
73+
dfs(root)
74+
return ans
5275
```
5376

5477
### **Java**
5578

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

5881
```java
82+
/**
83+
* Definition for a binary tree node.
84+
* public class TreeNode {
85+
* int val;
86+
* TreeNode left;
87+
* TreeNode right;
88+
* TreeNode() {}
89+
* TreeNode(int val) { this.val = val; }
90+
* TreeNode(int val, TreeNode left, TreeNode right) {
91+
* this.val = val;
92+
* this.left = left;
93+
* this.right = right;
94+
* }
95+
* }
96+
*/
97+
class Solution {
98+
private double ans;
99+
100+
public double maximumAverageSubtree(TreeNode root) {
101+
ans = 0;
102+
dfs(root);
103+
return ans;
104+
}
105+
106+
private int[] dfs(TreeNode root) {
107+
if (root == null) {
108+
return new int[]{0, 0};
109+
}
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];
114+
ans = Math.max(ans, s * 1.0 / n);
115+
return new int[]{s, n};
116+
}
117+
}
118+
```
119+
120+
### **C++**
121+
122+
```cpp
123+
/**
124+
* Definition for a binary tree node.
125+
* struct TreeNode {
126+
* int val;
127+
* TreeNode *left;
128+
* TreeNode *right;
129+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
130+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
131+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
132+
* };
133+
*/
134+
class Solution {
135+
public:
136+
double ans;
137+
138+
double maximumAverageSubtree(TreeNode* root) {
139+
ans = 0;
140+
dfs(root);
141+
return ans;
142+
}
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+
}
153+
};
154+
```
59155
156+
### **Go**
157+
158+
```go
159+
/**
160+
* Definition for a binary tree node.
161+
* type TreeNode struct {
162+
* Val int
163+
* Left *TreeNode
164+
* Right *TreeNode
165+
* }
166+
*/
167+
func maximumAverageSubtree(root *TreeNode) float64 {
168+
var ans float64
169+
var dfs func(root *TreeNode) []int
170+
dfs = func(root *TreeNode) []int {
171+
if root == nil {
172+
return []int{0, 0}
173+
}
174+
l, r := dfs(root.Left), dfs(root.Right)
175+
s := l[0] + root.Val + r[0]
176+
n := l[1] + 1 + r[1]
177+
ans = math.Max(ans, float64(s)/float64(n))
178+
return []int{s, n}
179+
}
180+
dfs(root)
181+
return ans
182+
}
60183
```
61184

62185
### **...**

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

Lines changed: 122 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -41,13 +41,134 @@ So the answer is 6 which is the maximum.
4141
### **Python3**
4242

4343
```python
44-
44+
# Definition for a binary tree node.
45+
# class TreeNode:
46+
# def __init__(self, val=0, left=None, right=None):
47+
# self.val = val
48+
# self.left = left
49+
# self.right = right
50+
class Solution:
51+
def maximumAverageSubtree(self, root: TreeNode) -> float:
52+
def dfs(root):
53+
if root is None:
54+
return 0, 0
55+
ls, ln = dfs(root.left)
56+
rs, rn = dfs(root.right)
57+
s = ls + root.val + rs
58+
n = ln + 1 + rn
59+
nonlocal ans
60+
ans = max(ans, s / n)
61+
return s, n
62+
63+
ans = 0
64+
dfs(root)
65+
return ans
4566
```
4667

4768
### **Java**
4869

4970
```java
71+
/**
72+
* Definition for a binary tree node.
73+
* public class TreeNode {
74+
* int val;
75+
* TreeNode left;
76+
* TreeNode right;
77+
* TreeNode() {}
78+
* TreeNode(int val) { this.val = val; }
79+
* TreeNode(int val, TreeNode left, TreeNode right) {
80+
* this.val = val;
81+
* this.left = left;
82+
* this.right = right;
83+
* }
84+
* }
85+
*/
86+
class Solution {
87+
private double ans;
88+
89+
public double maximumAverageSubtree(TreeNode root) {
90+
ans = 0;
91+
dfs(root);
92+
return ans;
93+
}
94+
95+
private int[] dfs(TreeNode root) {
96+
if (root == null) {
97+
return new int[]{0, 0};
98+
}
99+
int[] l = dfs(root.left);
100+
int[] r = dfs(root.right);
101+
int s = l[0] + root.val + r[0];
102+
int n = l[1] + 1 + r[1];
103+
ans = Math.max(ans, s * 1.0 / n);
104+
return new int[]{s, n};
105+
}
106+
}
107+
```
108+
109+
### **C++**
110+
111+
```cpp
112+
/**
113+
* Definition for a binary tree node.
114+
* struct TreeNode {
115+
* int val;
116+
* TreeNode *left;
117+
* TreeNode *right;
118+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
119+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
120+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
121+
* };
122+
*/
123+
class Solution {
124+
public:
125+
double ans;
126+
127+
double maximumAverageSubtree(TreeNode* root) {
128+
ans = 0;
129+
dfs(root);
130+
return ans;
131+
}
132+
133+
pair<int, int> dfs(TreeNode* root) {
134+
if (!root) return {0, 0};
135+
auto l = dfs(root->left);
136+
auto r = dfs(root->right);
137+
int s = l.first + root->val + r.first;
138+
int n = l.second + 1 + r.second;
139+
ans = max(ans, s * 1.0 / n);
140+
return {s, n};
141+
}
142+
};
143+
```
50144
145+
### **Go**
146+
147+
```go
148+
/**
149+
* Definition for a binary tree node.
150+
* type TreeNode struct {
151+
* Val int
152+
* Left *TreeNode
153+
* Right *TreeNode
154+
* }
155+
*/
156+
func maximumAverageSubtree(root *TreeNode) float64 {
157+
var ans float64
158+
var dfs func(root *TreeNode) []int
159+
dfs = func(root *TreeNode) []int {
160+
if root == nil {
161+
return []int{0, 0}
162+
}
163+
l, r := dfs(root.Left), dfs(root.Right)
164+
s := l[0] + root.Val + r[0]
165+
n := l[1] + 1 + r[1]
166+
ans = math.Max(ans, float64(s)/float64(n))
167+
return []int{s, n}
168+
}
169+
dfs(root)
170+
return ans
171+
}
51172
```
52173

53174
### **...**

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

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
double ans;
15+
16+
double maximumAverageSubtree(TreeNode* root) {
17+
ans = 0;
18+
dfs(root);
19+
return ans;
20+
}
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+
}
31+
};

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

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func maximumAverageSubtree(root *TreeNode) float64 {
10+
var ans float64
11+
var dfs func(root *TreeNode) []int
12+
dfs = func(root *TreeNode) []int {
13+
if root == nil {
14+
return []int{0, 0}
15+
}
16+
l, r := dfs(root.Left), dfs(root.Right)
17+
s := l[0] + root.Val + r[0]
18+
n := l[1] + 1 + r[1]
19+
ans = math.Max(ans, float64(s)/float64(n))
20+
return []int{s, n}
21+
}
22+
dfs(root)
23+
return ans
24+
}

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

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* public class TreeNode {
4+
* int val;
5+
* TreeNode left;
6+
* TreeNode right;
7+
* TreeNode() {}
8+
* TreeNode(int val) { this.val = val; }
9+
* TreeNode(int val, TreeNode left, TreeNode right) {
10+
* this.val = val;
11+
* this.left = left;
12+
* this.right = right;
13+
* }
14+
* }
15+
*/
16+
class Solution {
17+
private double ans;
18+
19+
public double maximumAverageSubtree(TreeNode root) {
20+
ans = 0;
21+
dfs(root);
22+
return ans;
23+
}
24+
25+
private int[] dfs(TreeNode root) {
26+
if (root == null) {
27+
return new int[]{0, 0};
28+
}
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];
33+
ans = Math.max(ans, s * 1.0 / n);
34+
return new int[]{s, n};
35+
}
36+
}

0 commit comments

Comments
 (0)