feat: add solutions to lc problem: No.1660

No.1660.Correct a Binary Tree

Author: yanglbme

solution/1600-1699/1660.Correct a Binary Tree/README.md

@@ -62,49 +62,19 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-<!-- tabs:start -->
+**方法一：DFS**
 
-### **Python3**
+我们设计一个函数 $dfs(root)$，用于处理以 $root$ 为根的子树。如果 $root$ 为 $null$ 或者 $root.right$ 已经被访问过，说明 $root$ 为无效节点，返回 $null$。否则，递归处理 $root.right$ 和 $root.left$，并返回 $root$。
 
-<!-- 这里可写当前语言的特殊实现逻辑 -->
+最后，返回 $dfs(root)$ 即可。
 
-记录父节点。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树节点个数。
 
-```python
-# 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 correctBinaryTree(self, root: TreeNode) -> TreeNode:
-        q = deque([root])
-        res = root
-        p = {}
-        while q:
-            n = len(q)
-            mp = {}
-            for _ in range(n):
-                node = q.popleft()
-                if node.val in mp:
-                    left, father = p[mp[node.val]]
-                    if left:
-                        father.left = None
-                    else:
-                        father.right = None
-                    return res
-                if node.left:
-                    q.append(node.left)
-                    p[node.left.val] = [True, node]
-                if node.right:
-                    q.append(node.right)
-                    p[node.right.val] = [False, node]
-                    mp[node.right.val] = node.val
-        return res
-```
+<!-- tabs:start -->
+
+### **Python3**
 
-优化，无需记录父节点。
+<!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
 # Definition for a binary tree node.
@@ -115,22 +85,16 @@ class Solution:
 #         self.right = right
 class Solution:
     def correctBinaryTree(self, root: TreeNode) -> TreeNode:
-        q = deque([root])
-        while q:
-            n = len(q)
-            for _ in range(n):
-                node = q.popleft()
-                if node.right:
-                    if node.right.right in q:
-                        node.right = None
-                        return root
-                    q.append(node.right)
-                if node.left:
-                    if node.left.right in q:
-                        node.left = None
-                        return root
-                    q.append(node.left)
-        return root
+        def dfs(root):
+            if root is None or root.right in vis:
+                return None
+            vis.add(root)
+            root.right = dfs(root.right)
+            root.left = dfs(root.left)
+            return root
+
+        vis = set()
+        return dfs(root)
 ```
 
 ### **Java**
@@ -154,29 +118,19 @@ class Solution:
  * }
  */
 class Solution {
+    private Set<TreeNode> vis = new HashSet<>();
+
     public TreeNode correctBinaryTree(TreeNode root) {
-        Deque<TreeNode> q = new ArrayDeque<>();
-        q.offer(root);
-        while (!q.isEmpty()) {
-            int n = q.size();
-            while (n-- > 0) {
-                TreeNode node = q.pollFirst();
-                if (node.right != null) {
-                    if (node.right.right != null && q.contains(node.right.right)) {
-                        node.right = null;
-                        return root;
-                    }
-                    q.offer(node.right);
-                }
-                if (node.left != null) {
-                    if (node.left.right != null && q.contains(node.left.right)) {
-                        node.left = null;
-                        return root;
-                    }
-                    q.offer(node.left);
-                }
-            }
+        return dfs(root);
+    }
+
+    private TreeNode dfs(TreeNode root) {
+        if (root == null || vis.contains(root.right)) {
+            return null;
         }
+        vis.add(root);
+        root.right = dfs(root.right);
+        root.left = dfs(root.left);
         return root;
     }
 }
@@ -199,34 +153,50 @@ class Solution {
 class Solution {
 public:
     TreeNode* correctBinaryTree(TreeNode* root) {
-        queue<TreeNode*> q;
-        q.push(root);
-        unordered_set<TreeNode*> s;
-        while (!q.empty()) {
-            int n = q.size();
-            while (n--) {
-                TreeNode* node = q.front();
-                q.pop();
-                if (node->right) {
-                    if (s.count(node->right->right)) {
-                        node->right = nullptr;
-                        return root;
-                    }
-                    q.push(node->right);
-                    s.insert(node->right);
-                }
-                if (node->left) {
-                    if (s.count(node->left->right)) {
-                        node->left = nullptr;
-                        return root;
-                    }
-                    q.push(node->left);
-                    s.insert(node->left);
-                }
+        unordered_set<TreeNode*> vis;
+        function<TreeNode*(TreeNode*)> dfs = [&](TreeNode* root) -> TreeNode* {
+            if (!root || vis.count(root->right)) {
+                return nullptr;
             }
+            vis.insert(root);
+            root->right = dfs(root->right);
+            root->left = dfs(root->left);
+            return root;
+        };
+        return dfs(root);
+    }
+};
+```
+
+### **JavaScript**
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} from
+ * @param {number} to
+ * @return {TreeNode}
+ */
+var correctBinaryTree = function (root) {
+    const dfs = root => {
+        if (!root || vis.has(root.right)) {
+            return null;
         }
+        vis.add(root);
+        root.right = dfs(root.right);
+        root.left = dfs(root.left);
         return root;
-    }
+    };
+    const vis = new Set();
+    return dfs(root);
 };
 ```