Skip to content

Commit b1247a1

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0508
No.0508.Most Frequent Subtree Sum
1 parent 0f28571 commit b1247a1

File tree

11 files changed

+401
-33
lines changed

11 files changed

+401
-33
lines changed

‎lcof2/剑指 Offer II 044. 二叉树每层的最大值/README.md

+1-2
Original file line numberDiff line numberDiff line change
@@ -174,9 +174,8 @@ class Solution {
174174
public:
175175
vector<int> largestValues(TreeNode* root) {
176176
if (!root) return {};
177-
queue<TreeNode*> q;
177+
queue<TreeNode*> q{{root}};
178178
vector<int> ans;
179-
q.push(root);
180179
while (!q.empty())
181180
{
182181
int t = INT_MIN;

‎lcof2/剑指 Offer II 044. 二叉树每层的最大值/Solution.cpp

+1-2
Original file line numberDiff line numberDiff line change
@@ -13,9 +13,8 @@ class Solution {
1313
public:
1414
vector<int> largestValues(TreeNode* root) {
1515
if (!root) return {};
16-
queue<TreeNode*> q;
16+
queue<TreeNode*> q{{root}};
1717
vector<int> ans;
18-
q.push(root);
1918
while (!q.empty())
2019
{
2120
int t = INT_MIN;

‎solution/0500-0599/0508.Most Frequent Subtree Sum/README.md

+143-1
Original file line numberDiff line numberDiff line change
@@ -40,22 +40,164 @@
4040

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

43+
后序遍历获取每个子树元素和，同时用哈希表记录每个子树元素和出现的次数，以及最大的次数 mx。最后判断哈希表中出现次数为 mx 的，获取对应的子树元素，组成结果列表 ans。
44+
4345
<!-- tabs:start -->
4446

4547
### **Python3**
4648

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

4951
```python
50-
52+
# Definition for a binary tree node.
53+
# class TreeNode:
54+
# def __init__(self, val=0, left=None, right=None):
55+
# self.val = val
56+
# self.left = left
57+
# self.right = right
58+
class Solution:
59+
def findFrequentTreeSum(self, root: TreeNode) -> List[int]:
60+
def dfs(root):
61+
if root is None:
62+
return 0
63+
left, right = dfs(root.left), dfs(root.right)
64+
s = root.val + left + right
65+
counter[s] += 1
66+
return s
67+
68+
counter = Counter()
69+
dfs(root)
70+
mx = max(counter.values())
71+
return [k for k, v in counter.items() if v == mx]
5172
```
5273

5374
### **Java**
5475

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

5778
```java
79+
/**
80+
* Definition for a binary tree node.
81+
* public class TreeNode {
82+
* int val;
83+
* TreeNode left;
84+
* TreeNode right;
85+
* TreeNode() {}
86+
* TreeNode(int val) { this.val = val; }
87+
* TreeNode(int val, TreeNode left, TreeNode right) {
88+
* this.val = val;
89+
* this.left = left;
90+
* this.right = right;
91+
* }
92+
* }
93+
*/
94+
class Solution {
95+
private Map<Integer, Integer> counter;
96+
private int mx;
97+
98+
public int[] findFrequentTreeSum(TreeNode root) {
99+
counter = new HashMap<>();
100+
mx = Integer.MIN_VALUE;
101+
dfs(root);
102+
List<Integer> res = new ArrayList<>();
103+
for (Map.Entry<Integer, Integer> entry : counter.entrySet()) {
104+
if (entry.getValue() == mx) {
105+
res.add(entry.getKey());
106+
}
107+
}
108+
int[] ans = new int[res.size()];
109+
for (int i = 0; i < res.size(); ++i) {
110+
ans[i] = res.get(i);
111+
}
112+
return ans;
113+
}
114+
115+
private int dfs(TreeNode root) {
116+
if (root == null) {
117+
return 0;
118+
}
119+
int s = root.val + dfs(root.left) + dfs(root.right);
120+
counter.put(s, counter.getOrDefault(s, 0) + 1);
121+
mx = Math.max(mx, counter.get(s));
122+
return s;
123+
}
124+
}
125+
```
126+
127+
### **C++**
128+
129+
```cpp
130+
/**
131+
* Definition for a binary tree node.
132+
* struct TreeNode {
133+
* int val;
134+
* TreeNode *left;
135+
* TreeNode *right;
136+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
137+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
138+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
139+
* };
140+
*/
141+
class Solution {
142+
public:
143+
unordered_map<int, int> counter;
144+
int mx = 0;
145+
146+
vector<int> findFrequentTreeSum(TreeNode* root) {
147+
mx = INT_MIN;
148+
dfs(root);
149+
vector<int> ans;
150+
for (auto& entry : counter)
151+
if (entry.second == mx)
152+
ans.push_back(entry.first);
153+
return ans;
154+
}
155+
156+
int dfs(TreeNode* root) {
157+
if (!root) return 0;
158+
int s = root->val + dfs(root->left) + dfs(root->right);
159+
++counter[s];
160+
mx = max(mx, counter[s]);
161+
return s;
162+
}
163+
};
164+
```
58165
166+
### **Go**
167+
168+
```go
169+
/**
170+
* Definition for a binary tree node.
171+
* type TreeNode struct {
172+
* Val int
173+
* Left *TreeNode
174+
* Right *TreeNode
175+
* }
176+
*/
177+
func findFrequentTreeSum(root *TreeNode) []int {
178+
counter := make(map[int]int)
179+
mx := 0
180+
var dfs func(root *TreeNode) int
181+
dfs = func(root *TreeNode) int {
182+
if root == nil {
183+
return 0
184+
}
185+
s := root.Val + dfs(root.Left) + dfs(root.Right)
186+
counter[s]++
187+
if mx < counter[s] {
188+
mx = counter[s]
189+
}
190+
return s
191+
}
192+
dfs(root)
193+
var ans []int
194+
for k, v := range counter {
195+
if v == mx {
196+
ans = append(ans, k)
197+
}
198+
}
199+
return ans
200+
}
59201
```
60202

61203
### **...**

‎solution/0500-0599/0508.Most Frequent Subtree Sum/README_EN.md

+141-1
Original file line numberDiff line numberDiff line change
@@ -59,13 +59,153 @@ You may assume the sum of values in any subtree is in the range of 32-bit signed
5959
### **Python3**
6060

6161
```python
62-
62+
# Definition for a binary tree node.
63+
# class TreeNode:
64+
# def __init__(self, val=0, left=None, right=None):
65+
# self.val = val
66+
# self.left = left
67+
# self.right = right
68+
class Solution:
69+
def findFrequentTreeSum(self, root: TreeNode) -> List[int]:
70+
def dfs(root):
71+
if root is None:
72+
return 0
73+
left, right = dfs(root.left), dfs(root.right)
74+
s = root.val + left + right
75+
counter[s] += 1
76+
return s
77+
78+
counter = Counter()
79+
dfs(root)
80+
mx = max(counter.values())
81+
return [k for k, v in counter.items() if v == mx]
6382
```
6483

6584
### **Java**
6685

6786
```java
87+
/**
88+
* Definition for a binary tree node.
89+
* public class TreeNode {
90+
* int val;
91+
* TreeNode left;
92+
* TreeNode right;
93+
* TreeNode() {}
94+
* TreeNode(int val) { this.val = val; }
95+
* TreeNode(int val, TreeNode left, TreeNode right) {
96+
* this.val = val;
97+
* this.left = left;
98+
* this.right = right;
99+
* }
100+
* }
101+
*/
102+
class Solution {
103+
private Map<Integer, Integer> counter;
104+
private int mx;
105+
106+
public int[] findFrequentTreeSum(TreeNode root) {
107+
counter = new HashMap<>();
108+
mx = Integer.MIN_VALUE;
109+
dfs(root);
110+
List<Integer> res = new ArrayList<>();
111+
for (Map.Entry<Integer, Integer> entry : counter.entrySet()) {
112+
if (entry.getValue() == mx) {
113+
res.add(entry.getKey());
114+
}
115+
}
116+
int[] ans = new int[res.size()];
117+
for (int i = 0; i < res.size(); ++i) {
118+
ans[i] = res.get(i);
119+
}
120+
return ans;
121+
}
122+
123+
private int dfs(TreeNode root) {
124+
if (root == null) {
125+
return 0;
126+
}
127+
int s = root.val + dfs(root.left) + dfs(root.right);
128+
counter.put(s, counter.getOrDefault(s, 0) + 1);
129+
mx = Math.max(mx, counter.get(s));
130+
return s;
131+
}
132+
}
133+
```
134+
135+
### **C++**
136+
137+
```cpp
138+
/**
139+
* Definition for a binary tree node.
140+
* struct TreeNode {
141+
* int val;
142+
* TreeNode *left;
143+
* TreeNode *right;
144+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
145+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
146+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
147+
* };
148+
*/
149+
class Solution {
150+
public:
151+
unordered_map<int, int> counter;
152+
int mx = 0;
153+
154+
vector<int> findFrequentTreeSum(TreeNode* root) {
155+
mx = INT_MIN;
156+
dfs(root);
157+
vector<int> ans;
158+
for (auto& entry : counter)
159+
if (entry.second == mx)
160+
ans.push_back(entry.first);
161+
return ans;
162+
}
163+
164+
int dfs(TreeNode* root) {
165+
if (!root) return 0;
166+
int s = root->val + dfs(root->left) + dfs(root->right);
167+
++counter[s];
168+
mx = max(mx, counter[s]);
169+
return s;
170+
}
171+
};
172+
```
68173
174+
### **Go**
175+
176+
```go
177+
/**
178+
* Definition for a binary tree node.
179+
* type TreeNode struct {
180+
* Val int
181+
* Left *TreeNode
182+
* Right *TreeNode
183+
* }
184+
*/
185+
func findFrequentTreeSum(root *TreeNode) []int {
186+
counter := make(map[int]int)
187+
mx := 0
188+
var dfs func(root *TreeNode) int
189+
dfs = func(root *TreeNode) int {
190+
if root == nil {
191+
return 0
192+
}
193+
s := root.Val + dfs(root.Left) + dfs(root.Right)
194+
counter[s]++
195+
if mx < counter[s] {
196+
mx = counter[s]
197+
}
198+
return s
199+
}
200+
dfs(root)
201+
var ans []int
202+
for k, v := range counter {
203+
if v == mx {
204+
ans = append(ans, k)
205+
}
206+
}
207+
return ans
208+
}
69209
```
70210

71211
### **...**

‎solution/0500-0599/0508.Most Frequent Subtree Sum/Solution.cpp

+34
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
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+
unordered_map<int, int> counter;
15+
int mx = 0;
16+
17+
vector<int> findFrequentTreeSum(TreeNode* root) {
18+
mx = INT_MIN;
19+
dfs(root);
20+
vector<int> ans;
21+
for (auto& entry : counter)
22+
if (entry.second == mx)
23+
ans.push_back(entry.first);
24+
return ans;
25+
}
26+
27+
int dfs(TreeNode* root) {
28+
if (!root) return 0;
29+
int s = root->val + dfs(root->left) + dfs(root->right);
30+
++counter[s];
31+
mx = max(mx, counter[s]);
32+
return s;
33+
}
34+
};

0 commit comments

Comments
 (0)