Update some problem solutions for a better, easy-to-understand one

Author: enginebai

leetcode/209.minimum-size-subarray-sum.md

@@ -13,6 +13,8 @@ fun minSubArrayLen(target: Int, nums: IntArray): Int {
     var currentSum = 0
     while (end < nums.size) {
         currentSum += nums[end]
+        // We try to find the minimum size subarray sum, so we have to 
+        // shrink the window to become valid and minimum size!!
         while (currentSum - nums[start] >= target) {
             currentSum -= nums[start]
             start++

leetcode/226.invert-binary-tree.md

@@ -6,7 +6,6 @@ fun invertTree(root: TreeNode?): TreeNode? {
     if (root == null) return null
     if (root.left == null && root.right == null) return root
     // We have to preserve the original left and right child here, in case of references changes after inverting.
-    //f132820721
 
     // Wrong results: 
     // root.left = invertTree(root.right)

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

@@ -12,23 +12,23 @@ The key difference is the case that found, i.e. `nums[middle] == target`, the `m
 // 1. The first index, then the we found nothing 
 // when keeping searching and idx will be our final result.
 [100,..., (777) 777, 777, 777,...,999]
- start     mid                    end
+ left      mid                    right
            idx
 
 // 2. Not the first or the last index
 [100,..., 777, 777, (777), 777,...,999]
- start               mid           end
+ left                mid           right
                      idx
 
 // 3. The last index
 [100,..., 777, 777, 777, (777),...,999]
- start                    mid      end
+ left                     mid      right
                           idx
 ```
 
 For the above three possible cases, the first index will always be the left part or the current `mid`.
 
-So we update the result index (`idx`) firstand keep searching the left part (updating `end`), if we find again, it means there exist an index prior to the current result.
+So we update the result index (`idx`) first and keep searching the left part (updating `right`), if we find again, it means there exist an index prior to the current result.
 
 
 ```kotlin
@@ -41,36 +41,99 @@ fun searchRange(nums: IntArray, target: Int): IntArray {
 
 private fun searchFirstIndex(nums: IntArray, target: Int): Int {
     var index = -1
-    var start = 0
-    var end = nums.size - 1
-    while (start <= end) {
-        val middle = start + (end - start) / 2
+    var left = 0
+    var right = nums.size - 1
+    while (left <= right) {
+        val middle = left + (right - left) / 2
         // We update the index first
         if (nums[middle] == target) index = middle
         // Then keep searching if there exists target that index < current result
         if (nums[middle] >= target) {
-            end = middle - 1
+            right = middle - 1
         } else {
-            start = middle + 1
+            left = middle + 1
         }
     }
     return index
 }
 
 private fun searchLastIndex(nums: IntArray, target: Int): Int {
     var index = -1
-    var start = 0
-    var end = nums.size - 1
-    while (start <= end) {
-        val middle = start + (end - start) / 2
+    var left = 0
+    var right = nums.size - 1
+    while (left <= right) {
+        val middle = left + (right - left) / 2
         if (nums[middle] == target) index = middle
         if (nums[middle] <= target) {
-            start = middle + 1
+            left = middle + 1
         } else {
-            end = middle - 1
+            right = middle - 1
         }
 
     }
     return index
 }
+```
+
+> Nice explanation: https://medium.com/@lindingchi/binary-search-%E9%82%A3%E4%BA%9B%E8%97%8F%E5%9C%A8%E7%B4%B0%E7%AF%80%E8%A3%A1%E7%9A%84%E9%AD%94%E9%AC%BC-%E4%B8%89-%E5%BE%88%E5%A4%9A%E7%9B%B8%E5%90%8C%E7%9A%84%E6%83%85%E5%A2%83-c2215d1b9dc7
+
+如果我們要找 `target=8` 的第一個位置，假設我們有三個 `8`，那麼 `middle` 可能會落在三個位置，那麼我們要怎麼縮限下一個搜尋的範圍：
+
+```js
+8 8 8
+  M
+
+8 8 8
+    M
+
+// 這兩種情境第一個位置可能是當前 M 或者他的左邊，所以當 target <= nums[middle]，我們要搜尋左半邊。
+
+8 8 8
+M
+
+// 第一個位置就是在 M 位置，這樣套用上述邏輯，最後 L 和 R 和 M 都會走到這個 8 的左邊位置，在執行一次程式，L 就會跑到第一個 8 然後跳出迴圈。
+
+```
+
+```kotlin
+// Implemented based on the above explanation post!!
+
+fun searchRange(nums: IntArray, target: Int): IntArray {
+    return intArrayOf(
+        findStartingPosition(nums, target),
+        findEndingPosition(nums, target)
+    )
+}
+
+private fun findStartingPosition(nums: IntArray, target: Int): Int {
+    var found = false
+    var left = 0
+    var right = nums.size - 1
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+        if (nums[middle] == target) found = true
+        if (nums[middle] >= target) {
+            right = middle - 1
+        } else {
+            left = middle + 1
+        }
+    }
+    return if (found) left else - 1
+}
+
+private fun findEndingPosition(nums: IntArray, target: Int): Int {
+    var found = false
+    var left = 0
+    var right = nums.size - 1
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+        if (nums[middle] == target) found = true
+        if (target >= nums[middle]) {
+            left = middle + 1
+        } else {
+            right = middle - 1
+        }
+    }
+    return if (found) left - 1 else - 1
+}
 ```

leetcode/35.search-insert-position.md

@@ -1,5 +1,7 @@
 ## [35. Search Insert Position](https://leetcode.com/problems/search-insert-position/)
 
+We're going to find **all the numbers >= `target`, and return the smallest one.** (a.k.a., `left` pointer)
+
 ```kotlin
 fun searchInsert(nums: IntArray, target: Int): Int {
     var left = 0

leetcode/5.longest-palindromic-substring.md

@@ -6,14 +6,17 @@ fun longestPalindrome(s: String): String {
     var results = ""
     for (i in 0 until s.length) {
         for (j in i until s.length) {
-            val substring = s.substring(i, j)
+            val substring = s.substring(i..j)
+            println("$i, $j, $substring")
             if (isPalindrome(substring)) {
-                if (substring.length > results) {
+                if (substring.length > results.length) {
                     results = substring
                 }
             }
         }
+        println()
     }
+    return results
 }
 
 private fun isPalindrome(s: String): Boolean {
@@ -50,43 +53,47 @@ dp[i][j] = dp[i + 1][j - 1] && s[i] == s[j]
 
 ```kotlin
 fun longestPalindrome(s: String): String {
-    val len = s.length
-    val dp = Array(len) { _ -> BooleanArray(len)}
-    
-    // Base case:
-    // We will setup in the for loop below, so we don't do here.
-    // Or we can do here, and REMEMBER to skip below.
-    //
-    // for (i in 0 until len) {
-    //     dp[i][i] = true
-    //     if (i + 1 < len) {
-    //         dp[i][i + 1] = (s[i] == s[i + 1])
-    // }
-    
-    // We will use start + offset to calculate the substring.
-    var resultStart = 0
-    var resultLength = 1
-
-    for (i in len - 1 downTo 0) {
-        for (j in i + 1 until len) {
-            // j - i < 2 means the length of substring is 1 or 2, this is 
-            // the base cases.
-            dp[i][j] = (dp[i + 1][j - 1] || j - i < 2) && s[i] == s[j]
-
-            // If the current substring is palindrome, we update the longest palindrome result
-            if (dp[i][j] == true) {
+    val dp = Array(s.length) { _ -> BooleanArray(s.length) }
+    var result = ""
+
+    // How do we iterate i,j? i expands toward left, j expends toward right.
+    // We can iterate in this backward way:
+    // for (i in len - 1 downTo 0) {
+        // for (j in i + 1 until len) {
+
+    // Or foward way, mind the i, j order.
+    for (j in 0 until s.length) {
+        for (i in j downTo 0) {
+
+            // Base cases: when length is 1 or 2.
+            dp[i][j] = if (i == j || i + 1 == j) s[i] == s[j]
+            else dp[i + 1][j - 1] && s[i] == s[j]
+
+            if (dp[i][j]) {
                 val currentLength = j - i + 1
-                if (currentLength > resultLength) {
-                    resultLength = currentLength
-                    resultStart = i
-                }                                        
+                if (currentLength > result.length) {
+                    result = s.substring(i..j)
+                }
             }
         }
     }
-    
-    return s.substring(resultStart, resultStart + resultLength)
+    return result
 }   
 ```
+
+```js
+s = "babad"
+
+// Forward way
+ i|0 |1 0|2 1 0|3 2 1 0|4 3 2 1 0
+ j|0 |1  |2    |3      |4
+---------------------------------
+dp|O  O X O X O O X O X O X X X X
+
+// Backward
+ i|4 |3  |2    |...
+ j|4 |3 4|2 3 4|...
+```
 * **Time Complexity**: `O(n^2)`.
 * **Space Complexity**: `O(n^2)`.
 

leetcode/516.longest-palindromic-subsequence.md

@@ -87,6 +87,10 @@ fun longestPalindromeSubseq(s: String): Int {
     // `j` will be the next character of `i` to end.
     for (i in n - 1 downTo 0) {
         for (j in i + 1 until n) {
+
+    // Or we can iterate from the beginning (mind the i, j order)
+    // for (j in 0 until n) {
+    //  for (i in j downTo 0) {
             dp[i][j] = if (s[i] == s[j]) dp[i + 1][j - 1] + 2
             else max(dp[i + 1][j], dp[i][j - 1])
         }

leetcode/704.binary-search.md

@@ -2,15 +2,15 @@
 
 ```kotlin
 fun search(nums: IntArray, target: Int): Int {
-    var start = 0
-    var end = nums.size - 1
-    while (start <= end) {
-        val middle = start + (end - start) / 2
+    var left = 0
+    var right = nums.size - 1
+    while (left <= right) {
+        val middle = left + (right - left) / 2
         if (nums[middle] == target) return middle
         else if (nums[middle] > target) {
-            end = middle - 1
+            right = middle - 1
         } else {
-            start = middle + 1
+            left = middle + 1
         }
     }
     return -1

leetcode/735.asteroid-collision.md

@@ -2,37 +2,35 @@
 
 ```kotlin
 fun asteroidCollision(asteroids: IntArray): IntArray {
+    // 30, -40
+    // -5, -10
+    // -5, 10
     val stack = Stack<Int>()
     for (i in 0 until asteroids.size) {
-        val coming = asteroids[i]
-        if (coming < 0) {
-            if (stack.isEmpty()) {
-                results.add(coming)
+        val right = asteroids[i]
+        var existInFinal = true
+        while (stack.isNotEmpty() && stack.peek() > 0 && right < 0) {
+            val left = stack.peek()
+            if (left + right > 0) {
+                existInFinal = false
+                break
+            } else if (left + right == 0) {
+                existInFinal = false
+                stack.pop()
+                break
             } else {
-                while (!stack.isEmpty()) {
-                    val existing = stack.peek()
-                    if (existing + coming == 0) {
-                        stack.pop()
-                        break
-                    } else if (existing + coming < 0) {
-                        stack.pop()
-                        if (stack.isEmpty()) {
-                            results.add(coming)
-                        }
-                    } else {
-                        break
-                    }
-                }
+                stack.pop()
             }
-        } else if (coming > 0) {
-            stack.push(coming)
+        }
+        if (existInFinal) {
+            stack.push(right)
         }
     }
-    val result = IntArray(stack.size)
+    val results = IntArray(stack.size)
     val size = stack.size
-    for (i in 0 untili size) {
-        result[i] = stack.pop()
+    for (i in size - 1 downTo 0) {
+        results[i] = stack.pop()
     }
-    return result
+    return results
 }
 ```

topics/searching.md

@@ -60,6 +60,7 @@ if (100% sure logic) {
     left = middle
 }
 ```
+
 * Always use `while (left < right)`, so when while loop breaks, we will have `left == right`, and then check if the target exists or not. (might need further check, such as `if (A[left] == target)`).
 
 ## Resources