add 993

fishercoder1534 · fishercoder1534 · commit a9592ed914fd · 2019-02-17T15:20:06.000-08:00
diff --git a/README.md b/README.md
@@ -29,6 +29,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Video  | Difficulty  | Tag                   
 |-----|----------------|---------------|---------------|---------------|--------|-------------|-------------
+|993|[Cousins in Binary Tree](https://leetcode.com/problems/cousins-in-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_993.java) | O(n) | O(m) (m is length of the nodes that has the max number of nodes on the same level) | |Easy| Tree, BFS
 |989|[Add to Array-Form of Integer](https://leetcode.com/problems/add-to-array-form-of-integer/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_989.java) | O(max(N, logk)) | O(max(N, logk)) | |Easy| Array
 |985|[Sum of Even Numbers After Queries](https://leetcode.com/problems/sum-of-even-numbers-after-queries/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_985.java) | O(n) | O(n) | |Easy| Array
 |977|[Squares of a Sorted Array](https://leetcode.com/problems/squares-of-a-sorted-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_977.java) | O(nlogn) | O(1) | |Easy| Array
diff --git a/src/main/java/com/fishercoder/solutions/_993.java b/src/main/java/com/fishercoder/solutions/_993.java
@@ -0,0 +1,91 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Set;
+
+/**
+ * 993. Cousins in Binary Tree
+ *
+ * In a binary tree, the root node is at depth 0, and children of each depth k node are at depth k+1.
+ * Two nodes of a binary tree are cousins if they have the same depth, but have different parents.
+ * We are given the root of a binary tree with unique values, and the values x and y of two different nodes in the tree.
+ * Return true if and only if the nodes corresponding to the values x and y are cousins.
+ *
+ * Example 1:
+ *        1
+ *       / \
+ *      2   3
+ *     /
+ *    4
+ *
+ * Input: root = [1,2,3,4], x = 4, y = 3
+ * Output: false
+ *
+ * Example 2:
+ *         1
+ *        / \
+ *       2   3
+ *       \    \
+ *       4    5
+ *
+ * Input: root = [1,2,3,null,4,null,5], x = 5, y = 4
+ * Output: true
+ *
+ * Example 3:
+ *          1
+ *         / \
+ *        2  3
+ *        \
+ *        4
+ *
+ * Input: root = [1,2,3,null,4], x = 2, y = 3
+ * Output: false
+ *
+ *
+ * Note:
+ *
+ * The number of nodes in the tree will be between 2 and 100.
+ * Each node has a unique integer value from 1 to 100.
+ */
+public class _993 {
+  public static class Solution1 {
+    public boolean isCousins(TreeNode root, int x, int y) {
+      Queue<TreeNode> queue = new LinkedList<>();
+      queue.offer(root);
+      while (!queue.isEmpty()) {
+        int size = queue.size();
+        for (int i = 0; i < size; i++) {
+          TreeNode current = queue.poll();
+          if (current.left != null) {
+            queue.offer(current.left);
+          }
+          if (current.right != null) {
+            queue.offer(current.right);
+          }
+          if (current.left != null && current.right != null) {
+            if (current.left.val == x && current.right.val == y
+                || current.left.val == y && current.right.val == x) {
+              return false;
+            }
+          }
+        }
+        if (checkQueue(queue, x, y)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    private boolean checkQueue(Queue<TreeNode> queue, int x, int y) {
+      Set<Integer> set = new HashSet<>();
+      Queue<TreeNode> tmp = new LinkedList<>(queue);
+      while (!tmp.isEmpty()) {
+        set.add(tmp.poll().val);
+      }
+      return set.contains(x) && set.contains(y);
+    }
+  }
+}
diff --git a/src/test/java/com/fishercoder/_993Test.java b/src/test/java/com/fishercoder/_993Test.java
@@ -0,0 +1,43 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._703;
+import com.fishercoder.solutions._976;
+import com.fishercoder.solutions._993;
+import java.util.Arrays;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.Assert.assertEquals;
+
+public class _993Test {
+  private static _993.Solution1 solution1;
+  private static TreeNode root;
+
+  @BeforeClass
+  public static void setUp() {
+    solution1 = new _993.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    root = TreeUtils.constructBinaryTree(Arrays.asList(1, 2, 3, 4));
+    TreeUtils.printBinaryTree(root);
+    assertEquals(false, solution1.isCousins(root, 4, 3));
+  }
+
+  @Test
+  public void test2() {
+    root = TreeUtils.constructBinaryTree(Arrays.asList(1, 2, 3, null, 4, null, 5));
+    TreeUtils.printBinaryTree(root);
+    assertEquals(true, solution1.isCousins(root, 5, 4));
+  }
+
+  @Test
+  public void test3() {
+    root = TreeUtils.constructBinaryTree(Arrays.asList(1, 2, 3, null, 4));
+    TreeUtils.printBinaryTree(root);
+    assertEquals(false, solution1.isCousins(root, 2, 3));
+  }
+}
