feat(python): solutions

Author: hongbo-miao

JavaScript/0122. Best Time to Buy and Sell Stock II.js

@@ -30,14 +30,14 @@
  * @return {number}
  */
 
-// 1)
+// 1) Two Pointers
 const maxProfit1 = (prices) => {
   let res = 0;
   let slow = 0;
   let fast = 1;
 
-  while (slow < prices.length) {
-    while (prices[fast] > prices[fast - 1]) {
+  while (fast < prices.length) {
+    while ( prices[fast - 1] < prices[fast]) {
       fast++;
     }
     res += prices[fast - 1] - prices[slow];

JavaScript/0130. Surrounded Regions.js

@@ -24,6 +24,8 @@
  * @return {void} Do not return anything, modify board in-place instead.
  */
 
+// DFS
+//
 // Idea
 // 1) Check four borders. If it is O, change it and all its neighbor to temporary #
 // 2) Change all O to X
@@ -54,24 +56,24 @@ const solve = (board) => {
     }
   };
 
-  // change every square connected to left and right borders from O to temporary #
+  // Change every square connected to left and right borders from O to temporary #
   for (let i = 0; i < h; i++) {
     go(i, 0);
     go(i, w - 1);
   }
 
-  // change every square connected to top and bottom borders from O to temporary #
+  // Change every square connected to top and bottom borders from O to temporary #
   for (let i = 1; i < w - 1; i++) {
     go(0, i);
     go(h - 1, i);
   }
 
   for (let i = 0; i < h; i++) {
     for (let j = 0; j < w; j++) {
-      // change the rest of O to X
+      // Change the rest of O to X
       if (board[i][j] === 'O') board[i][j] = 'X';
 
-      // change temporary # back to O
+      // Change temporary # back to O
       if (board[i][j] === '#') board[i][j] = 'O';
     }
   }

Python/0079. Word Search.py

@@ -30,19 +30,19 @@ def exist(self, board: List[List[str]], word: str) -> bool:
         if not board or not board[0]:
             return False
         m, n = len(board), len(board[0])
-        dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+        dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)]
 
         def go(i, j, k):
             if k == len(word):
                 return True
-            if i < 0 or i >= m or j < 0 or j >= n or board[i][j] != word[k]:
+            if 0 <= i < m and 0 <= j < n and board[i][j] == word[k]:
+                c = board[i][j]
+                board[i][j] = "#"  # mark visited
+                for dir in dirs:
+                    if go(i + dir[0], j + dir[1], k + 1):
+                        return True
+                board[i][j] = c  # reset
                 return False
-            c = board[i][j]
-            board[i][j] = "#"  # mark visited
-            for dir in dirs:
-                if go(i + dir[0], j + dir[1], k + 1):
-                    return True
-            board[i][j] = c  # reset
             return False
 
         for i in range(m):

Python/0102. Binary Tree Level Order Traversal.py

@@ -71,12 +71,12 @@ def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
         q = [root]
 
         while q:
+            nodes = q.copy()
+            q = []
             row = []
 
-            # Note cannot use "while q" here because q changes.
-            # len(q) stands for the number of nodes in the current level.
-            for _ in range(len(q)):
-                node = q.pop(0)
+            while nodes:
+                node = nodes.pop(0)
                 row.append(node.val)
                 if node.left:
                     q.append(node.left)

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

@@ -0,0 +1,55 @@
+# Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same tree, construct and return the binary tree.
+#
+# Example 1:
+#
+# Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
+# Output: [3,9,20,null,null,15,7]
+#
+# Example 2:
+#
+# Input: preorder = [-1], inorder = [-1]
+# Output: [-1]
+#
+# Constraints:
+#
+# 1 <= preorder.length <= 3000
+# inorder.length == preorder.length
+# -3000 <= preorder[i], inorder[i] <= 3000
+# preorder and inorder consist of unique values.
+# Each value of inorder also appears in preorder.
+# preorder is guaranteed to be the preorder traversal of the tree.
+# inorder is guaranteed to be the inorder 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
+
+
+# preorder: (3) 9 20 15 7
+# inorder: 9 (3) 15 20 7
+#     3
+#    / \
+#   9  20
+#     /  \
+#    15   7
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        if not preorder or not inorder:
+            return None
+
+        def build(l, r):
+            if l > r:
+                return None
+            val = preorder.pop(0)
+            i = inorder.index(val)
+
+            node = TreeNode(val)
+            node.left = build(l, i - 1)
+            node.right = build(i + 1, r)
+            return node
+
+        return build(0, len(inorder) - 1)

Python/0108. Convert Sorted Array to Binary Search Tree.py

@@ -0,0 +1,39 @@
+# Given an integer array nums where the elements are sorted in ascending order, convert it to a height-balanced binary search tree.
+# A height-balanced binary tree is a binary tree in which the depth of the two subtrees of every node never differs by more than one.
+#
+# Example 1:
+#
+# Input: nums = [-10,-3,0,5,9]
+# Output: [0,-3,9,-10,null,5]
+# Explanation: [0,-10,5,null,-3,null,9] is also accepted:
+#
+# Example 2:
+#
+# Input: nums = [1,3]
+# Output: [3,1]
+# Explanation: [1,null,3] and [3,1] are both height-balanced BSTs.
+#
+# Constraints:
+#
+# 1 <= nums.length <= 10^4
+# -10^4 <= nums[i] <= 10^4
+# nums is sorted in a strictly increasing order.
+
+
+# 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 sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        if not nums:
+            return None
+        m = len(nums) // 2
+        root = TreeNode(nums[m])
+        root.left = self.sortedArrayToBST(nums[:m])
+        root.right = self.sortedArrayToBST(nums[m + 1 :])
+        return root

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

@@ -0,0 +1,84 @@
+# You are given a perfect binary tree where all leaves are on the same level, and every parent has two children. The binary tree has the following definition:
+#
+# 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,6,7]
+# Output: [1,#,2,3,#,4,5,6,7,#]
+# Explanation: Given the above perfect 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, 212 - 1].
+# -1000 <= Node.val <= 1000
+#
+# 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
+"""
+
+# 1)
+# Time O(n)
+# Space O(1)
+class Solution:
+    def connect(self, root: "Optional[Node]") -> "Optional[Node]":
+        if not root:
+            return None
+        if root.left:
+            root.left.next = root.right
+        if root.right:
+            root.right.next = root.next.left if root.next else None
+        self.connect(root.left)
+        self.connect(root.right)
+        return root
+
+
+# 2) BFS - level-order traversal
+# Similar
+# 102. Binary Tree Level Order Traversal
+# 116. Populating Next Right Pointers in Each Node
+#
+# Time O(n)
+class Solution:
+    def connect(self, root: "Optional[Node]") -> "Optional[Node]":
+        if not root:
+            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 node.left:
+                    q.append(node.left)
+                if node.right:
+                    q.append(node.right)
+        return root

Python/0118. Pascal's Triangle.py

@@ -0,0 +1,39 @@
+# Given an integer numRows, return the first numRows of Pascal's triangle.
+# In Pascal's triangle, each number is the sum of the two numbers directly above it as shown:
+#
+# Example 1:
+#
+# Input: numRows = 5
+# Output: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+#
+# Example 2:
+#
+# Input: numRows = 1
+# Output: [[1]]
+#
+# Constraints:
+#
+# 1 <= numRows <= 30
+
+
+# Dynamic programming
+# Time O(numRows^2), consider how many overall loop iterations there are. The outer loop obviously runs numRows times, but for each iteration of the outer loop, the inner loop runs rowNum times
+#   Therefore, the overall number of triangle updates that occur is 1 + 2 + 3 + ... + numRows, which, according to Gauss' formula, is (1 + numRows) * numRows / 2 -> O(numRows^2)
+# Space O(numRows^2), we need to store each number that we update in triangle, so the space requirement is the same as the time complexity
+class Solution:
+    def generate(self, numRows: int) -> List[List[int]]:
+        if numRows == 0:
+            return []
+        if numRows == 1:
+            return [[1]]
+        if numRows == 2:
+            return [[1], [1, 1]]
+
+        res = [[1], [1, 1]]
+        for i in range(2, numRows):
+            row = [1]
+            for j in range(1, i):
+                row.append(res[i - 1][j - 1] + res[i - 1][j])
+            row.append(1)
+            res.append(row)
+        return res

Python/0121. Best Time to Buy and Sell Stock.py

@@ -0,0 +1,48 @@
+# You are given an array prices where prices[i] is the price of a given stock on the ith day.
+# You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.
+# Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.
+#
+# Example 1:
+#
+# Input: prices = [7,1,5,3,6,4]
+# Output: 5
+# Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
+# Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
+#
+# Example 2:
+#
+# Input: prices = [7,6,4,3,1]
+# Output: 0
+# Explanation: In this case, no transactions are done and the max profit = 0.
+#
+# Constraints:
+#
+# 1 <= prices.length <= 10^5
+# 0 <= prices[i] <= 10^4
+
+
+# 1) Brute force (time limit exceeded)
+# Time O(n^2)
+# Space O(1)
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        mx = 0
+        for i in range(len(prices)):
+            for j in range(i + 1, len(prices)):
+                mx = max(mx, prices[j] - prices[i])
+        return mx
+
+
+# 2) One pass using min and max
+# Time O(n)
+# Space O(1)
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        if len(prices) < 2:
+            return 0
+        mn = float("inf")
+        mx = float("-inf")
+        for p in prices:
+            mn = min(mn, p)
+            mx = max(mx, p - mn)
+        return mx