Skip to content

Commit 76f10a2

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problems: No.0549,1522
* No.0549.Binary Tree Longest Consecutive Sequence II * No.1522.Diameter of N-Ary Tree
1 parent a0dfaa9 commit 76f10a2

File tree

20 files changed

+1940
-85
lines changed

20 files changed

+1940
-85
lines changed

‎solution/0500-0599/0543.Diameter of Binary Tree/README.md

+75-27
Original file line numberDiff line numberDiff line change
@@ -30,8 +30,14 @@
3030

3131
<!-- 这里可写通用的实现逻辑 -->
3232

33+
**方法一**：后序遍历求每个结点的深度，此过程中获取每个结点左右子树的最长伸展（深度），迭代获取最长路径。
34+
3335
类似题目：[687. 最长同值路径](/solution/0600-0699/0687.Longest%20Univalue%20Path/README.md)
3436

37+
**方法二**：构建图，两次 DFS。
38+
39+
类似题目：[1245. 树的直径](/solution/1200-1299/1245.Tree%20Diameter/README.md), [1522. N 叉树的直径](/solution/1500-1599/1522.Diameter%20of%20N-Ary%20Tree/README.md)
40+
3541
<!-- tabs:start -->
3642

3743
### **Python3**
@@ -47,18 +53,61 @@
4753
# self.right = right
4854
class Solution:
4955
def diameterOfBinaryTree(self, root: TreeNode) -> int:
50-
res = 0
51-
5256
def dfs(root):
53-
nonlocal res
5457
if root is None:
5558
return 0
59+
nonlocal ans
5660
left, right = dfs(root.left), dfs(root.right)
57-
res = max(res, left + right)
61+
ans = max(ans, left + right)
5862
return 1 + max(left, right)
5963

64+
ans = 0
6065
dfs(root)
61-
return res
66+
return ans
67+
```
68+
69+
```python
70+
# Definition for a binary tree node.
71+
# class TreeNode:
72+
# def __init__(self, val=0, left=None, right=None):
73+
# self.val = val
74+
# self.left = left
75+
# self.right = right
76+
class Solution:
77+
def diameterOfBinaryTree(self, root: TreeNode) -> int:
78+
def build(root):
79+
if root is None:
80+
return
81+
nonlocal d
82+
if root.left:
83+
d[root].add(root.left)
84+
d[root.left].add(root)
85+
if root.right:
86+
d[root].add(root.right)
87+
d[root.right].add(root)
88+
build(root.left)
89+
build(root.right)
90+
91+
def dfs(u, t):
92+
nonlocal ans, vis, d, next
93+
if u in vis:
94+
return
95+
vis.add(u)
96+
if t > ans:
97+
ans = t
98+
next = u
99+
for v in d[u]:
100+
dfs(v, t + 1)
101+
102+
d = defaultdict(set)
103+
ans = 0
104+
next = root
105+
build(root)
106+
vis = set()
107+
dfs(next, 0)
108+
vis.clear()
109+
dfs(next, 0)
110+
return ans
62111
```
63112

64113
### **Java**
@@ -82,12 +131,12 @@ class Solution:
82131
* }
83132
*/
84133
class Solution {
85-
private int res;
134+
private int ans;
86135

87136
public int diameterOfBinaryTree(TreeNode root) {
88-
res = 0;
137+
ans = 0;
89138
dfs(root);
90-
return res;
139+
return ans;
91140
}
92141

93142
private int dfs(TreeNode root) {
@@ -96,7 +145,7 @@ class Solution {
96145
}
97146
int left = dfs(root.left);
98147
int right = dfs(root.right);
99-
res = Math.max(res, left + right);
148+
ans = Math.max(ans, left + right);
100149
return 1 + Math.max(left, right);
101150
}
102151
}
@@ -118,18 +167,19 @@ class Solution {
118167
*/
119168
class Solution {
120169
public:
121-
int res;
170+
int ans;
122171

123172
int diameterOfBinaryTree(TreeNode* root) {
124-
res = 0;
173+
ans = 0;
125174
dfs(root);
126-
return res;
175+
return ans;
127176
}
128177

129178
int dfs(TreeNode* root) {
130179
if (!root) return 0;
131-
int left = dfs(root->left), right = dfs(root->right);
132-
res = max(res, left + right);
180+
int left = dfs(root->left);
181+
int right = dfs(root->right);
182+
ans = max(ans, left + right);
133183
return 1 + max(left, right);
134184
}
135185
};
@@ -146,21 +196,19 @@ public:
146196
* Right *TreeNode
147197
* }
148198
*/
149-
var res int
150-
151199
func diameterOfBinaryTree(root *TreeNode) int {
152-
res = 0
153-
dfs(root)
154-
return res
155-
}
156-
157-
func dfs(root *TreeNode) int {
158-
if root == nil {
159-
return 0
200+
ans := 0
201+
var dfs func(root *TreeNode) int
202+
dfs = func(root *TreeNode) int {
203+
if root == nil {
204+
return 0
205+
}
206+
left, right := dfs(root.Left), dfs(root.Right)
207+
ans = max(ans, left+right)
208+
return 1 + max(left, right)
160209
}
161-
left, right := dfs(root.Left), dfs(root.Right)
162-
res = max(res, left+right)
163-
return 1 + max(left, right)
210+
dfs(root)
211+
return ans
164212
}
165213
166214
func max(a, b int) int {

‎solution/0500-0599/0543.Diameter of Binary Tree/README_EN.md

+69-27
Original file line numberDiff line numberDiff line change
@@ -51,18 +51,61 @@ Similar to problem [687. Longest Univalue Path](/solution/0600-0699/0687.Longest
5151
# self.right = right
5252
class Solution:
5353
def diameterOfBinaryTree(self, root: TreeNode) -> int:
54-
res = 0
55-
5654
def dfs(root):
57-
nonlocal res
5855
if root is None:
5956
return 0
57+
nonlocal ans
6058
left, right = dfs(root.left), dfs(root.right)
61-
res = max(res, left + right)
59+
ans = max(ans, left + right)
6260
return 1 + max(left, right)
6361

62+
ans = 0
6463
dfs(root)
65-
return res
64+
return ans
65+
```
66+
67+
```python
68+
# Definition for a binary tree node.
69+
# class TreeNode:
70+
# def __init__(self, val=0, left=None, right=None):
71+
# self.val = val
72+
# self.left = left
73+
# self.right = right
74+
class Solution:
75+
def diameterOfBinaryTree(self, root: TreeNode) -> int:
76+
def build(root):
77+
if root is None:
78+
return
79+
nonlocal d
80+
if root.left:
81+
d[root].add(root.left)
82+
d[root.left].add(root)
83+
if root.right:
84+
d[root].add(root.right)
85+
d[root.right].add(root)
86+
build(root.left)
87+
build(root.right)
88+
89+
def dfs(u, t):
90+
nonlocal ans, vis, d, next
91+
if u in vis:
92+
return
93+
vis.add(u)
94+
if t > ans:
95+
ans = t
96+
next = u
97+
for v in d[u]:
98+
dfs(v, t + 1)
99+
100+
d = defaultdict(set)
101+
ans = 0
102+
next = root
103+
build(root)
104+
vis = set()
105+
dfs(next, 0)
106+
vis.clear()
107+
dfs(next, 0)
108+
return ans
66109
```
67110

68111
### **Java**
@@ -84,12 +127,12 @@ class Solution:
84127
* }
85128
*/
86129
class Solution {
87-
private int res;
130+
private int ans;
88131

89132
public int diameterOfBinaryTree(TreeNode root) {
90-
res = 0;
133+
ans = 0;
91134
dfs(root);
92-
return res;
135+
return ans;
93136
}
94137

95138
private int dfs(TreeNode root) {
@@ -98,7 +141,7 @@ class Solution {
98141
}
99142
int left = dfs(root.left);
100143
int right = dfs(root.right);
101-
res = Math.max(res, left + right);
144+
ans = Math.max(ans, left + right);
102145
return 1 + Math.max(left, right);
103146
}
104147
}
@@ -120,18 +163,19 @@ class Solution {
120163
*/
121164
class Solution {
122165
public:
123-
int res;
166+
int ans;
124167

125168
int diameterOfBinaryTree(TreeNode* root) {
126-
res = 0;
169+
ans = 0;
127170
dfs(root);
128-
return res;
171+
return ans;
129172
}
130173

131174
int dfs(TreeNode* root) {
132175
if (!root) return 0;
133-
int left = dfs(root->left), right = dfs(root->right);
134-
res = max(res, left + right);
176+
int left = dfs(root->left);
177+
int right = dfs(root->right);
178+
ans = max(ans, left + right);
135179
return 1 + max(left, right);
136180
}
137181
};
@@ -148,21 +192,19 @@ public:
148192
* Right *TreeNode
149193
* }
150194
*/
151-
var res int
152-
153195
func diameterOfBinaryTree(root *TreeNode) int {
154-
res = 0
155-
dfs(root)
156-
return res
157-
}
158-
159-
func dfs(root *TreeNode) int {
160-
if root == nil {
161-
return 0
196+
ans := 0
197+
var dfs func(root *TreeNode) int
198+
dfs = func(root *TreeNode) int {
199+
if root == nil {
200+
return 0
201+
}
202+
left, right := dfs(root.Left), dfs(root.Right)
203+
ans = max(ans, left+right)
204+
return 1 + max(left, right)
162205
}
163-
left, right := dfs(root.Left), dfs(root.Right)
164-
res = max(res, left+right)
165-
return 1 + max(left, right)
206+
dfs(root)
207+
return ans
166208
}
167209
168210
func max(a, b int) int {

‎solution/0500-0599/0543.Diameter of Binary Tree/Solution.cpp

+7-6
Original file line numberDiff line numberDiff line change
@@ -11,18 +11,19 @@
1111
*/
1212
class Solution {
1313
public:
14-
int res;
15-
14+
int ans;
15+
1616
int diameterOfBinaryTree(TreeNode* root) {
17-
res = 0;
17+
ans = 0;
1818
dfs(root);
19-
return res;
19+
return ans;
2020
}
2121

2222
int dfs(TreeNode* root) {
2323
if (!root) return 0;
24-
int left = dfs(root->left), right = dfs(root->right);
25-
res = max(res, left + right);
24+
int left = dfs(root->left);
25+
int right = dfs(root->right);
26+
ans = max(ans, left + right);
2627
return 1 + max(left, right);
2728
}
2829
};

‎solution/0500-0599/0543.Diameter of Binary Tree/Solution.go

+11-13
Original file line numberDiff line numberDiff line change
@@ -6,21 +6,19 @@
66
* Right *TreeNode
77
* }
88
*/
9-
var res int
10-
119
func diameterOfBinaryTree(root *TreeNode) int {
12-
res = 0
13-
dfs(root)
14-
return res
15-
}
16-
17-
func dfs(root *TreeNode) int {
18-
if root == nil {
19-
return 0
10+
ans := 0
11+
var dfs func(root *TreeNode) int
12+
dfs = func(root *TreeNode) int {
13+
if root == nil {
14+
return 0
15+
}
16+
left, right := dfs(root.Left), dfs(root.Right)
17+
ans = max(ans, left+right)
18+
return 1 + max(left, right)
2019
}
21-
left, right := dfs(root.Left), dfs(root.Right)
22-
res = max(res, left+right)
23-
return 1 + max(left, right)
20+
dfs(root)
21+
return ans
2422
}
2523

2624
func max(a, b int) int {

0 commit comments

Comments
 (0)