leetcode: 1123

From: MacOS

一个暂未verify的commit
需要手动认证

Signed-off-by: LetMeFly666 <[email protected]>

Author: LetMeFly666

.commitmsg

@@ -1 +1,4 @@
-MGJW: 周报.(本周->上周)
+From: MacOS
+
+一个暂未verify的commit
+需要手动认证

Codes/1123-lowest-common-ancestor-of-deepest-leaves_20250405.cpp

@@ -0,0 +1,41 @@
+/*
+ * @Author: LetMeFly
+ * @Date: 2025-04-05 00:42:04
+ * @LastEditors: LetMeFly.xyz
+ * @LastEditTime: 2025-04-05 00:47:42
+ */
+#ifdef _WIN32
+#include "_[1,2]toVector.h"
+#endif
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+private:
+    pair<TreeNode*, int> dfs(TreeNode* root) {
+        if (!root) {
+            return {root, 0};
+        }
+        pair<TreeNode*, int> left = dfs(root->left);
+        pair<TreeNode*, int> right = dfs(root->right);
+        if (left.second > right.second) {
+            return {left.first, left.second + 1};
+        } else if (left.second < right.second) {
+            return {right.first, right.second + 1};
+        }
+        return {root, left.second + 1};
+    }
+public:
+    TreeNode* lcaDeepestLeaves(TreeNode* root) {
+        return dfs(root).first;
+    }
+};

Codes/1123-lowest-common-ancestor-of-deepest-leaves_20250405.go

@@ -0,0 +1,38 @@
+/*
+ * @Author: LetMeFly
+ * @Date: 2025-04-05 01:05:07
+ * @LastEditors: LetMeFly.xyz
+ * @LastEditTime: 2025-04-05 01:11:09
+ */
+package main
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+type pair struct{
+    node *TreeNode
+    depth int
+}
+
+func dfs(root* TreeNode) pair {
+    if root == nil {
+        return pair{root, 0}
+    }
+    left := dfs(root.Left)
+    right := dfs(root.Right)
+    if left.depth > right.depth {
+        return pair{left.node, left.depth + 1}
+    } else if left.depth < right.depth {
+        return pair{right.node, right.depth + 1}
+    }
+    return pair{root, left.depth + 1}
+}
+
+func lcaDeepestLeaves(root *TreeNode) *TreeNode {
+    return dfs(root).node
+}

Codes/1123-lowest-common-ancestor-of-deepest-leaves_20250405.java

@@ -0,0 +1,40 @@
+/*
+ * @Author: LetMeFly
+ * @Date: 2025-04-05 00:59:21
+ * @LastEditors: LetMeFly.xyz
+ * @LastEditTime: 2025-04-05 01:03:59
+ */
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    private Pair<TreeNode, Integer> dfs(TreeNode root) {
+        if (root == null) {
+            return new Pair<>(root, 0);
+        }
+        Pair<TreeNode, Integer> left = dfs(root.left);
+        Pair<TreeNode, Integer> right = dfs(root.right);
+        if (left.getValue() > right.getValue()) {
+            return new Pair<>(left.getKey(), left.getValue() + 1);
+        } else if (left.getValue() < right.getValue()) {
+            return new Pair<>(right.getKey(), right.getValue() + 1);
+        }
+        return new Pair<>(root, left.getValue() + 1);
+    }
+
+    public TreeNode lcaDeepestLeaves(TreeNode root) {
+        return dfs(root).getKey();
+    }
+}

Codes/1123-lowest-common-ancestor-of-deepest-leaves_20250405.py

@@ -0,0 +1,30 @@
+'''
+Author: LetMeFly
+Date: 2025-04-05 00:49:25
+LastEditors: LetMeFly.xyz
+LastEditTime: 2025-04-05 00:58:30
+'''
+from typing import Tuple, Optional
+
+
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def dfs(self, root: Optional[TreeNode]) -> Tuple[Optional[TreeNode], int]:
+        if not root:
+            return (root, 0)
+        left = self.dfs(root.left)
+        right = self.dfs(root.right)
+        if left[1] > right[1]:
+            return (left[0], left[1] + 1)
+        elif left[1] < right[1]:
+            return (right[0], right[1] + 1)
+        return (root, left[1] + 1)
+        
+    def lcaDeepestLeaves(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        return self.dfs(root)[0]

Solutions/LeetCode 1123.最深叶节点的最近公共祖先.md

@@ -80,6 +80,12 @@ categories: [题解, LeetCode]
 #### C++
 
 ```cpp
+/*
+ * @Author: LetMeFly
+ * @Date: 2023-09-06 22:43:49
+ * @LastEditors: LetMeFly
+ * @LastEditTime: 2023-09-06 22:49:44
+ */
 typedef pair<TreeNode*, int> pti;
 class Solution {
 private:
@@ -109,31 +115,124 @@ public:
 #### Python
 
 ```python
-# from typing import Optional
-
-# # Definition for a binary tree node.
-# class TreeNode:
-#     def __init__(self, val=0, left=None, right=None):
-#         self.val = val
-#         self.left = left
-#         self.right = right
+'''
+Author: LetMeFly
+Date: 2025-04-05 00:49:25
+LastEditors: LetMeFly.xyz
+LastEditTime: 2025-04-05 00:58:30
+'''
+from typing import Tuple, Optional
+
+
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
 
 class Solution:
-    def dfs(self, root: Optional[TreeNode]):
+    def dfs(self, root: Optional[TreeNode]) -> Tuple[Optional[TreeNode], int]:
         if not root:
-            return [None, 0]
+            return (root, 0)
         left = self.dfs(root.left)
         right = self.dfs(root.right)
-        if left[1] == right[1]:
-            return [root, left[1] + 1]
+        if left[1] > right[1]:
+            return (left[0], left[1] + 1)
         elif left[1] < right[1]:
-            return [right[0], right[1] + 1]
-        else:
-            return [left[0], left[1] + 1]
-    
+            return (right[0], right[1] + 1)
+        return (root, left[1] + 1)
+        
     def lcaDeepestLeaves(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
         return self.dfs(root)[0]
+```
+
+#### Java
+
+```java
+/*
+ * @Author: LetMeFly
+ * @Date: 2025-04-05 00:59:21
+ * @LastEditors: LetMeFly.xyz
+ * @LastEditTime: 2025-04-05 01:03:59
+ */
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    private Pair<TreeNode, Integer> dfs(TreeNode root) {
+        if (root == null) {
+            return new Pair<>(root, 0);
+        }
+        Pair<TreeNode, Integer> left = dfs(root.left);
+        Pair<TreeNode, Integer> right = dfs(root.right);
+        if (left.getValue() > right.getValue()) {
+            return new Pair<>(left.getKey(), left.getValue() + 1);
+        } else if (left.getValue() < right.getValue()) {
+            return new Pair<>(right.getKey(), right.getValue() + 1);
+        }
+        return new Pair<>(root, left.getValue() + 1);
+    }
+
+    public TreeNode lcaDeepestLeaves(TreeNode root) {
+        return dfs(root).getKey();
+    }
+}
+```
+
+#### Go
+
+```go
+/*
+ * @Author: LetMeFly
+ * @Date: 2025-04-05 01:05:07
+ * @LastEditors: LetMeFly.xyz
+ * @LastEditTime: 2025-04-05 01:11:09
+ */
+package main
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+type pair struct{
+    node *TreeNode
+    depth int
+}
+
+func dfs(root* TreeNode) pair {
+    if root == nil {
+        return pair{root, 0}
+    }
+    left := dfs(root.Left)
+    right := dfs(root.Right)
+    if left.depth > right.depth {
+        return pair{left.node, left.depth + 1}
+    } else if left.depth < right.depth {
+        return pair{right.node, right.depth + 1}
+    }
+    return pair{root, left.depth + 1}
+}
 
+func lcaDeepestLeaves(root *TreeNode) *TreeNode {
+    return dfs(root).node
+}
 ```
 
 > 同步发文于CSDN，原创不易，转载经作者同意后请附上[原文链接](https://blog.letmefly.xyz/2023/09/06/LeetCode%201123.%E6%9C%80%E6%B7%B1%E5%8F%B6%E8%8A%82%E7%82%B9%E7%9A%84%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/)哦~

Solutions/Other-English-LearningNotes-SomeWords.md

@@ -1081,6 +1081,8 @@ categories: [自用]
 |||
 |insofar|adv. 到如此程度<details><summary>例句</summary>I'll help you <font color="#28bea0">insofar</font> as I can.<br/>我将尽力帮助你。</details>|
 |mitten|n. 连指手套|
+|||
+|luxurious|adj. 奢侈的，十分舒适的|
 
 <p class="wordCounts">单词收录总数</p>