add 1373

Author: fishercoder1534

README.md

@@ -8,6 +8,7 @@ _If you like this project, please leave me a star._ ★
 
 |  #  |      Title     |   Solutions   | Video  | Difficulty  | Tag                   
 |-----|----------------|---------------|--------|-------------|-------------
+|1373|[Maximum Sum BST in Binary Tree](https://leetcode.com/problems/maximum-sum-bst-in-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1373.java) | |Hard||DP, BST
 |1371|[Find the Longest Substring Containing Vowels in Even Counts](https://leetcode.com/problems/find-the-longest-substring-containing-vowels-in-even-counts/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1371.java) | |Medium||String
 |1370|[Increasing Decreasing String](https://leetcode.com/problems/increasing-decreasing-string/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1370.java) | |Easy||String, Sort
 |1367|[Linked List in Binary Tree](https://leetcode.com/problems/linked-list-in-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1367.java) | |Medium||DP, Linked List, Tree

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

@@ -0,0 +1,72 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+/**
+ * 1373. Maximum Sum BST in Binary Tree
+ *
+ * Given a binary tree root, the task is to return the maximum sum of all keys of any sub-tree which is also a Binary Search Tree (BST).
+ * Assume a BST is defined as follows:
+ * 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:
+ * Input: root = [1,4,3,2,4,2,5,null,null,null,null,null,null,4,6]
+ * Output: 20
+ * Explanation: Maximum sum in a valid Binary search tree is obtained in root node with key equal to 3.
+ *
+ * Example 2:
+ * Input: root = [4,3,null,1,2]
+ * Output: 2
+ * Explanation: Maximum sum in a valid Binary search tree is obtained in a single root node with key equal to 2.
+ *
+ * Example 3:
+ * Input: root = [-4,-2,-5]
+ * Output: 0
+ * Explanation: All values are negatives. Return an empty BST.
+ *
+ * Example 4:
+ * Input: root = [2,1,3]
+ * Output: 6
+ *
+ * Example 5:
+ * Input: root = [5,4,8,3,null,6,3]
+ * Output: 7
+ *
+ * Constraints:
+ * Each tree has at most 40000 nodes..
+ * Each node's value is between [-4 * 10^4 , 4 * 10^4].
+ * */
+public class _1373 {
+    public static class Solution1 {
+        /**
+         * credit: https://leetcode.com/problems/maximum-sum-bst-in-binary-tree/discuss/532021/Java-Post-Order
+         * */
+        public int maxSumBST(TreeNode root) {
+            return postOrder(root)[4];
+        }
+
+        /**
+         * result[0] means this tree is a BST
+         * result[1] means the sum of this tree
+         * result[2] means the left boundary
+         * result[3] means the right boundary
+         * result[4] means the global max sum
+         * */
+        private int[] postOrder(TreeNode root) {
+            if (root == null) {
+                return new int[]{1, 0, Integer.MAX_VALUE, Integer.MIN_VALUE, 0};
+            }
+            int[] leftSide = postOrder(root.left);
+            int[] rightSide = postOrder(root.right);
+            int localMax = Math.max(leftSide[4], rightSide[4]);
+            if (leftSide[0] == 1 && rightSide[0] == 1 && root.val > leftSide[3] && root.val < rightSide[2]) {
+                int sum = root.val + leftSide[1] + rightSide[1];
+                return new int[]{1, sum, leftSide[2] == Integer.MAX_VALUE ? root.val : leftSide[2], rightSide[3] == Integer.MIN_VALUE ? root.val : rightSide[3], Math.max(localMax, sum)};
+            } else {
+                return new int[]{0, 0, 0, 0, localMax};
+            }
+        }
+    }
+}

src/test/java/com/fishercoder/_1373Test.java

@@ -0,0 +1,64 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._1373;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class _1373Test {
+    private static _1373.Solution1 solution1;
+    private static TreeNode root;
+
+    @Test
+    public void test1() {
+        solution1 = new _1373.Solution1();
+        root = TreeUtils.constructBinaryTree(Arrays.asList(2, 1, 3));
+        TreeUtils.printBinaryTree(root);
+        assertEquals(6, solution1.maxSumBST(root));
+    }
+
+    @Test
+    public void test2() {
+        solution1 = new _1373.Solution1();
+        root = TreeUtils.constructBinaryTree(Arrays.asList(5, 4, 8, 3, null, 6, 3));
+        TreeUtils.printBinaryTree(root);
+        assertEquals(7, solution1.maxSumBST(root));
+    }
+
+    @Test
+    public void test3() {
+        solution1 = new _1373.Solution1();
+        root = TreeUtils.constructBinaryTree(Arrays.asList(-4, -2, -5));
+        TreeUtils.printBinaryTree(root);
+        assertEquals(0, solution1.maxSumBST(root));
+    }
+
+    @Test
+    public void test4() {
+        solution1 = new _1373.Solution1();
+        root = TreeUtils.constructBinaryTree(Arrays.asList(4, 3, null, 1, 2));
+        TreeUtils.printBinaryTree(root);
+        assertEquals(2, solution1.maxSumBST(root));
+    }
+
+    @Test
+    public void test5() {
+        solution1 = new _1373.Solution1();
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1, 4, 3, 2, 4, 2, 5, null, null, null, null, null, null, 4, 6));
+        TreeUtils.printBinaryTree(root);
+        assertEquals(20, solution1.maxSumBST(root));
+    }
+
+    @Test
+    public void test6() {
+        solution1 = new _1373.Solution1();
+        root = TreeUtils.constructBinaryTree(Arrays.asList(4, 8, null, 6, 1, 9, null, -5, 4, null, null, null, -3, null, 10));
+        TreeUtils.printBinaryTree(root);
+        assertEquals(14, solution1.maxSumBST(root));
+    }
+
+}