feat: add solutions to lc problem: No.1261

No.1261.Find Elements in a Contaminated Binary Tree

Author: yanglbme

solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/README.md

@@ -94,15 +94,200 @@ findElements.find(5); // return True
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```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 FindElements:
+
+    def __init__(self, root: TreeNode):
+        root.val = 0
+        self.nodes = {0}
+
+        def dfs(root):
+            if root is None:
+                return
+            if root.left:
+                root.left.val = root.val * 2 + 1
+                self.nodes.add(root.left.val)
+            if root.right:
+                root.right.val = root.val * 2 + 2
+                self.nodes.add(root.right.val)
+            dfs(root.left)
+            dfs(root.right)
+
+        dfs(root)
+
+    def find(self, target: int) -> bool:
+        return target in self.nodes
+
+
+# Your FindElements object will be instantiated and called as such:
+# obj = FindElements(root)
+# param_1 = obj.find(target)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+/**
+ * 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 FindElements {
+    private Set<Integer> nodes;
+
+    public FindElements(TreeNode root) {
+        nodes = new HashSet<>();
+        root.val = 0;
+        nodes.add(0);
+        dfs(root);
+    }
+
+    public boolean find(int target) {
+        return nodes.contains(target);
+    }
+
+    private void dfs(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        if (root.left != null) {
+            root.left.val = root.val * 2 + 1;
+            nodes.add(root.left.val);
+        }
+        if (root.right != null) {
+            root.right.val = root.val * 2 + 2;
+            nodes.add(root.right.val);
+        }
+        dfs(root.left);
+        dfs(root.right);
+    }
+}
+
+/**
+ * Your FindElements object will be instantiated and called as such:
+ * FindElements obj = new FindElements(root);
+ * boolean param_1 = obj.find(target);
+ */
+```
+
+### **C++**
+
+```cpp
+/**
+ * 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 FindElements {
+public:
+    unordered_set<int> nodes;
+
+    FindElements(TreeNode* root) {
+        root->val = 0;
+        nodes.clear();
+        nodes.insert(0);
+        dfs(root);
+    }
+
+    bool find(int target) {
+        return nodes.count(target);
+    }
+
+    void dfs(TreeNode* root) {
+        if (!root) return;
+        if (root->left)
+        {
+            root->left->val = root->val * 2 + 1;
+            nodes.insert(root->left->val);
+        }
+        if (root->right)
+        {
+            root->right->val = root->val * 2 + 2;
+            nodes.insert(root->right->val);
+        }
+        dfs(root->left);
+        dfs(root->right);
+    }
+};
+
+/**
+ * Your FindElements object will be instantiated and called as such:
+ * FindElements* obj = new FindElements(root);
+ * bool param_1 = obj->find(target);
+ */
+```
 
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+type FindElements struct {
+	nodes map[int]bool
+}
+
+func Constructor(root *TreeNode) FindElements {
+	root.Val = 0
+	nodes := make(map[int]bool)
+	nodes[0] = true
+	var dfs func(root *TreeNode)
+	dfs = func(root *TreeNode) {
+		if root == nil {
+			return
+		}
+		if root.Left != nil {
+			root.Left.Val = root.Val*2 + 1
+			nodes[root.Left.Val] = true
+		}
+		if root.Right != nil {
+			root.Right.Val = root.Val*2 + 2
+			nodes[root.Right.Val] = true
+		}
+		dfs(root.Left)
+		dfs(root.Right)
+	}
+	dfs(root)
+	return FindElements{nodes}
+}
+
+func (this *FindElements) Find(target int) bool {
+	return this.nodes[target]
+}
+
+/**
+ * Your FindElements object will be instantiated and called as such:
+ * obj := Constructor(root);
+ * param_1 := obj.Find(target);
+ */
 ```
 
 ### **...**