From 54f6eb75ed668995bc95f46c0367e8d80b68955f Mon Sep 17 00:00:00 2001 From: yanglbme Date: Sun, 16 Jan 2022 10:12:17 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.1261 No.1261.Find Elements in a Contaminated Binary Tree --- .../README.md | 187 +++++++++++++++++- .../README_EN.md | 185 +++++++++++++++++ .../Solution.cpp | 48 +++++ .../Solution.go | 45 +++++ .../Solution.java | 51 +++++ .../Solution.py | 33 ++++ 6 files changed, 548 insertions(+), 1 deletion(-) create mode 100644 solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.cpp create mode 100644 solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.go create mode 100644 solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.java create mode 100644 solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.py diff --git a/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/README.md b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/README.md index f4bf9be19fff4..1f52f43e2afca 100644 --- a/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/README.md +++ b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/README.md @@ -94,7 +94,39 @@ 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** @@ -102,7 +134,160 @@ findElements.find(5); // return True ```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 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 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); + */ ``` ### **...** diff --git a/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/README_EN.md b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/README_EN.md index 8df6183235348..d8c3306180031 100644 --- a/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/README_EN.md +++ b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/README_EN.md @@ -89,13 +89,198 @@ findElements.find(5); // return True ### **Python3** ```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 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 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); + */ ``` ### **...** diff --git a/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.cpp b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.cpp new file mode 100644 index 0000000000000..b644b3949815d --- /dev/null +++ b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.cpp @@ -0,0 +1,48 @@ +/** + * 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 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); + */ \ No newline at end of file diff --git a/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.go b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.go new file mode 100644 index 0000000000000..839cbdecf819f --- /dev/null +++ b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.go @@ -0,0 +1,45 @@ +/** + * 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); + */ \ No newline at end of file diff --git a/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.java b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.java new file mode 100644 index 0000000000000..077a86f133197 --- /dev/null +++ b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.java @@ -0,0 +1,51 @@ +/** + * 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 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); + */ \ No newline at end of file diff --git a/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.py b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.py new file mode 100644 index 0000000000000..d142818b795b5 --- /dev/null +++ b/solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.py @@ -0,0 +1,33 @@ +# 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)