add 979

fishercoder1534 · fishercoder1534 · commit 7e281d9b23be · 2019-05-29T08:06:37.000-07:00
diff --git a/README.md b/README.md
@@ -50,6 +50,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |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
+|979|[Distribute Coins in Binary Tree](https://leetcode.com/problems/distribute-coins-in-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_979.java) | O(n) | O(1) | |Medium| Recursion
 |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
 |976|[Largest Perimeter Triangle](https://leetcode.com/problems/largest-perimeter-triangle/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_976.java) | O(nlogn) | O(1) | |Easy| Math Array 
 |974|[Subarray Sums Divisible by K](https://leetcode.com/problems/subarray-sums-divisible-by-k/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_974.java) | O(n) | O(n) | |Medium| Array|
diff --git a/src/main/java/com/fishercoder/solutions/_979.java b/src/main/java/com/fishercoder/solutions/_979.java
@@ -0,0 +1,76 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+/**
+ * 979. Distribute Coins in Binary Tree
+ *
+ * Given the root of a binary tree with N nodes, each node in the tree has node.val coins, and there are N coins total.
+ * In one move, we may choose two adjacent nodes and move one coin from one node to another.  (The move may be from parent to child, or from child to parent.)
+ * Return the number of moves required to make every node have exactly one coin.
+ *
+ * Example 1:
+ *
+ *      3
+ *     / \
+ *    0  0
+ *
+ * Input: [3,0,0]
+ * Output: 2
+ * Explanation: From the root of the tree, we move one coin to its left child, and one coin to its right child.
+ *
+ * Example 2:
+ *
+ *    0
+ *   / \
+ *  3  0
+ *
+ * Input: [0,3,0]
+ * Output: 3
+ * Explanation: From the left child of the root, we move two coins to the root [taking two moves].  Then, we move one coin from the root of the tree to the right child.
+ *
+ * Example 3:
+ *
+ *    0
+ *   / \
+ *  1  2
+ *
+ * Input: [1,0,2]
+ * Output: 2
+ *
+ * Example 4:
+ *
+ *     1
+ *    / \
+ *   0  0
+ *    \
+ *    3
+ *
+ * Input: [1,0,0,null,3]
+ * Output: 4
+ *
+ *
+ * Note:
+ * 1<= N <= 100
+ * 0 <= node.val <= N
+ * */
+public class _979 {
+    public static class Solution1 {
+        /**credit: https://leetcode.com/problems/distribute-coins-in-binary-tree/discuss/221930/JavaC%2B%2BPython-Recursive-Solution*/
+        int moves = 0;
+        public int distributeCoins(TreeNode root) {
+            dfs(root);
+            return moves;
+        }
+
+        int dfs(TreeNode root) {
+            if (root == null) {
+                return 0;
+            }
+            int left = dfs(root.left);
+            int right = dfs(root.right);
+            moves += Math.abs(left) + Math.abs(right);
+            return root.val + left + right - 1;
+        }
+    }
+}
diff --git a/src/test/java/com/fishercoder/_979Test.java b/src/test/java/com/fishercoder/_979Test.java
@@ -0,0 +1,43 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._979;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class _979Test {
+    private static _979.Solution1 solution1;
+    private static TreeNode root;
+
+    @Test
+    public void test1() {
+        solution1 = new _979.Solution1();
+        root = TreeUtils.constructBinaryTree(Arrays.asList(3, 0, 0));
+        assertEquals(2, solution1.distributeCoins(root));
+    }
+
+    @Test
+    public void test2() {
+        solution1 = new _979.Solution1();
+        root = TreeUtils.constructBinaryTree(Arrays.asList(0, 3, 0));
+        assertEquals(3, solution1.distributeCoins(root));
+    }
+
+    @Test
+    public void test3() {
+        solution1 = new _979.Solution1();
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1, 0, 2));
+        assertEquals(2, solution1.distributeCoins(root));
+    }
+
+    @Test
+    public void test4() {
+        solution1 = new _979.Solution1();
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1, 0, 0, null, 3));
+        assertEquals(4, solution1.distributeCoins(root));
+    }
+}
