Skip to content

Commit ddb655f

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0663
No.0663.Equal Tree Partition
1 parent a55e8be commit ddb655f

File tree

6 files changed

+389
-2
lines changed

6 files changed

+389
-2
lines changed

‎solution/0600-0699/0663.Equal Tree Partition/README.md

+134-1
Original file line numberDiff line numberDiff line change
@@ -62,22 +62,155 @@
6262

6363
<!-- 这里可写通用的实现逻辑 -->
6464

65+
后序遍历，记录每个子树的和。
66+
6567
<!-- tabs:start -->
6668

6769
### **Python3**
6870

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

7173
```python
72-
74+
# Definition for a binary tree node.
75+
# class TreeNode:
76+
# def __init__(self, val=0, left=None, right=None):
77+
# self.val = val
78+
# self.left = left
79+
# self.right = right
80+
class Solution:
81+
def checkEqualTree(self, root: TreeNode) -> bool:
82+
def sum(root):
83+
if root is None:
84+
return 0
85+
l, r = sum(root.left), sum(root.right)
86+
seen.append(l + r + root.val)
87+
return seen[-1]
88+
89+
seen = []
90+
s = sum(root)
91+
if s % 2 == 1:
92+
return False
93+
seen.pop()
94+
return s // 2 in seen
7395
```
7496

7597
### **Java**
7698

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

79101
```java
102+
/**
103+
* Definition for a binary tree node.
104+
* public class TreeNode {
105+
* int val;
106+
* TreeNode left;
107+
* TreeNode right;
108+
* TreeNode() {}
109+
* TreeNode(int val) { this.val = val; }
110+
* TreeNode(int val, TreeNode left, TreeNode right) {
111+
* this.val = val;
112+
* this.left = left;
113+
* this.right = right;
114+
* }
115+
* }
116+
*/
117+
class Solution {
118+
private List<Integer> seen;
119+
120+
public boolean checkEqualTree(TreeNode root) {
121+
seen = new ArrayList<>();
122+
int s = sum(root);
123+
if (s % 2 != 0) {
124+
return false;
125+
}
126+
seen.remove(seen.size() - 1);
127+
return seen.contains(s / 2);
128+
}
129+
130+
private int sum(TreeNode root) {
131+
if (root == null) {
132+
return 0;
133+
}
134+
int l = sum(root.left);
135+
int r = sum(root.right);
136+
int s = l + r + root.val;
137+
seen.add(s);
138+
return s;
139+
}
140+
}
141+
```
142+
143+
### **C++**
144+
145+
```cpp
146+
/**
147+
* Definition for a binary tree node.
148+
* struct TreeNode {
149+
* int val;
150+
* TreeNode *left;
151+
* TreeNode *right;
152+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
153+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
154+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
155+
* };
156+
*/
157+
class Solution {
158+
public:
159+
vector<int> seen;
160+
161+
bool checkEqualTree(TreeNode* root) {
162+
int s = sum(root);
163+
if (s % 2 != 0) return false;
164+
seen.pop_back();
165+
return count(seen.begin(), seen.end(), s / 2);
166+
}
167+
168+
int sum(TreeNode* root) {
169+
if (!root) return 0;
170+
int l = sum(root->left), r = sum(root->right);
171+
int s = l + r + root->val;
172+
seen.push_back(s);
173+
return s;
174+
}
175+
};
176+
```
80177
178+
### **Go**
179+
180+
```go
181+
/**
182+
* Definition for a binary tree node.
183+
* type TreeNode struct {
184+
* Val int
185+
* Left *TreeNode
186+
* Right *TreeNode
187+
* }
188+
*/
189+
func checkEqualTree(root *TreeNode) bool {
190+
var seen []int
191+
var sum func(root *TreeNode) int
192+
sum = func(root *TreeNode) int {
193+
if root == nil {
194+
return 0
195+
}
196+
l, r := sum(root.Left), sum(root.Right)
197+
s := l + r + root.Val
198+
seen = append(seen, s)
199+
return s
200+
}
201+
202+
s := sum(root)
203+
if s%2 != 0 {
204+
return false
205+
}
206+
seen = seen[:len(seen)-1]
207+
for _, v := range seen {
208+
if v == s/2 {
209+
return true
210+
}
211+
}
212+
return false
213+
}
81214
```
82215

83216
### **...**

‎solution/0600-0699/0663.Equal Tree Partition/README_EN.md

+132-1
Original file line numberDiff line numberDiff line change
@@ -103,13 +103,144 @@ Sum: 15
103103
### **Python3**
104104

105105
```python
106-
106+
# Definition for a binary tree node.
107+
# class TreeNode:
108+
# def __init__(self, val=0, left=None, right=None):
109+
# self.val = val
110+
# self.left = left
111+
# self.right = right
112+
class Solution:
113+
def checkEqualTree(self, root: TreeNode) -> bool:
114+
def sum(root):
115+
if root is None:
116+
return 0
117+
l, r = sum(root.left), sum(root.right)
118+
seen.append(l + r + root.val)
119+
return seen[-1]
120+
121+
seen = []
122+
s = sum(root)
123+
if s % 2 == 1:
124+
return False
125+
seen.pop()
126+
return s // 2 in seen
107127
```
108128

109129
### **Java**
110130

111131
```java
132+
/**
133+
* Definition for a binary tree node.
134+
* public class TreeNode {
135+
* int val;
136+
* TreeNode left;
137+
* TreeNode right;
138+
* TreeNode() {}
139+
* TreeNode(int val) { this.val = val; }
140+
* TreeNode(int val, TreeNode left, TreeNode right) {
141+
* this.val = val;
142+
* this.left = left;
143+
* this.right = right;
144+
* }
145+
* }
146+
*/
147+
class Solution {
148+
private List<Integer> seen;
149+
150+
public boolean checkEqualTree(TreeNode root) {
151+
seen = new ArrayList<>();
152+
int s = sum(root);
153+
if (s % 2 != 0) {
154+
return false;
155+
}
156+
seen.remove(seen.size() - 1);
157+
return seen.contains(s / 2);
158+
}
159+
160+
private int sum(TreeNode root) {
161+
if (root == null) {
162+
return 0;
163+
}
164+
int l = sum(root.left);
165+
int r = sum(root.right);
166+
int s = l + r + root.val;
167+
seen.add(s);
168+
return s;
169+
}
170+
}
171+
```
172+
173+
### **C++**
174+
175+
```cpp
176+
/**
177+
* Definition for a binary tree node.
178+
* struct TreeNode {
179+
* int val;
180+
* TreeNode *left;
181+
* TreeNode *right;
182+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
183+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
184+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
185+
* };
186+
*/
187+
class Solution {
188+
public:
189+
vector<int> seen;
190+
191+
bool checkEqualTree(TreeNode* root) {
192+
int s = sum(root);
193+
if (s % 2 != 0) return false;
194+
seen.pop_back();
195+
return count(seen.begin(), seen.end(), s / 2);
196+
}
197+
198+
int sum(TreeNode* root) {
199+
if (!root) return 0;
200+
int l = sum(root->left), r = sum(root->right);
201+
int s = l + r + root->val;
202+
seen.push_back(s);
203+
return s;
204+
}
205+
};
206+
```
112207
208+
### **Go**
209+
210+
```go
211+
/**
212+
* Definition for a binary tree node.
213+
* type TreeNode struct {
214+
* Val int
215+
* Left *TreeNode
216+
* Right *TreeNode
217+
* }
218+
*/
219+
func checkEqualTree(root *TreeNode) bool {
220+
var seen []int
221+
var sum func(root *TreeNode) int
222+
sum = func(root *TreeNode) int {
223+
if root == nil {
224+
return 0
225+
}
226+
l, r := sum(root.Left), sum(root.Right)
227+
s := l + r + root.Val
228+
seen = append(seen, s)
229+
return s
230+
}
231+
232+
s := sum(root)
233+
if s%2 != 0 {
234+
return false
235+
}
236+
seen = seen[:len(seen)-1]
237+
for _, v := range seen {
238+
if v == s/2 {
239+
return true
240+
}
241+
}
242+
return false
243+
}
113244
```
114245

115246
### **...**

‎solution/0600-0699/0663.Equal Tree Partition/Solution.cpp

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
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+
vector<int> seen;
15+
16+
bool checkEqualTree(TreeNode* root) {
17+
int s = sum(root);
18+
if (s % 2 != 0) return false;
19+
seen.pop_back();
20+
return count(seen.begin(), seen.end(), s / 2);
21+
}
22+
23+
int sum(TreeNode* root) {
24+
if (!root) return 0;
25+
int l = sum(root->left), r = sum(root->right);
26+
int s = l + r + root->val;
27+
seen.push_back(s);
28+
return s;
29+
}
30+
};

‎solution/0600-0699/0663.Equal Tree Partition/Solution.go

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
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 checkEqualTree(root *TreeNode) bool {
10+
var seen []int
11+
var sum func(root *TreeNode) int
12+
sum = func(root *TreeNode) int {
13+
if root == nil {
14+
return 0
15+
}
16+
l, r := sum(root.Left), sum(root.Right)
17+
s := l + r + root.Val
18+
seen = append(seen, s)
19+
return s
20+
}
21+
22+
s := sum(root)
23+
if s%2 != 0 {
24+
return false
25+
}
26+
seen = seen[:len(seen)-1]
27+
for _, v := range seen {
28+
if v == s/2 {
29+
return true
30+
}
31+
}
32+
return false
33+
}

0 commit comments

Comments
 (0)