add 663

Author: fishercoder1534

README.md

@@ -22,6 +22,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Difficulty  | Tag          | Notes
 |-----|----------------|---------------|---------------|---------------|-------------|--------------|-----
+|663|[Equal Tree Partition](https://leetcode.com/problems/equal-tree-partition/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_663.java) | O(n) | O(n) | Medium | Tree
 |661|[Image Smoother](https://leetcode.com/problems/image-smoother/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_661.java) | O(m*n) | O(1) | Easy | Array 
 |660|[Remove 9](https://leetcode.com/problems/remove-9/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_660.java) | O(n) | O(1) | Hard | Math
 |659|[Split Array into Consecutive Subsequences](https://leetcode.com/problems/split-array-into-consecutive-subsequences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_659.java) | O(n) | O(n) | Medium | HashMap

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

@@ -0,0 +1,91 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 663. Equal Tree Partition
+ *
+ * Given a binary tree with n nodes,
+ * your task is to check if it's possible to partition the tree to two trees which have the equal sum of values
+ * after removing exactly one edge on the original tree.
+
+ Example 1:
+ Input:
+    5
+   / \
+  10 10
+    /  \
+   2   3
+
+ Output: True
+ Explanation:
+  5
+ /
+10
+
+ Sum: 15
+
+  10
+ /  \
+2   3
+
+ Sum: 15
+
+
+ Example 2:
+ Input:
+   1
+  / \
+ 2  10
+   /  \
+  2   20
+
+ Output: False
+ Explanation: You can't split the tree into two trees with equal sum after removing exactly one edge on the tree.
+
+ Note:
+ The range of tree node value is in the range of [-100000, 100000].
+ 1 <= n <= 10000
+
+ */
+public class _663 {
+    /**
+     * The idea is that we use a map to store the sum of each node, then in the end,
+     * we check if any node has a sum that is exactly half of total sum.
+     */
+    public boolean checkEqualTree(TreeNode root) {
+        Map<TreeNode, Integer> map = new HashMap<>();
+        int totalSum = sumForEachNode(root, map);
+        if (totalSum % 2 != 0 || map.size() < 2) return false;
+        for (TreeNode key : map.keySet()) {
+            if (map.get(key) == totalSum / 2) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private int sumForEachNode(TreeNode root, Map<TreeNode, Integer> map) {
+        if (root == null) {
+            return 0;
+        }
+        if (root.left == null && root.right == null) {
+            map.put(root, root.val);
+            return root.val;
+        }
+        int leftVal = 0;
+        if (root.left != null) {
+            leftVal = sumForEachNode(root.left, map);
+        }
+        int rightVal = 0;
+        if (root.right != null) {
+            rightVal = sumForEachNode(root.right, map);
+        }
+        int val = root.val + leftVal + rightVal;
+        map.put(root, val);
+        return val;
+    }
+}

src/test/java/com/fishercoder/_663Test.java

@@ -0,0 +1,55 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._663;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class _663Test {
+    private static _663 test;
+    private static TreeNode root;
+    private static boolean expected;
+
+    @BeforeClass
+    public static void setup(){
+        test = new _663();
+    }
+
+    @Test
+    public void test1(){
+        root = TreeUtils.constructBinaryTree(Arrays.asList(5,10,10,null, null, 2,3));
+        TreeUtils.printBinaryTree(root);
+        expected = true;
+        assertEquals(expected, test.checkEqualTree(root));
+    }
+
+    @Test
+    public void test2(){
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1,2,10,null, null, 2,20));
+        TreeUtils.printBinaryTree(root);
+        expected = false;
+        assertEquals(expected, test.checkEqualTree(root));
+    }
+
+    @Test
+    public void test3(){
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1,null, 2, 2));
+        TreeUtils.printBinaryTree(root);
+        expected = false;
+        assertEquals(expected, test.checkEqualTree(root));
+    }
+
+    @Test
+    public void test4(){
+        root = TreeUtils.constructBinaryTree(Arrays.asList(0));
+        TreeUtils.printBinaryTree(root);
+        expected = false;
+        assertEquals(expected, test.checkEqualTree(root));
+    }
+
+}