add 1660

Author: fishercoder1534

Diff for: paginated_contents/algorithms/2nd_thousand/README.md

@@ -147,6 +147,7 @@
 | 1664 | [Ways to Make a Fair Array](https://leetcode.com/problems/ways-to-make-a-fair-array/)                                                                                                        | [Javascript](./javascript/_1664.js)                                                                                                                                                                                         || Medium                                              | Greedy                           |
 | 1663 | [Smallest String With A Given Numeric Value](https://leetcode.com/problems/smallest-string-with-a-given-numeric-value/)                                                                      | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1663.java)                                                                                       | [:tv:](https://youtu.be/o3MRJfsoUrw)                | Medium                           | Greedy                                                               |
 | 1662 | [Check If Two String Arrays are Equivalent](https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent/)                                                                        | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1662.java)                                                                                       || Easy                                                | String                           |
+| 1660 | [Correct a Binary Tree](https://leetcode.com/problems/correct-a-binary-tree/)                                                                              | [Javascript](./javascript/_1658.js), [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1660.java)                                                      || Medium                                              | BFS, Tree                        |
 | 1658 | [Minimum Operations to Reduce X to Zero](https://leetcode.com/problems/minimum-operations-to-reduce-x-to-zero/)                                                                              | [Javascript](./javascript/_1658.js), [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1658.java)                                                      || Medium                                              | Greedy                           |
 | 1657 | [Determine if Two Strings Are Close](https://leetcode.com/problems/determine-if-two-strings-are-close/)                                                                                      | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1657.java)                                                                                       | [:tv:](https://youtu.be/-jXQK-UeChU)                | Medium                           | Greedy                                                               |
 | 1656 | [Design an Ordered Stream](https://leetcode.com/problems/design-an-ordered-stream/)                                                                                                          | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/secondthousand/_1656.java)                                                                                       || Easy                                                | Array, Design                    |

Diff for: src/main/java/com/fishercoder/solutions/secondthousand/_1660.java

@@ -0,0 +1,50 @@
+package com.fishercoder.solutions.secondthousand;
+
+import com.fishercoder.common.classes.TreeNode;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Set;
+
+public class _1660 {
+    public static class Solution1 {
+        /**
+         * First off, this problem description is confusing.
+         * Second, that aside, I learned a cool technique to pass TreeNode[]{node, nodeParent} into the queue
+         * so that you can easily reference one node's parent without building an additional hashmap.
+         * Third, there's no easy way to write unit tests for this problem...
+         */
+        public TreeNode correctBinaryTree(TreeNode root) {
+            Queue<TreeNode[]> q = new LinkedList<>();
+            q.offer(new TreeNode[]{root, null});
+            Set<Integer> visited = new HashSet<>();
+            visited.add(root.val);
+            while (!q.isEmpty()) {
+                int size = q.size();
+                for (int i = 0; i < size; i++) {
+                    TreeNode[] curr = q.poll();
+                    TreeNode node = curr[0];
+                    TreeNode nodeParent = curr[1];
+                    if (node.right != null && visited.contains(node.right.val)) {
+                        if (nodeParent.left == node) {
+                            nodeParent.left = null;
+                        } else {
+                            nodeParent.right = null;
+                        }
+                        return root;
+                    }
+                    if (node.left != null) {
+                        q.offer(new TreeNode[]{node.left, node});
+                        visited.add(node.left.val);
+                    }
+                    if (node.right != null) {
+                        q.offer(new TreeNode[]{node.right, node});
+                        visited.add(node.right.val);
+                    }
+                }
+            }
+            return root;
+        }
+    }
+}