feat(python): solutions

Author: hongbo-miao

JavaScript/0387. First Unique Character in a String.js

@@ -30,8 +30,8 @@ const firstUniqChar = (s) => {
   const map = {};
 
   for (const c of s) {
-    if (map[c] == null) map[c] = 1;
-    else map[c]++;
+    if (map[c] == null) map[c] = 0;
+    map[c]++;
   }
 
   for (let i = 0; i < s.length; i++) {

Python/0101. Symmetric Tree.py

@@ -35,10 +35,11 @@ def isSymmetric(self, root: Optional[TreeNode]) -> bool:
         def isMirror(l: Optional[TreeNode], r: Optional[TreeNode]) -> bool:
             if not l and not r:
                 return True
-            if not l or not r:
+            elif not l or not r:
                 return False
-            if l.val != r.val:
+            elif l.val != r.val:
                 return False
-            return isMirror(l.left, r.right) and isMirror(l.right, r.left)
+            else:
+                return isMirror(l.left, r.right) and isMirror(l.right, r.left)
 
         return isMirror(root.left, root.right)

Python/0105. Construct Binary Tree from Preorder and Inorder Traversal.py

@@ -36,6 +36,22 @@
 #   9  20
 #     /  \
 #    15   7
+
+
+# Similar
+# 105. Construct Binary Tree from Preorder and Inorder Traversal
+# 106. Construct Binary Tree from Inorder and Postorder Traversal
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        if not preorder or not inorder:
+            return None
+        root = TreeNode(preorder[0])
+        root_idx = inorder.index(preorder[0])
+        root.left = self.buildTree(preorder[1 : root_idx + 1], inorder[:root_idx])
+        root.right = self.buildTree(preorder[root_idx + 1 :], inorder[root_idx + 1 :])
+        return root
+
+
 class Solution:
     def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
         if not preorder or not inorder:

Python/0106. Construct Binary Tree from Inorder and Postorder Traversal.py

@@ -0,0 +1,42 @@
+# Given two integer arrays inorder and postorder where inorder is the inorder traversal of a binary tree and postorder is the postorder traversal of the same tree, construct and return the binary tree.
+#
+# Example 1:
+#
+# Input: inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
+# Output: [3,9,20,null,null,15,7]
+#
+# Example 2:
+#
+# Input: inorder = [-1], postorder = [-1]
+# Output: [-1]
+#
+# Constraints:
+#
+# 1 <= inorder.length <= 3000
+# postorder.length == inorder.length
+# -3000 <= inorder[i], postorder[i] <= 3000
+# inorder and postorder consist of unique values.
+# Each value of postorder also appears in inorder.
+# inorder is guaranteed to be the inorder traversal of the tree.
+# postorder is guaranteed to be the postorder traversal of the tree.
+
+
+# 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
+
+# Similar
+# 105. Construct Binary Tree from Preorder and Inorder Traversal
+# 106. Construct Binary Tree from Inorder and Postorder Traversal
+class Solution:
+    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
+        if not inorder or not postorder:
+            return None
+        root = TreeNode(postorder[-1])
+        root_idx = inorder.index(postorder[-1])
+        root.left = self.buildTree(inorder[:root_idx], postorder[:root_idx])
+        root.right = self.buildTree(inorder[root_idx + 1 :], postorder[root_idx:-1])
+        return root

Python/0112. Path Sum.py

@@ -0,0 +1,46 @@
+# Given the root of a binary tree and an integer targetSum, return true if the tree has a root-to-leaf path such that adding up all the values along the path equals targetSum.
+# A leaf is a node with no children.
+#
+# Example 1:
+#
+# Input: root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
+# Output: true
+# Explanation: The root-to-leaf path with the target sum is shown.
+#
+# Example 2:
+#
+# Input: root = [1,2,3], targetSum = 5
+# Output: false
+# Explanation: There two root-to-leaf paths in the tree:
+# (1 --> 2): The sum is 3.
+# (1 --> 3): The sum is 4.
+# There is no root-to-leaf path with sum = 5.
+#
+# Example 3:
+#
+# Input: root = [], targetSum = 0
+# Output: false
+# Explanation: Since the tree is empty, there are no root-to-leaf paths.
+#
+# Constraints:
+#
+# The number of nodes in the tree is in the range [0, 5000].
+# -1000 <= Node.val <= 1000
+# -1000 <= targetSum <= 1000
+
+
+# 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 hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
+        if not root:
+            return False
+        if not root.left and not root.right:
+            return root.val == targetSum
+        return self.hasPathSum(root.left, targetSum - root.val) or self.hasPathSum(
+            root.right, targetSum - root.val
+        )

Python/0116. Populating Next Right Pointers in Each Node.py

@@ -62,6 +62,7 @@ def connect(self, root: "Optional[Node]") -> "Optional[Node]":
 # Similar
 # 102. Binary Tree Level Order Traversal
 # 116. Populating Next Right Pointers in Each Node
+# 117. Populating Next Right Pointers in Each Node II
 #
 # Time O(n)
 class Solution:
@@ -70,13 +71,13 @@ def connect(self, root: "Optional[Node]") -> "Optional[Node]":
             return None
 
         q = [root]
-
         while q:
             nodes = q.copy()
             q = []
             while nodes:
                 node = nodes.pop(0)
-                node.next = nodes[0] if nodes else None
+                if nodes:
+                    node.next = nodes[0]
                 if node.left:
                     q.append(node.left)
                 if node.right:

Python/0117. Populating Next Right Pointers in Each Node II.py

@@ -0,0 +1,65 @@
+# Given a binary tree
+#
+# struct Node {
+#   int val;
+#   Node *left;
+#   Node *right;
+#   Node *next;
+# }
+#
+# Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.
+#
+# Initially, all next pointers are set to NULL.
+#
+# Example 1:
+#
+# Input: root = [1,2,3,4,5,null,7]
+# Output: [1,#,2,3,#,4,5,7,#]
+# Explanation: Given the above binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.
+#
+# Example 2:
+#
+# Input: root = []
+# Output: []
+#
+# Constraints:
+#
+# The number of nodes in the tree is in the range [0, 6000].
+# -100 <= Node.val <= 100
+#
+# Follow-up:
+#
+# You may only use constant extra space.
+# The recursive approach is fine. You may assume implicit stack space does not count as extra space for this problem.
+
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
+        self.val = val
+        self.left = left
+        self.right = right
+        self.next = next
+"""
+
+# Similar
+# 116. Populating Next Right Pointers in Each Node
+# 117. Populating Next Right Pointers in Each Node II
+class Solution:
+    def connect(self, root: "Node") -> "Node":
+        if not root:
+            return root
+
+        q = [root]
+        while q:
+            nodes = q.copy()
+            q = []
+            while nodes:
+                node = nodes.pop(0)
+                if nodes:
+                    node.next = nodes[0]
+                if node.left:
+                    q.append(node.left)
+                if node.right:
+                    q.append(node.right)
+        return root

Python/0250. Count Univalue Subtrees.py

@@ -0,0 +1,51 @@
+# Given the root of a binary tree, return the number of uni-value subtrees.
+# A uni-value subtree means all nodes of the subtree have the same value.
+#
+# Example 1:
+#
+# Input: root = [5,1,5,5,5,null,5]
+# Output: 4
+#
+# Example 2:
+#
+# Input: root = []
+# Output: 0
+#
+# Example 3:
+#
+# Input: root = [5,5,5,5,5,null,5]
+# Output: 6
+#
+# Constraints:
+#
+# The number of the node in the tree will be in the range [0, 1000].
+# -1000 <= Node.val <= 1000
+
+
+# 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 countUnivalSubtrees(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+        self.count = 0
+        self.is_univalue_subtree(root)
+        return self.count
+
+    def is_univalue_subtree(self, root):
+        if not root:
+            return True
+        l = self.is_univalue_subtree(root.left)
+        r = self.is_univalue_subtree(root.right)
+        if l and r:
+            if root.left and root.left.val != root.val:
+                return False
+            if root.right and root.right.val != root.val:
+                return False
+            self.count += 1
+            return True
+        return False

Python/0378. Kth Smallest Element in a Sorted Matrix.py

@@ -0,0 +1,77 @@
+# Given an n x n matrix where each of the rows and columns is sorted in ascending order, return the kth smallest element in the matrix.
+# Note that it is the kth smallest element in the sorted order, not the kth distinct element.
+# You must find a solution with a memory complexity better than O(n2).
+#
+# Example 1:
+#
+# Input: matrix = [[1,5,9],[10,11,13],[12,13,15]], k = 8
+# Output: 13
+# Explanation: The elements in the matrix are [1,5,9,10,11,12,13,13,15], and the 8th smallest number is 13
+#
+# Example 2:
+#
+# Input: matrix = [[-5]], k = 1
+# Output: -5
+#
+# Constraints:
+#
+# n == matrix.length == matrix[i].length
+# 1 <= n <= 300
+# -109 <= matrix[i][j] <= 109
+# All the rows and columns of matrix are guaranteed to be sorted in non-decreasing order.
+# 1 <= k <= n2
+#
+# Follow up:
+#
+# Could you solve the problem with a constant memory (i.e., O(1) memory complexity)?
+# Could you solve the problem in O(n) time complexity? The solution may be too advanced for an interview but you may find reading this paper fun.
+
+
+# 1)
+class Solution:
+    def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
+        n = len(matrix)
+        l, r = matrix[0][0], matrix[-1][-1]
+        while l < r:
+            m = (l + r) // 2
+            if self.count_less_equal(matrix, m) < k:
+                l = m + 1
+            else:
+                r = m
+        return l
+
+    def count_less_equal(self, matrix, target):
+        n = len(matrix)
+        count = 0
+        for i in range(n):
+            for j in range(n):
+                if matrix[i][j] <= target:
+                    count += 1
+        return count
+
+
+# 2) Optimized version of 1)
+class Solution:
+    def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
+        n = len(matrix)
+        l, r = matrix[0][0], matrix[-1][-1]
+        while l < r:
+            m = (l + r) // 2
+            if self.count_less_equal(matrix, m) < k:
+                l = m + 1
+            else:
+                r = m
+        return l
+
+    def count_less_equal(self, matrix, target):
+        n = len(matrix)
+        count = 0
+        i = n - 1
+        j = 0
+        while i >= 0 and j < n:
+            if matrix[i][j] <= target:
+                count += i + 1
+                j += 1
+            else:
+                i -= 1
+        return count