Skip to content

Commit 3d8f0f9

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0951
No.0951.Flip Equivalent Binary Trees
1 parent b1247a1 commit 3d8f0f9

File tree

6 files changed

+292
-2
lines changed

6 files changed

+292
-2
lines changed

‎solution/0900-0999/0951.Flip Equivalent Binary Trees/README.md

Lines changed: 101 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,8 @@
3535

3636
## 解法
3737

38+
DFS。
39+
3840
<!-- 这里可写通用的实现逻辑 -->
3941

4042
<!-- tabs:start -->
@@ -44,15 +46,113 @@
4446
<!-- 这里可写当前语言的特殊实现逻辑 -->
4547

4648
```python
47-
49+
# Definition for a binary tree node.
50+
# class TreeNode:
51+
# def __init__(self, val=0, left=None, right=None):
52+
# self.val = val
53+
# self.left = left
54+
# self.right = right
55+
class Solution:
56+
def flipEquiv(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool:
57+
def dfs(root1, root2):
58+
if root1 == root2 or (root1 is None and root2 is None):
59+
return True
60+
if root1 is None or root2 is None or root1.val != root2.val:
61+
return False
62+
return (dfs(root1.left, root2.left) and dfs(root1.right, root2.right)) or (dfs(root1.left, root2.right) and dfs(root1.right, root2.left))
63+
64+
return dfs(root1, root2)
4865
```
4966

5067
### **Java**
5168

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

5471
```java
72+
/**
73+
* Definition for a binary tree node.
74+
* public class TreeNode {
75+
* int val;
76+
* TreeNode left;
77+
* TreeNode right;
78+
* TreeNode() {}
79+
* TreeNode(int val) { this.val = val; }
80+
* TreeNode(int val, TreeNode left, TreeNode right) {
81+
* this.val = val;
82+
* this.left = left;
83+
* this.right = right;
84+
* }
85+
* }
86+
*/
87+
class Solution {
88+
public boolean flipEquiv(TreeNode root1, TreeNode root2) {
89+
return dfs(root1, root2);
90+
}
91+
92+
private boolean dfs(TreeNode root1, TreeNode root2) {
93+
if (root1 == root2 || (root1 == null && root2 == null)) {
94+
return true;
95+
}
96+
if (root1 == null || root2 == null || root1.val != root2.val) {
97+
return false;
98+
}
99+
return (dfs(root1.left, root2.left) && dfs(root1.right, root2.right)) || (dfs(root1.left, root2.right) && dfs(root1.right, root2.left));
100+
}
101+
}
102+
```
103+
104+
### **C++**
105+
106+
```cpp
107+
/**
108+
* Definition for a binary tree node.
109+
* struct TreeNode {
110+
* int val;
111+
* TreeNode *left;
112+
* TreeNode *right;
113+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
114+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
115+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
116+
* };
117+
*/
118+
class Solution {
119+
public:
120+
bool flipEquiv(TreeNode* root1, TreeNode* root2) {
121+
return dfs(root1, root2);
122+
}
123+
124+
bool dfs(TreeNode* root1, TreeNode* root2) {
125+
if (root1 == root2 || (!root1 && !root2)) return true;
126+
if (!root1 || !root2 || root1->val != root2->val) return false;
127+
return (dfs(root1->left, root2->left) && dfs(root1->right, root2->right)) || (dfs(root1->left, root2->right) && dfs(root1->right, root2->left));
128+
}
129+
};
130+
```
55131

132+
### **Go**
133+
134+
```go
135+
/**
136+
* Definition for a binary tree node.
137+
* type TreeNode struct {
138+
* Val int
139+
* Left *TreeNode
140+
* Right *TreeNode
141+
* }
142+
*/
143+
func flipEquiv(root1 *TreeNode, root2 *TreeNode) bool {
144+
var dfs func(root1, root2 *TreeNode) bool
145+
dfs = func(root1, root2 *TreeNode) bool {
146+
if root1 == root2 || (root1 == nil && root2 == nil) {
147+
return true
148+
}
149+
if root1 == nil || root2 == nil || root1.Val != root2.Val {
150+
return false
151+
}
152+
return (dfs(root1.Left, root2.Left) && dfs(root1.Right, root2.Right)) || (dfs(root1.Left, root2.Right) && dfs(root1.Right, root2.Left))
153+
}
154+
return dfs(root1, root2)
155+
}
56156
```
57157

58158
### **...**

‎solution/0900-0999/0951.Flip Equivalent Binary Trees/README_EN.md

Lines changed: 101 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -57,18 +57,118 @@
5757

5858
## Solutions
5959

60+
DFS.
61+
6062
<!-- tabs:start -->
6163

6264
### **Python3**
6365

6466
```python
65-
67+
# Definition for a binary tree node.
68+
# class TreeNode:
69+
# def __init__(self, val=0, left=None, right=None):
70+
# self.val = val
71+
# self.left = left
72+
# self.right = right
73+
class Solution:
74+
def flipEquiv(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool:
75+
def dfs(root1, root2):
76+
if root1 == root2 or (root1 is None and root2 is None):
77+
return True
78+
if root1 is None or root2 is None or root1.val != root2.val:
79+
return False
80+
return (dfs(root1.left, root2.left) and dfs(root1.right, root2.right)) or (dfs(root1.left, root2.right) and dfs(root1.right, root2.left))
81+
82+
return dfs(root1, root2)
6683
```
6784

6885
### **Java**
6986

7087
```java
88+
/**
89+
* Definition for a binary tree node.
90+
* public class TreeNode {
91+
* int val;
92+
* TreeNode left;
93+
* TreeNode right;
94+
* TreeNode() {}
95+
* TreeNode(int val) { this.val = val; }
96+
* TreeNode(int val, TreeNode left, TreeNode right) {
97+
* this.val = val;
98+
* this.left = left;
99+
* this.right = right;
100+
* }
101+
* }
102+
*/
103+
class Solution {
104+
public boolean flipEquiv(TreeNode root1, TreeNode root2) {
105+
return dfs(root1, root2);
106+
}
107+
108+
private boolean dfs(TreeNode root1, TreeNode root2) {
109+
if (root1 == root2 || (root1 == null && root2 == null)) {
110+
return true;
111+
}
112+
if (root1 == null || root2 == null || root1.val != root2.val) {
113+
return false;
114+
}
115+
return (dfs(root1.left, root2.left) && dfs(root1.right, root2.right)) || (dfs(root1.left, root2.right) && dfs(root1.right, root2.left));
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+
bool flipEquiv(TreeNode* root1, TreeNode* root2) {
137+
return dfs(root1, root2);
138+
}
139+
140+
bool dfs(TreeNode* root1, TreeNode* root2) {
141+
if (root1 == root2 || (!root1 && !root2)) return true;
142+
if (!root1 || !root2 || root1->val != root2->val) return false;
143+
return (dfs(root1->left, root2->left) && dfs(root1->right, root2->right)) || (dfs(root1->left, root2->right) && dfs(root1->right, root2->left));
144+
}
145+
};
146+
```
71147

148+
### **Go**
149+
150+
```go
151+
/**
152+
* Definition for a binary tree node.
153+
* type TreeNode struct {
154+
* Val int
155+
* Left *TreeNode
156+
* Right *TreeNode
157+
* }
158+
*/
159+
func flipEquiv(root1 *TreeNode, root2 *TreeNode) bool {
160+
var dfs func(root1, root2 *TreeNode) bool
161+
dfs = func(root1, root2 *TreeNode) bool {
162+
if root1 == root2 || (root1 == nil && root2 == nil) {
163+
return true
164+
}
165+
if root1 == nil || root2 == nil || root1.Val != root2.Val {
166+
return false
167+
}
168+
return (dfs(root1.Left, root2.Left) && dfs(root1.Right, root2.Right)) || (dfs(root1.Left, root2.Right) && dfs(root1.Right, root2.Left))
169+
}
170+
return dfs(root1, root2)
171+
}
72172
```
73173

74174
### **...**

‎solution/0900-0999/0951.Flip Equivalent Binary Trees/Solution.cpp

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
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+
bool flipEquiv(TreeNode* root1, TreeNode* root2) {
15+
return dfs(root1, root2);
16+
}
17+
18+
bool dfs(TreeNode* root1, TreeNode* root2) {
19+
if (root1 == root2 || (!root1 && !root2)) return true;
20+
if (!root1 || !root2 || root1->val != root2->val) return false;
21+
return (dfs(root1->left, root2->left) && dfs(root1->right, root2->right)) || (dfs(root1->left, root2->right) && dfs(root1->right, root2->left));
22+
}
23+
};

‎solution/0900-0999/0951.Flip Equivalent Binary Trees/Solution.go

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
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 flipEquiv(root1 *TreeNode, root2 *TreeNode) bool {
10+
var dfs func(root1, root2 *TreeNode) bool
11+
dfs = func(root1, root2 *TreeNode) bool {
12+
if root1 == root2 || (root1 == nil && root2 == nil) {
13+
return true
14+
}
15+
if root1 == nil || root2 == nil || root1.Val != root2.Val {
16+
return false
17+
}
18+
return (dfs(root1.Left, root2.Left) && dfs(root1.Right, root2.Right)) || (dfs(root1.Left, root2.Right) && dfs(root1.Right, root2.Left))
19+
}
20+
return dfs(root1, root2)
21+
}

‎solution/0900-0999/0951.Flip Equivalent Binary Trees/Solution.java

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
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+
public boolean flipEquiv(TreeNode root1, TreeNode root2) {
18+
return dfs(root1, root2);
19+
}
20+
21+
private boolean dfs(TreeNode root1, TreeNode root2) {
22+
if (root1 == root2 || (root1 == null && root2 == null)) {
23+
return true;
24+
}
25+
if (root1 == null || root2 == null || root1.val != root2.val) {
26+
return false;
27+
}
28+
return (dfs(root1.left, root2.left) && dfs(root1.right, root2.right)) || (dfs(root1.left, root2.right) && dfs(root1.right, root2.left));
29+
}
30+
}

‎solution/0900-0999/0951.Flip Equivalent Binary Trees/Solution.py

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
7+
class Solution:
8+
def flipEquiv(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool:
9+
def dfs(root1, root2):
10+
if root1 == root2 or (root1 is None and root2 is None):
11+
return True
12+
if root1 is None or root2 is None or root1.val != root2.val:
13+
return False
14+
return (dfs(root1.left, root2.left) and dfs(root1.right, root2.right)) or (dfs(root1.left, root2.right) and dfs(root1.right, root2.left))
15+
16+
return dfs(root1, root2)

0 commit comments

Comments
 (0)