Sync LeetCode submission Runtime - 0 ms (100.00%), Memory - 19.5 MB (47.25%)

Author: jimit105

0333-largest-bst-subtree/README.md

@@ -0,0 +1,38 @@
+<p>Given the root of a binary tree, find the largest <span data-keyword="subtree">subtree</span>, which is also a Binary Search Tree (BST), where the largest means subtree has the largest number of nodes.</p>
+
+<p>A <strong>Binary Search Tree (BST)</strong> is a tree in which all the nodes follow the below-mentioned properties:</p>
+
+<ul>
+	<li>The left subtree values are less than the value of their parent (root) node&#39;s value.</li>
+	<li>The right subtree values are greater than the value of their parent (root) node&#39;s value.</li>
+</ul>
+
+<p><strong>Note:</strong> A subtree must include all of its descendants.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/10/17/tmp.jpg" style="width: 571px; height: 302px;" /></strong></p>
+
+<pre>
+<strong>Input:</strong> root = [10,5,15,1,8,null,7]
+<strong>Output:</strong> 3
+<strong>Explanation: </strong>The Largest BST Subtree in this case is the highlighted one. The return value is the subtree&#39;s size, which is 3.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [4,2,7,2,3,5,null,2,null,null,null,null,null,1]
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>4</sup> &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Can you figure out ways to solve it with <code>O(n)</code> time complexity?</p>

0333-largest-bst-subtree/solution.py

@@ -0,0 +1,44 @@
+class Solution:
+    def is_valid_bst(self, root: Optional[TreeNode]) -> bool:
+        """Check if given tree is a valid BST using in-order traversal."""
+        # An empty tree is a valid Binary Search Tree.
+        if not root:
+            return True
+        
+        # If left subtree is not a valid BST return false.
+        if not self.is_valid_bst(root.left):
+            return False
+
+        # If current node's value is not greater than the previous 
+        # node's value in the in-order traversal return false.
+        if self.previous and self.previous.val >= root.val:
+            return False
+
+        # Update previous node to current node.
+        self.previous = root
+
+        # If right subtree is not a valid BST return false.
+        return self.is_valid_bst(root.right)
+
+    # Count nodes in current tree.
+    def count_nodes(self, root: Optional[TreeNode]) -> int:
+        if not root: 
+            return 0
+
+        # Add nodes in left and right subtree.
+        # Add 1 and return total size.
+        return 1 + self.count_nodes(root.left) + self.count_nodes(root.right)
+        
+    def largestBSTSubtree(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+        
+        # Previous node is initially null.
+        self.previous = None
+
+        # If current subtree is a validBST, its children will have smaller size BST.
+        if self.is_valid_bst(root):
+            return self.count_nodes(root)
+        
+        # Find BST in left and right subtrees of current nodes.
+        return max(self.largestBSTSubtree(root.left), self.largestBSTSubtree(root.right))