Apr-04

Author: geemaple

README.md

@@ -0,0 +1,87 @@
+//  Tag: Hash Table, Tree, Depth-First Search, Breadth-First Search, Binary Tree
+//  Time: O(N)
+//  Space: O(N)
+//  Ref: Leetcode-865
+//  Note: -
+//  Video: https://youtu.be/FdSQ1jfDzd0
+
+//  Given the root of a binary tree, return the lowest common ancestor of its deepest leaves.
+//  Recall that:
+//  
+//  The node of a binary tree is a leaf if and only if it has no children
+//  The depth of the root of the tree is 0. if the depth of a node is d, the depth of each of its children is d + 1.
+//  The lowest common ancestor of a set S of nodes, is the node A with the largest depth such that every node in S is in the subtree with root A.
+//  
+//   
+//  Example 1:
+//  
+//  
+//  Input: root = [3,5,1,6,2,0,8,null,null,7,4]
+//  Output: [2,7,4]
+//  Explanation: We return the node with value 2, colored in yellow in the diagram.
+//  The nodes coloured in blue are the deepest leaf-nodes of the tree.
+//  Note that nodes 6, 0, and 8 are also leaf nodes, but the depth of them is 2, but the depth of nodes 7 and 4 is 3.
+//  Example 2:
+//  
+//  Input: root = [1]
+//  Output: [1]
+//  Explanation: The root is the deepest node in the tree, and it's the lca of itself.
+//  
+//  Example 3:
+//  
+//  Input: root = [0,1,3,null,2]
+//  Output: [2]
+//  Explanation: The deepest leaf node in the tree is 2, the lca of one node is itself.
+//  
+//   
+//  Constraints:
+//  
+//  The number of nodes in the tree will be in the range [1, 1000].
+//  0 <= Node.val <= 1000
+//  The values of the nodes in the tree are unique.
+//  
+//   
+//  Note: This question is the same as 865: https://leetcode.com/problems/smallest-subtree-with-all-the-deepest-nodes/
+//  
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* lcaDeepestLeaves(TreeNode* root) {
+        return lca(root, 0).first;
+    }
+
+    pair<TreeNode *, int> lca(TreeNode *node, int depth) {
+        if (!node->left && !node->right) {
+            return make_pair(node, depth);
+        }
+
+        if (!node->left) {
+            return lca(node->right, depth + 1);
+        }
+
+        if (!node->right) {
+            return lca(node->left, depth + 1);
+        }
+        
+        pair<TreeNode *, int> l = lca(node->left, depth + 1);
+        pair<TreeNode *, int> r = lca(node->right, depth + 1);
+        if (l.second == r.second) {
+            return make_pair(node, l.second);
+        } else if (l.second < r.second) {
+            return r;
+        } else {
+            return l;
+        }
+    }
+};

leetcode/1123.lowest-common-ancestor-of-deepest-leaves.cpp

@@ -0,0 +1,75 @@
+#  Tag: Hash Table, Tree, Depth-First Search, Breadth-First Search, Binary Tree
+#  Time: O(N)
+#  Space: O(N)
+#  Ref: Leetcode-865
+#  Note: -
+#  Video: https://youtu.be/FdSQ1jfDzd0
+
+#  Given the root of a binary tree, return the lowest common ancestor of its deepest leaves.
+#  Recall that:
+#  
+#  The node of a binary tree is a leaf if and only if it has no children
+#  The depth of the root of the tree is 0. if the depth of a node is d, the depth of each of its children is d + 1.
+#  The lowest common ancestor of a set S of nodes, is the node A with the largest depth such that every node in S is in the subtree with root A.
+#  
+#   
+#  Example 1:
+#  
+#  
+#  Input: root = [3,5,1,6,2,0,8,null,null,7,4]
+#  Output: [2,7,4]
+#  Explanation: We return the node with value 2, colored in yellow in the diagram.
+#  The nodes coloured in blue are the deepest leaf-nodes of the tree.
+#  Note that nodes 6, 0, and 8 are also leaf nodes, but the depth of them is 2, but the depth of nodes 7 and 4 is 3.
+#  Example 2:
+#  
+#  Input: root = [1]
+#  Output: [1]
+#  Explanation: The root is the deepest node in the tree, and it's the lca of itself.
+#  
+#  Example 3:
+#  
+#  Input: root = [0,1,3,null,2]
+#  Output: [2]
+#  Explanation: The deepest leaf node in the tree is 2, the lca of one node is itself.
+#  
+#   
+#  Constraints:
+#  
+#  The number of nodes in the tree will be in the range [1, 1000].
+#  0 <= Node.val <= 1000
+#  The values of the nodes in the tree are unique.
+#  
+#   
+#  Note: This question is the same as 865: https://leetcode.com/problems/smallest-subtree-with-all-the-deepest-nodes/
+#  
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def lcaDeepestLeaves(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        return self.lca(root, 0)[0]
+
+    def lca(self, node: TreeNode, depth: int) -> Tuple:
+        if node.left is None and node.right is None:
+            return (node, depth)
+
+        if node.left is None:
+            return self.lca(node.right, depth + 1)
+        
+        if node.right is None:
+            return self.lca(node.left, depth + 1)
+
+        n1, d1 = self.lca(node.left, depth + 1)
+        n2, d2 = self.lca(node.right, depth + 1)
+
+        if d1 == d2:
+            return (node, d1)
+        elif d1 < d2:
+            return (n2, d2)
+        else:
+            return (n1, d1)

leetcode/1123.lowest-common-ancestor-of-deepest-leaves.py

@@ -0,0 +1,68 @@
+//  Tag: Array, Dynamic Programming, Greedy, Line Sweep
+//  Time: O(N)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+
+//  There is a one-dimensional garden on the x-axis. The garden starts at the point 0 and ends at the point n. (i.e., the length of the garden is n).
+//  There are n + 1 taps located at points [0, 1, ..., n] in the garden.
+//  Given an integer n and an integer array ranges of length n + 1 where ranges[i] (0-indexed) means the i-th tap can water the area [i - ranges[i], i + ranges[i]] if it was open.
+//  Return the minimum number of taps that should be open to water the whole garden, If the garden cannot be watered return -1.
+//   
+//  Example 1:
+//  
+//  
+//  Input: n = 5, ranges = [3,4,1,1,0,0]
+//  Output: 1
+//  Explanation: The tap at point 0 can cover the interval [-3,3]
+//  The tap at point 1 can cover the interval [-3,5]
+//  The tap at point 2 can cover the interval [1,3]
+//  The tap at point 3 can cover the interval [2,4]
+//  The tap at point 4 can cover the interval [4,4]
+//  The tap at point 5 can cover the interval [5,5]
+//  Opening Only the second tap will water the whole garden [0,5]
+//  
+//  Example 2:
+//  
+//  Input: n = 3, ranges = [0,0,0,0]
+//  Output: -1
+//  Explanation: Even if you activate all the four taps you cannot water the whole garden.
+//  
+//   
+//  Constraints:
+//  
+//  1 <= n <= 104
+//  ranges.length == n + 1
+//  0 <= ranges[i] <= 100
+//  
+//  
+
+class Solution {
+public:
+    int minTaps(int n, vector<int>& ranges) {
+        vector<int> line(n + 1, 0);
+        for (int i = 0; i < ranges.size(); i++) {
+            int start = max(0, i - ranges[i]);
+            int end = min(n, i + ranges[i]);
+            line[start] = max(line[start], end);
+        }
+
+        int cur = 0;
+        int right = 0;
+        int i = 0;
+        int res = 0;
+        while (cur < n) {
+            res += 1;
+            while (i < line.size() && i <= cur) {
+                right = max(right, line[i]);
+                i += 1;
+            }
+            if (cur >= right) {
+                return -1;
+            }
+            cur = right;
+        }
+
+        return res;
+    }
+};

leetcode/1326.minimum-number-of-taps-to-open-to-water-a-garden.cpp

@@ -0,0 +1,63 @@
+#  Tag: Array, Dynamic Programming, Greedy, Line Sweep
+#  Time: O(N)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+
+#  There is a one-dimensional garden on the x-axis. The garden starts at the point 0 and ends at the point n. (i.e., the length of the garden is n).
+#  There are n + 1 taps located at points [0, 1, ..., n] in the garden.
+#  Given an integer n and an integer array ranges of length n + 1 where ranges[i] (0-indexed) means the i-th tap can water the area [i - ranges[i], i + ranges[i]] if it was open.
+#  Return the minimum number of taps that should be open to water the whole garden, If the garden cannot be watered return -1.
+#   
+#  Example 1:
+#  
+#  
+#  Input: n = 5, ranges = [3,4,1,1,0,0]
+#  Output: 1
+#  Explanation: The tap at point 0 can cover the interval [-3,3]
+#  The tap at point 1 can cover the interval [-3,5]
+#  The tap at point 2 can cover the interval [1,3]
+#  The tap at point 3 can cover the interval [2,4]
+#  The tap at point 4 can cover the interval [4,4]
+#  The tap at point 5 can cover the interval [5,5]
+#  Opening Only the second tap will water the whole garden [0,5]
+#  
+#  Example 2:
+#  
+#  Input: n = 3, ranges = [0,0,0,0]
+#  Output: -1
+#  Explanation: Even if you activate all the four taps you cannot water the whole garden.
+#  
+#   
+#  Constraints:
+#  
+#  1 <= n <= 104
+#  ranges.length == n + 1
+#  0 <= ranges[i] <= 100
+#  
+#  
+
+class Solution:
+    def minTaps(self, n: int, ranges: List[int]) -> int:
+        line = [0 for i in range(n + 1)]
+        for i in range(len(ranges)):
+            start = max(0, i - ranges[i])
+            end = min(n, i + ranges[i])
+            line[start] = max(line[start], end)
+
+        cur = 0
+        res = 0
+        right = 0
+        i = 0
+        while cur < n:
+            res += 1
+            while i <= n and i <= cur:
+                right = max(right, line[i])
+                i += 1
+
+            if (cur == right):
+                return -1
+
+            cur = right
+
+        return res

leetcode/1326.minimum-number-of-taps-to-open-to-water-a-garden.py

@@ -0,0 +1,77 @@
+//  Tag: Hash Table, Tree, Depth-First Search, Breadth-First Search, Binary Tree
+//  Time: O(N)
+//  Space: O(N)
+//  Ref: Leetcode-1123
+//  Note: -
+//  Video: https://youtu.be/FdSQ1jfDzd0
+
+//  Given the root of a binary tree, the depth of each node is the shortest distance to the root.
+//  Return the smallest subtree such that it contains all the deepest nodes in the original tree.
+//  A node is called the deepest if it has the largest depth possible among any node in the entire tree.
+//  The subtree of a node is a tree consisting of that node, plus the set of all descendants of that node.
+//   
+//  Example 1:
+//  
+//  
+//  Input: root = [3,5,1,6,2,0,8,null,null,7,4]
+//  Output: [2,7,4]
+//  Explanation: We return the node with value 2, colored in yellow in the diagram.
+//  The nodes coloured in blue are the deepest nodes of the tree.
+//  Notice that nodes 5, 3 and 2 contain the deepest nodes in the tree but node 2 is the smallest subtree among them, so we return it.
+//  
+//  Example 2:
+//  
+//  Input: root = [1]
+//  Output: [1]
+//  Explanation: The root is the deepest node in the tree.
+//  
+//  Example 3:
+//  
+//  Input: root = [0,1,3,null,2]
+//  Output: [2]
+//  Explanation: The deepest node in the tree is 2, the valid subtrees are the subtrees of nodes 2, 1 and 0 but the subtree of node 2 is the smallest.
+//  
+//   
+//  Constraints:
+//  
+//  The number of nodes in the tree will be in the range [1, 500].
+//  0 <= Node.val <= 500
+//  The values of the nodes in the tree are unique.
+//  
+//   
+//  Note: This question is the same as 1123: https://leetcode.com/problems/lowest-common-ancestor-of-deepest-leaves/
+//  
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* subtreeWithAllDeepest(TreeNode* root) {
+        return lca(root).first;
+    }
+
+    pair<TreeNode *, int> lca(TreeNode *node) {
+        if (!node) {
+            return make_pair(node, 0);
+        }
+
+        pair<TreeNode *, int> l = lca(node->left);
+        pair<TreeNode *, int> r = lca(node->right);
+        if (l.second == r.second) {
+            return make_pair(node, l.second + 1);
+        } else if (l.second < r.second) {
+            return make_pair(r.first, r.second + 1);
+        } else {
+            return make_pair(l.first, l.second + 1);
+        }
+    }
+};