Skip to content

Commit 30b9a8b

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.1123 (#4327)
No.1123.Lowest Common Ancestor of Deepest Leaves
1 parent fda9fec commit 30b9a8b

File tree

4 files changed

+163
-45
lines changed

4 files changed

+163
-45
lines changed

‎solution/1100-1199/1123.Lowest Common Ancestor of Deepest Leaves/README.md

+56-15
Original file line numberDiff line numberDiff line change
@@ -175,23 +175,22 @@ class Solution {
175175
class Solution {
176176
public:
177177
TreeNode* lcaDeepestLeaves(TreeNode* root) {
178+
auto dfs = [&](this auto&& dfs, TreeNode* root) -> pair<TreeNode*, int> {
179+
if (!root) {
180+
return {nullptr, 0};
181+
}
182+
auto [l, d1] = dfs(root->left);
183+
auto [r, d2] = dfs(root->right);
184+
if (d1 > d2) {
185+
return {l, d1 + 1};
186+
}
187+
if (d1 < d2) {
188+
return {r, d2 + 1};
189+
}
190+
return {root, d1 + 1};
191+
};
178192
return dfs(root).first;
179193
}
180-
181-
pair<TreeNode*, int> dfs(TreeNode* root) {
182-
if (!root) {
183-
return {nullptr, 0};
184-
}
185-
auto [l, d1] = dfs(root->left);
186-
auto [r, d2] = dfs(root->right);
187-
if (d1 > d2) {
188-
return {l, d1 + 1};
189-
}
190-
if (d1 < d2) {
191-
return {r, d2 + 1};
192-
}
193-
return {root, d1 + 1};
194-
}
195194
};
196195
```
197196
@@ -267,6 +266,48 @@ function lcaDeepestLeaves(root: TreeNode | null): TreeNode | null {
267266
}
268267
```
269268

269+
#### C#
270+
271+
```cs
272+
/**
273+
* Definition for a binary tree node.
274+
* public class TreeNode {
275+
* public int val;
276+
* public TreeNode left;
277+
* public TreeNode right;
278+
* public TreeNode(int val = 0, TreeNode left = null, TreeNode right = null) {
279+
* this.val = val;
280+
* this.left = left;
281+
* this.right = right;
282+
* }
283+
* }
284+
*/
285+
public class Solution {
286+
public TreeNode LcaDeepestLeaves(TreeNode root) {
287+
(TreeNode, int) Dfs(TreeNode root) {
288+
if (root == null) {
289+
return (null, 0);
290+
}
291+
292+
var l = Dfs(root.left);
293+
var r = Dfs(root.right);
294+
int d1 = l.Item2;
295+
int d2 = r.Item2;
296+
297+
if (d1 > d2) {
298+
return (l.Item1, d1 + 1);
299+
}
300+
if (d1 < d2) {
301+
return (r.Item1, d2 + 1);
302+
}
303+
return (root, d1 + 1);
304+
}
305+
306+
return Dfs(root).Item1;
307+
}
308+
}
309+
```
310+
270311
<!-- tabs:end -->
271312

272313
<!-- solution:end -->

‎solution/1100-1199/1123.Lowest Common Ancestor of Deepest Leaves/README_EN.md

+56-15
Original file line numberDiff line numberDiff line change
@@ -172,23 +172,22 @@ class Solution {
172172
class Solution {
173173
public:
174174
TreeNode* lcaDeepestLeaves(TreeNode* root) {
175+
auto dfs = [&](this auto&& dfs, TreeNode* root) -> pair<TreeNode*, int> {
176+
if (!root) {
177+
return {nullptr, 0};
178+
}
179+
auto [l, d1] = dfs(root->left);
180+
auto [r, d2] = dfs(root->right);
181+
if (d1 > d2) {
182+
return {l, d1 + 1};
183+
}
184+
if (d1 < d2) {
185+
return {r, d2 + 1};
186+
}
187+
return {root, d1 + 1};
188+
};
175189
return dfs(root).first;
176190
}
177-
178-
pair<TreeNode*, int> dfs(TreeNode* root) {
179-
if (!root) {
180-
return {nullptr, 0};
181-
}
182-
auto [l, d1] = dfs(root->left);
183-
auto [r, d2] = dfs(root->right);
184-
if (d1 > d2) {
185-
return {l, d1 + 1};
186-
}
187-
if (d1 < d2) {
188-
return {r, d2 + 1};
189-
}
190-
return {root, d1 + 1};
191-
}
192191
};
193192
```
194193
@@ -264,6 +263,48 @@ function lcaDeepestLeaves(root: TreeNode | null): TreeNode | null {
264263
}
265264
```
266265

266+
#### C#
267+
268+
```cs
269+
/**
270+
* Definition for a binary tree node.
271+
* public class TreeNode {
272+
* public int val;
273+
* public TreeNode left;
274+
* public TreeNode right;
275+
* public TreeNode(int val = 0, TreeNode left = null, TreeNode right = null) {
276+
* this.val = val;
277+
* this.left = left;
278+
* this.right = right;
279+
* }
280+
* }
281+
*/
282+
public class Solution {
283+
public TreeNode LcaDeepestLeaves(TreeNode root) {
284+
(TreeNode, int) Dfs(TreeNode root) {
285+
if (root == null) {
286+
return (null, 0);
287+
}
288+
289+
var l = Dfs(root.left);
290+
var r = Dfs(root.right);
291+
int d1 = l.Item2;
292+
int d2 = r.Item2;
293+
294+
if (d1 > d2) {
295+
return (l.Item1, d1 + 1);
296+
}
297+
if (d1 < d2) {
298+
return (r.Item1, d2 + 1);
299+
}
300+
return (root, d1 + 1);
301+
}
302+
303+
return Dfs(root).Item1;
304+
}
305+
}
306+
```
307+
267308
<!-- tabs:end -->
268309

269310
<!-- solution:end -->

‎solution/1100-1199/1123.Lowest Common Ancestor of Deepest Leaves/Solution.cpp

+14-15
Original file line numberDiff line numberDiff line change
@@ -12,21 +12,20 @@
1212
class Solution {
1313
public:
1414
TreeNode* lcaDeepestLeaves(TreeNode* root) {
15+
auto dfs = [&](this auto&& dfs, TreeNode* root) -> pair<TreeNode*, int> {
16+
if (!root) {
17+
return {nullptr, 0};
18+
}
19+
auto [l, d1] = dfs(root->left);
20+
auto [r, d2] = dfs(root->right);
21+
if (d1 > d2) {
22+
return {l, d1 + 1};
23+
}
24+
if (d1 < d2) {
25+
return {r, d2 + 1};
26+
}
27+
return {root, d1 + 1};
28+
};
1529
return dfs(root).first;
1630
}
17-
18-
pair<TreeNode*, int> dfs(TreeNode* root) {
19-
if (!root) {
20-
return {nullptr, 0};
21-
}
22-
auto [l, d1] = dfs(root->left);
23-
auto [r, d2] = dfs(root->right);
24-
if (d1 > d2) {
25-
return {l, d1 + 1};
26-
}
27-
if (d1 < d2) {
28-
return {r, d2 + 1};
29-
}
30-
return {root, d1 + 1};
31-
}
3231
};

‎solution/1100-1199/1123.Lowest Common Ancestor of Deepest Leaves/Solution.cs

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* public class TreeNode {
4+
* public int val;
5+
* public TreeNode left;
6+
* public TreeNode right;
7+
* public TreeNode(int val = 0, TreeNode left = null, TreeNode right = null) {
8+
* this.val = val;
9+
* this.left = left;
10+
* this.right = right;
11+
* }
12+
* }
13+
*/
14+
public class Solution {
15+
public TreeNode LcaDeepestLeaves(TreeNode root) {
16+
(TreeNode, int) Dfs(TreeNode root) {
17+
if (root == null) {
18+
return (null, 0);
19+
}
20+
21+
var l = Dfs(root.left);
22+
var r = Dfs(root.right);
23+
int d1 = l.Item2;
24+
int d2 = r.Item2;
25+
26+
if (d1 > d2) {
27+
return (l.Item1, d1 + 1);
28+
}
29+
if (d1 < d2) {
30+
return (r.Item1, d2 + 1);
31+
}
32+
return (root, d1 + 1);
33+
}
34+
35+
return Dfs(root).Item1;
36+
}
37+
}

0 commit comments

Comments
 (0)