add 1261

Author: fishercoder1534

README.md

@@ -37,6 +37,7 @@ _If you like this project, please leave me a star._ ★
 |1271|[Hexspeak](https://leetcode.com/problems/hexspeak/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1271.java) |   |Easy||
 |1267|[Count Servers that Communicate](https://leetcode.com/problems/count-servers-that-communicate/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1267.java) |   |Medium||
 |1266|[Minimum Time Visiting All Points](https://leetcode.com/problems/minimum-time-visiting-all-points/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1266.java) |   |Easy||
+|1261|[Find Elements in a Contaminated Binary Tree](https://leetcode.com/problems/find-elements-in-a-contaminated-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1261.java) ||Medium|Tree, HashTable|
 |1260|[Shift 2D Grid](https://leetcode.com/problems/shift-2d-grid/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1260.java) | [:tv:](https://www.youtube.com/watch?v=9hBcARSiU0s)|Easy||
 |1252|[Cells with Odd Values in a Matrix](https://leetcode.com/problems/cells-with-odd-values-in-a-matrix/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1252.java) |  |Easy||
 |1237|[Find Positive Integer Solution for a Given Equation](https://leetcode.com/problems/find-positive-integer-solution-for-a-given-equation/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1237.java) | |Easy||

src/main/java/com/fishercoder/solutions/_1261.java

@@ -0,0 +1,101 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+/**
+ * 1261. Find Elements in a Contaminated Binary Tree
+ *
+ * Given a binary tree with the following rules:
+ * root.val == 0
+ * If treeNode.val == x and treeNode.left != null, then treeNode.left.val == 2 * x + 1
+ * If treeNode.val == x and treeNode.right != null, then treeNode.right.val == 2 * x + 2
+ * Now the binary tree is contaminated, which means all treeNode.val have been changed to -1.
+ *
+ * You need to first recover the binary tree and then implement the FindElements class:
+ * FindElements(TreeNode* root) Initializes the object with a contamined binary tree, you need to recover it first.
+ * bool find(int target) Return if the target value exists in the recovered binary tree.
+ *
+ * Example 1:
+ * Input
+ * ["FindElements","find","find"]
+ * [[[-1,null,-1]],[1],[2]]
+ * Output
+ * [null,false,true]
+ * Explanation
+ * FindElements findElements = new FindElements([-1,null,-1]);
+ * findElements.find(1); // return False
+ * findElements.find(2); // return True
+ *
+ * Example 2:
+ * Input
+ * ["FindElements","find","find","find"]
+ * [[[-1,-1,-1,-1,-1]],[1],[3],[5]]
+ * Output
+ * [null,true,true,false]
+ * Explanation
+ * FindElements findElements = new FindElements([-1,-1,-1,-1,-1]);
+ * findElements.find(1); // return True
+ * findElements.find(3); // return True
+ * findElements.find(5); // return False
+ *
+ * Example 3:
+ * Input
+ * ["FindElements","find","find","find","find"]
+ * [[[-1,null,-1,-1,null,-1]],[2],[3],[4],[5]]
+ * Output
+ * [null,true,false,false,true]
+ * Explanation
+ * FindElements findElements = new FindElements([-1,null,-1,-1,null,-1]);
+ * findElements.find(2); // return True
+ * findElements.find(3); // return False
+ * findElements.find(4); // return False
+ * findElements.find(5); // return True
+ *
+ * Constraints:
+ * TreeNode.val == -1
+ * The height of the binary tree is less than or equal to 20
+ * The total number of nodes is between [1, 10^4]
+ * Total calls of find() is between [1, 10^4]
+ * 0 <= target <= 10^6
+ * */
+public class _1261 {
+    public static class Solution1 {
+        class FindElements {
+
+            TreeNode recoveredRoot;
+
+            public FindElements(TreeNode root) {
+                recoveredRoot = new TreeNode(0);
+                recoveredRoot = recoverTree(root, recoveredRoot);
+            }
+
+            private TreeNode recoverTree(TreeNode root, TreeNode recoveredRoot) {
+                if (root == null) {
+                    return recoveredRoot;
+                }
+                if (root.left != null) {
+                    recoveredRoot.left = new TreeNode(recoveredRoot.val * 2 + 1);
+                }
+                if (root.right != null) {
+                    recoveredRoot.right = new TreeNode(recoveredRoot.val * 2 + 2);
+                }
+                recoverTree(root.left, recoveredRoot.left);
+                recoverTree(root.right, recoveredRoot.right);
+                return recoveredRoot;
+            }
+
+            public boolean find(int target) {
+                return find(recoveredRoot, target);
+            }
+
+            private boolean find(TreeNode root, int target) {
+                if (root == null) {
+                    return false;
+                } else if (root.val == target) {
+                    return true;
+                }
+                return find(root.left, target) || find(root.right, target);
+            }
+        }
+    }
+}