Add some solutions to new problems

16. 3Sum Cloest

221. Maximal Square

45. Jump Game II

653. Two Sum IV Input Is A BST

Author: enginebai

leetcode/16.3sum-closest.md

@@ -0,0 +1,35 @@
+## [16. 3Sum Closest](https://leetcode.com/problems/3sum-closest/)
+
+The idea is similar to [15. 3Sum](../leetcode/15.3sum.md) with some modification.
+
+> Nice explanation: https://leetcode.com/problems/3sum-closest/solutions/7883/c-solution-o-n-2-using-sort/
+
+```kotlin
+fun threeSumClosest(nums: IntArray, target: Int): Int {
+    nums.sort()
+    var resultSum = Int.MAX_VALUE
+    for (i in 0 until nums.size) {
+        val first = nums[i]
+        
+        var secondIndex = i + 1
+        var thirdIndex = nums.size - 1
+        while (secondIndex < thirdIndex) {
+            val sum = first + nums[secondIndex] + nums[thirdIndex]
+            val diff = abs(sum - target)
+            if (sum == target) return sum
+            if (abs(resultSum - target) > diff) {
+                resultSum = sum
+            }
+            if (sum > target) {
+                thirdIndex--
+            } else if (sum < target) {
+                secondIndex++
+            }
+        }
+    }
+    return resultSum
+}
+```
+
+* **Time Complexity**: `O(n^2)`.
+* **Space Complexity**: `O(lg n)` for sorting.

leetcode/207.course-schedule.md

@@ -43,4 +43,9 @@ class Solution {
         topologicalSort.push(source)
     }
 }
-```
+```
+
+### Clarification Questions
+1. Are all the prerequisites pair unique?
+2. What if `prerequisites` is empty? (but `numCourses` is 1 or greater than 1)
+3. Do all the prerequisite pairs cover all courses from 0 to `numCourses - 1`.

leetcode/221.maximal-square.md

@@ -0,0 +1,67 @@
+## [221. Maximal Square](https://leetcode.com/problems/maximal-square/)
+
+### Brute Force
+```kotlin
+fun maximalSquare(matrix: Array<CharArray>): Int {
+    val m = matrix.size
+    val n = matrix[0].size
+
+    var maxSquare = 0
+    for (row in 0 until m) {
+        for (col in 0 until n) {
+            var i = row
+            var j = col
+            var currentLength = if (matrix[i][j] == '1') 1 else 0
+            if (currentLength == 0) continue
+            while (i + 1 < m && j + 1 < n && matrix[i + 1][j + 1] == '1') {
+                var allOnes = true
+                for (r in row..i) {
+                    if (matrix[r][j + 1] == '0') {
+                        allOnes = false
+                        break
+                    }
+                }
+                if (!allOnes) break
+                for (c in col..j) {
+                    if (matrix[i + 1][c] == '0') {
+                        allOnes = false
+                        break
+                    }
+                }
+
+                if (allOnes) {
+                    currentLength++
+                } else {
+                    break
+                }
+                i++
+                j++
+            }
+
+            maxSquare = max(maxSquare, currentLength * currentLength)
+        }
+    }
+    return maxSquare
+}
+```
+
+### Dynamic Programming
+```kotlin
+fun maximalSquare(matrix: Array<CharArray>): Int {
+    val dp = Array(matrix.size) { _ -> IntArray(matrix[0].size) }
+    var longestLength = 0
+    for (i in 0 until matrix.size) {
+        for (j in 0 until matrix[0].size) {
+            dp[i][j] = if (matrix[i][j] == '0') 0 else {
+                if (i == 0 || j == 0) 1
+                else min(
+                    dp[i - 1][j - 1],
+                    min(dp[i - 1][j], dp[i][j - 1])
+                ) + 1
+            }
+            longestLength = max(longestLength, dp[i][j])
+        }
+    }
+    return longestLength * longestLength
+}
+```

leetcode/33.search-in-rotated-sorted-array.md

@@ -17,7 +17,9 @@ fun search(nums: IntArray, target: Int): Int {
     while (left <= right) {
         val middle = left + (right - left) / 2
         if (target == nums[middle]) return middle
-        else if (nums[left] <= nums[middle]) {
+
+        // Or we can exchange the logic for `if (nums[middle] <= nums[right])`, it leads to the same accepted result.
+        if (nums[left] <= nums[middle]) {
             if (target in nums[left]..nums[middle])
                 right = middle - 1
             else 
@@ -33,4 +35,36 @@ fun search(nums: IntArray, target: Int): Int {
 }
 ```
 
-Another way to implement the binary search
+## Corner Cases
+```js
+[3,1]
+target = 0
+```
+
+If you implement the following logic, it leads TLE:
+```kotlin
+if (nums[left] < nums[middle]) {
+    if (target in nums[left]..nums[middle])
+        right = middle - 1
+    else 
+        left = middle + 1
+} else {
+    if (target in nums[middle]..nums[right])
+        left = middle + 1
+    else
+        right = middle - 1
+}
+
+// Or 
+if (nums[left] < nums[middle]) {
+    if (target in nums[left]..nums[middle])
+        right = middle - 1
+    else 
+        left = middle + 1
+} else if (nums[middle] <= nums[right]) {
+    if (target in nums[middle]..nums[right])
+        left = middle + 1
+    else
+        right = middle - 1
+}
+```

leetcode/34.find-first-and-last-position-of-element-in-sorted-array.md

@@ -134,6 +134,6 @@ private fun findEndingPosition(nums: IntArray, target: Int): Int {
             right = middle - 1
         }
     }
-    return if (found) left - 1 else - 1
+    return if (found) right else - 1
 }
 ```

leetcode/45.jump-game-ii.md

@@ -0,0 +1 @@
+## [45. Jump Game II]()

leetcode/653.two-sum-iv-input-is-a-bst.md

@@ -0,0 +1,46 @@
+## [653. Two Sum IV - Input is a BST](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/)
+
+### Inorder + Two Pointers
+```kotlin
+private val inorder = mutableListOf<Int>()
+
+fun findTarget(root: TreeNode?, k: Int): Boolean {
+    inorder(root)
+    var left = 0
+    var right = inorder.size - 1
+    while (left < right) {
+        val sum = inorder[left] + inorder[right]
+        if (sum == k) return true
+        if (sum < k) left++
+        else right--
+    }
+    return false
+}
+
+private fun inorder(root: TreeNode?) {
+    if (root == null) return
+    if (root.left != null) inorder(root.left)
+    inorder.add(root.`val`)
+    if (root.right != null) inorder(root.right)
+}
+```
+
+* **Time Complexity**: `O(n)`.
+* **Space Complexity**: `O(n)`.
+
+### Hash Table
+```kotlin
+private val hashSet = hashSetOf<Int>()
+
+fun findTarget(root: TreeNode?, k: Int): Boolean {
+    if (root == null) return false
+    val remaining = k - root.`val`
+    if (hashSet.contains(remaining)) return true
+    hashSet.add(root.`val`)
+    hashSet.add(remaining)
+    return findTarget(root.left, k) || findTarget(root.right, k)
+}
+```
+
+* **Time Complexity**: `O(n)`.
+* **Space Complexity**: `O(n)`.

topics/problems-solutions.md

@@ -6,6 +6,7 @@
 |[977. Squares of a Sorted Array](../leetcode/977.squares-of-a-sorted-array.md)|Easy|
 |[283. Move Zeroes](../leetcode/283.move-zeros.md)|Easy|
 |[15. 3Sum](../leetcode/15.3sum.md)|Medium|
+|[16. 3Sum Closest](../leetcode/16.3sum-closest.md)|Medium|
 |[1. Two Sum](../leetcode/1.two-sum.md)|Easy|
 |[217. Contains Duplicate](../leetcode/217.contains-duplicate.md)|Easy|
 |[350. Intersection of Two Arrays II](../leetcode/350.intersection-of-two-arrays-ii.md)|Easy|
@@ -26,6 +27,7 @@
 |[674. Longest Continuous Increasing Subsequence](../leetcode/674.longest-continuous-increasing-subsequence.md)|Easy|
 |[76. Minimum Window Substring](../leetcode/76.minimum-window-substring.md)|Hard|
 |[239. Sliding Window Maximum](../leetcode/239.sliding-window-maximium.md)|Hard|
+|[221. Maximal Square](../leetcode/221.maximal-square.md)|Medium|
 
 > * https://leetcode.com/problems/find-all-duplicates-in-an-array/ 6k m
 > * https://leetcode.com/problems/merge-intervals/ 14k m
@@ -142,6 +144,7 @@
 |[98. Validate Binary Search Tree](../leetcode/98.validate-binary-search-tree.md)|Medium|
 |[230. Kth Smallest Element in a BST](../leetcode/230.kth-smallest-element-in-a-bst.md)|Medium|
 |[235. Lowest Common Ancestor of a Binary Search Tree](../leetcode/235.lowest-common-acestor-of-a-binary-search-tree.md)|Easy|
+|[653. Two Sum IV - Input is a BST](../leetcode/653.two-sum-iv-input-is-a-bst.md)|Easy|
 
 > * https://leetcode.com/problems/construct-binary-search-tree-from-preorder-traversal/ 4k m
 > * https://leetcode.com/problems/serialize-and-deserialize-bst/ 2k m
@@ -217,6 +220,7 @@
 |[152. Maximum Product Subarray](../leetcode/153.maximum-product-subarray.md)|Medium|
 |[32. Longest Valid Parentheses](../leetcode/32.longest-valid-parentheses.md)|Hard|
 |[55. Jump Game](../leetcode/55.jump-game.md)|Medium|
+|[45. Jump Game II](../leetcode/45.jump-game-ii.md)|Medium|
 |[139. Word Break](../leetcode/139.word-break.md)|Medium|
 |[64. Minimum Path Sum](../leetcode/64.minimum-path-sum.md)|Medium|
 |[279. Perfect Squares](../leetcode/279.perfect-squares.md)|Medium|
@@ -244,7 +248,6 @@
 > * https://leetcode.com/problems/ones-and-zeroes/ 4k m
 > * https://leetcode.com/problems/integer-break/ 3k m
 > * https://leetcode.com/problems/triangle/ 6k m
-> * https://leetcode.com/problems/maximal-square/ 7k m
 
 ### LCS
 > * https://leetcode.com/problems/distinct-subsequences/ 4k h