feat: add solutions to lc problem: No.1379

1379.Find a Corresponding Node of a Binary Tree in a Clone of That Tree

Author: yanglbme

solution/1300-1399/1379.Find a Corresponding Node of a Binary Tree in a Clone of That Tree/README.md

@@ -80,7 +80,6 @@
 	<li><code>target</code>&nbsp;节点是树&nbsp;<code>original</code>&nbsp;中的一个节点，并且不会是&nbsp;<code>null</code>&nbsp;。</li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
@@ -92,15 +91,101 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def getTargetCopy(self, original: TreeNode, cloned: TreeNode, target: TreeNode) -> TreeNode:
+        res = None
+
+        def dfs(original, cloned):
+            nonlocal res
+            if cloned is None:
+                return
+            if original == target:
+                res = cloned
+                return
+            dfs(original.left, cloned.left)
+            dfs(original.right, cloned.right)
+
+        dfs(original, cloned)
+        return res
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+
+class Solution {
+    private TreeNode res;
+
+    public final TreeNode getTargetCopy(final TreeNode original, final TreeNode cloned, final TreeNode target) {
+        dfs(original, cloned, target);
+        return res;
+    }
+
+    private void dfs(TreeNode original, TreeNode cloned, TreeNode target) {
+        if (cloned == null) {
+            return;
+        }
+        if (original == target) {
+            res = cloned;
+            return;
+        }
+        dfs(original.left, cloned.left, target);
+        dfs(original.right, cloned.right, target);
+    }
+}
+```
 
+### **C++**
+
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+
+class Solution {
+public:
+    TreeNode* res;
+
+    TreeNode* getTargetCopy(TreeNode* original, TreeNode* cloned, TreeNode* target) {
+        dfs(original, cloned, target);
+        return res;
+    }
+
+    void dfs(TreeNode* original, TreeNode* cloned, TreeNode* target) {
+        if (!cloned) return;
+        if (original == target)
+        {
+            res = cloned;
+            return;
+        }
+        dfs(original->left, cloned->left, target);
+        dfs(original->right, cloned->right, target);
+    }
+};
 ```
 
 ### **...**

solution/1300-1399/1379.Find a Corresponding Node of a Binary Tree in a Clone of That Tree/README_EN.md

@@ -6,24 +6,14 @@
 
 <p>Given two binary trees <code>original</code> and <code>cloned</code> and given a reference to a node <code>target</code> in the original tree.</p>
 
-
-
 <p>The <code>cloned</code> tree is a <strong>copy of</strong> the <code>original</code> tree.</p>
 
-
-
 <p>Return <em>a reference to the same node</em> in the <code>cloned</code> tree.</p>
 
-
-
 <p><strong>Note</strong> that you are <strong>not allowed</strong> to change any of the two trees or the <code>target</code> node and the answer <strong>must be</strong> a reference to a node in the <code>cloned</code> tree.</p>
 
-
-
 <p><strong>Follow up:</strong>&nbsp;Solve the problem if repeated values on the tree are allowed.</p>
 
-
-
 <p>&nbsp;</p>
 
 <p><strong>Example 1:</strong></p>
@@ -40,8 +30,6 @@
 
 </pre>
 
-
-
 <p><strong>Example 2:</strong></p>
 
 <img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/1300-1399/1379.Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree/images/e2.png" style="width: 221px; height: 159px;" />
@@ -54,8 +42,6 @@
 
 </pre>
 
-
-
 <p><strong>Example 3:</strong></p>
 
 <img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/1300-1399/1379.Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree/images/e3.png" style="width: 459px; height: 486px;" />
@@ -68,8 +54,6 @@
 
 </pre>
 
-
-
 <p><strong>Example 4:</strong></p>
 
 <img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/1300-1399/1379.Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree/images/e4.png" style="width: 555px; height: 239px;" />
@@ -82,8 +66,6 @@
 
 </pre>
 
-
-
 <p><strong>Example 5:</strong></p>
 
 <img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/1300-1399/1379.Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree/images/e5.png" style="width: 427px; height: 345px;" />
@@ -96,14 +78,10 @@
 
 </pre>
 
-
-
 <p>&nbsp;</p>
 
 <p><strong>Constraints:</strong></p>
 
-
-
 <ul>
 	<li>The number of nodes in the <code>tree</code> is in the range <code>[1, 10^4]</code>.</li>
 	<li>The values of the nodes of the <code>tree</code> are unique.</li>
@@ -117,13 +95,99 @@
 ### **Python3**
 
 ```python
-
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def getTargetCopy(self, original: TreeNode, cloned: TreeNode, target: TreeNode) -> TreeNode:
+        res = None
+
+        def dfs(original, cloned):
+            nonlocal res
+            if cloned is None:
+                return
+            if original == target:
+                res = cloned
+                return
+            dfs(original.left, cloned.left)
+            dfs(original.right, cloned.right)
+
+        dfs(original, cloned)
+        return res
 ```
 
 ### **Java**
 
 ```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+
+class Solution {
+    private TreeNode res;
+
+    public final TreeNode getTargetCopy(final TreeNode original, final TreeNode cloned, final TreeNode target) {
+        dfs(original, cloned, target);
+        return res;
+    }
+
+    private void dfs(TreeNode original, TreeNode cloned, TreeNode target) {
+        if (cloned == null) {
+            return;
+        }
+        if (original == target) {
+            res = cloned;
+            return;
+        }
+        dfs(original.left, cloned.left, target);
+        dfs(original.right, cloned.right, target);
+    }
+}
+```
 
+### **C++**
+
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+
+class Solution {
+public:
+    TreeNode* res;
+
+    TreeNode* getTargetCopy(TreeNode* original, TreeNode* cloned, TreeNode* target) {
+        dfs(original, cloned, target);
+        return res;
+    }
+
+    void dfs(TreeNode* original, TreeNode* cloned, TreeNode* target) {
+        if (!cloned) return;
+        if (original == target)
+        {
+            res = cloned;
+            return;
+        }
+        dfs(original->left, cloned->left, target);
+        dfs(original->right, cloned->right, target);
+    }
+};
 ```
 
 ### **...**

solution/1300-1399/1379.Find a Corresponding Node of a Binary Tree in a Clone of That Tree/Solution.cpp

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+
+class Solution {
+public:
+    TreeNode* res;
+
+    TreeNode* getTargetCopy(TreeNode* original, TreeNode* cloned, TreeNode* target) {
+        dfs(original, cloned, target);
+        return res;
+    }
+
+    void dfs(TreeNode* original, TreeNode* cloned, TreeNode* target) {
+        if (!cloned) return;
+        if (original == target)
+        {
+            res = cloned;
+            return;
+        }
+        dfs(original->left, cloned->left, target);
+        dfs(original->right, cloned->right, target);
+    }
+};

solution/1300-1399/1379.Find a Corresponding Node of a Binary Tree in a Clone of That Tree/Solution.java

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+
+class Solution {
+    private TreeNode res;
+
+    public final TreeNode getTargetCopy(final TreeNode original, final TreeNode cloned, final TreeNode target) {
+        dfs(original, cloned, target);
+        return res;
+    }
+
+    private void dfs(TreeNode original, TreeNode cloned, TreeNode target) {
+        if (cloned == null) {
+            return;
+        }
+        if (original == target) {
+            res = cloned;
+            return;
+        }
+        dfs(original.left, cloned.left, target);
+        dfs(original.right, cloned.right, target);
+    }
+}

solution/1300-1399/1379.Find a Corresponding Node of a Binary Tree in a Clone of That Tree/Solution.py

@@ -0,0 +1,23 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def getTargetCopy(self, original: TreeNode, cloned: TreeNode, target: TreeNode) -> TreeNode:
+        res = None
+
+        def dfs(original, cloned):
+            nonlocal res
+            if cloned is None:
+                return
+            if original == target:
+                res = cloned
+                return
+            dfs(original.left, cloned.left)
+            dfs(original.right, cloned.right)
+
+        dfs(original, cloned)
+        return res