add 1038

fishercoder1534 · fishercoder1534 · commit e28b4a30015d · 2019-05-27T11:10:47.000-07:00
diff --git a/README.md b/README.md
@@ -29,6 +29,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |-----|----------------|---------------|---------------|---------------|--------|-------------|-------------
 |1051|[Height Checker](https://leetcode.com/problems/height-checker/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1051.java) | O(nlogn) | O(1) | |Easy||
 |1047|[Remove All Adjacent Duplicates In String](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1047.java) | O(n) | O(1) | |Easy||
+|1038|[Binary Search Tree to Greater Sum Tree](https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1038.java) | O(n) | O(n) | |Medium|DFS, tree|
 |1037|[Valid Boomerang](https://leetcode.com/problems/valid-boomerang/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1037.java) | O(1) | O(1) | |Easy|Math|
 |1033|[Moving Stones Until Consecutive](https://leetcode.com/problems/moving-stones-until-consecutive/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1033.java) | O(1) | O(1) | |Easy|Math|
 |1030|[Matrix Cells in Distance Order](https://leetcode.com/problems/matrix-cells-in-distance-order/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1030.java) | O(R*C) | O(1) | |Easy|
diff --git a/src/main/java/com/fishercoder/solutions/_1038.java b/src/main/java/com/fishercoder/solutions/_1038.java
@@ -0,0 +1,50 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+/**
+ * 1038. Binary Search Tree to Greater Sum Tree
+ *
+ * Given the root of a binary search tree with distinct values,
+ * modify it so that every node has a new value equal to the sum of the values of the original tree that are greater than or equal to node.val.
+ * As a reminder, a binary search tree is a tree that satisfies these constraints:
+ *
+ * The left subtree of a node contains only nodes with keys less than the node's key.
+ * The right subtree of a node contains only nodes with keys greater than the node's key.
+ * Both the left and right subtrees must also be binary search trees.
+ *
+ *
+ * Example 1:
+ *                            4(30)
+ *                          /    \
+ *                       1(36)   6(21)
+ *                     /   \     /    \
+ *                 0(36)  2(35) 5(26) 7(15)
+ *                          \          \
+ *                        3(33)        8(8)
+ *
+ * Input: [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
+ * Output: [30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
+ *
+ *
+ * Note:
+ *
+ * The number of nodes in the tree is between 1 and 100.
+ * Each node will have value between 0 and 100.
+ * The given tree is a binary search tree.*/
+public class _1038 {
+    public static class Solution1 {
+        /**credit: https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/discuss/286725/JavaC%2B%2BPython-Revered-Inorder-Traversal*/
+        int greaterSum = 0;
+        public TreeNode bstToGst(TreeNode root) {
+            if (root.right != null) {
+                bstToGst(root.right);
+            }
+            greaterSum = root.val = greaterSum + root.val;
+            if (root.left != null) {
+                bstToGst(root.left);
+            }
+            return root;
+        }
+    }
+}
diff --git a/src/test/java/com/fishercoder/_1038Test.java b/src/test/java/com/fishercoder/_1038Test.java
@@ -0,0 +1,35 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._1038;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class _1038Test {
+    private static _1038.Solution1 solution1;
+    private static TreeNode root;
+    private static TreeNode expected;
+    private static TreeNode actual;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _1038.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        root = TreeUtils.constructBinaryTree(Arrays.asList(4, 1, 6, 0, 2, 5, 7, null, null, null, 3, null, null, null, 8));
+        TreeUtils.printBinaryTree(root);
+        expected = TreeUtils.constructBinaryTree(Arrays.asList(30, 36, 21, 36, 35, 26, 15, null, null, null, 33, null, null, null, 8));
+        TreeUtils.printBinaryTree(expected);
+        actual = solution1.bstToGst(root);
+        TreeUtils.printBinaryTree(actual);
+        assertEquals(expected, actual);
+    }
+
+}
