Add some solutions to new problems

* 11. Container With Most Water
* 131. Palindrome Partitioning
* 237. Delete Node in a Linked List
* 238. Product of Array Except Sefl
* 31. Next Permutation
* 334. Increasing Triplet Subsequence
* 73. Set Matrix Zeroes
* 56. Merge Intervals
* 75. Sort Colors
* 2095. Delete the Middle Node of a Linked List
* 169. Majority Element
* 128. Longest Consecutive Sequence
* 148. Sort List

Author: enginebai

leetcode/101.symmetric-tree.md

@@ -15,26 +15,34 @@ fun check(left: TreeNode?, right: TreeNode?): Boolean {
 
 ### Iterative
 ```kotlin
-val emptyNode = TreeNode(-1)
+private val nullNode = TreeNode(200)
+    
 fun isSymmetric(root: TreeNode?): Boolean {
     if (root == null) return true
-    val queue = ArrayDeque<TreeNode>()
-    if (root.left != null) queue.addLast(root.left)
-    if (root.right != null) queue.addLast(root.right)
-    while (queue.isNotEmpty()) {
-        val left = queue.removeFirst()
-        if (queue.isEmpty()) return false
-        val right = queue.removeFirst()
+    
+    val leftQueue = ArrayDeque<TreeNode>()
+    val rightQueue = ArrayDeque<TreeNode>()
+    
+    leftQueue.addLast(if (root.left != null) root.left else nullNode)        
+    rightQueue.addLast(if (root.right != null) root.right else nullNode)
+    
+    while (leftQueue.isNotEmpty() && rightQueue.isNotEmpty()) {
+        val left = leftQueue.removeFirst()
+        val right = rightQueue.removeFirst()
 
-        if (left == emptyNode && right == emptyNode) continue
-        if (left == emptyNode || right == emptyNode || left.`val` != right.`val`) return false
-
-        // Make sure to enqueue empty node
-        if (left.left != null) queue.addLast(left.left!!) else queue.addLast(emptyNode)
-        if (right.right != null) queue.addLast(right.right!!) else queue.addLast(emptyNode)
-        if (left.right != null) queue.addLast(left.right!!) else queue.addLast(emptyNode)
-        if (right.left != null) queue.addLast(right.left!!) else queue.addLast(emptyNode)
+        if (left.`val` != right.`val`) return false
+        
+        if (left != nullNode) {
+            leftQueue.addLast(if (left.left != null) left.left else nullNode)
+            rightQueue.addLast(if (right.right != null) right.right else nullNode)
+        }
+        
+        if (right != nullNode) {
+            leftQueue.addLast(if (left.right != null) left.right else nullNode)
+            rightQueue.addLast(if (right.left != null) right.left else nullNode)
+        }
     }
-    return true
+    
+    return leftQueue.isEmpty() && rightQueue.isEmpty()
 }
 ```

leetcode/11.container-with-most-water.md

@@ -0,0 +1,66 @@
+## [11. Container With Most Water](https://leetcode.com/problems/container-with-most-water/)
+
+The max area might come from the following choices:
+1. The widest
+2. The highest
+
+But we don't know if we have the highest height at specific moment, but we can start the widest choice at first, we put `left` and `right` two pointers at the first and the last position, this forms the widest container, but it doesn't guarantee that it's highest, so we move the pointers to find the max area, but how to move?
+
+```js
+[...8  .....  6...]
+    L ->   <- R
+```
+
+**Keep the higher one and move the shorter one!!**
+
+* If we move `left` (to right direction), the width becomes smaller, then it's impossible to become the max area.
+* If we move `right` (to left direction), we *might* find the taller height later even if the width becomes smaller, it might be possible to find the max area.
+
+So, we will move **the shorter-height** pointer!!
+
+```js
+
+
+i: 0,1,2,3,4,5,6,7,8
+v: 1,8,6,2,5,4,8,3,7
+   L               R, min(1,7)*8, 8
+     L             R, min(8,7)*7, 49
+     L           R,   min(8,3)*6, 18
+     L         R      min(8,8)*5, 40
+       L       R      min(6,8)*4, 24
+         L     R      min(2,8)*3, 6
+           L   R      min(5,8)*2, 10
+             L R      min(4,8)*1, 4
+
+// Move right if the left == right
+     L       R        min(8,4)*4, 16
+     L     R          min(8,5)*3, 15
+     L   R            min(8,2)*2, 4
+     L R              min(8,6)*1, 6   
+```
+
+```kotlin
+fun maxArea(height: IntArray): Int {
+    var left = 0
+    var right = height.size - 1
+    var maxAmount = 0
+    while (left < right) {
+        val lowerHeight = min(height[left], height[right])
+        val width = right - left
+        maxAmount = max(maxAmount, lowerHeight * width)
+        if (height[left] <= height[right]) {
+            left++
+        } else {
+            right--
+        }
+    }
+    return maxAmount
+}
+
+// Sorting
+// Searching
+// Two Pointers
+// Sliding Windows
+// DP
+// Greedy
+```

leetcode/121.best-time-to-buy-and-sell-stock.md

@@ -3,25 +3,18 @@
 ### Greedy
 We're going to find minimium price to buy and calculate max profit for every day.
 
-|           | Init | 7 | 1 | 5 | 3 | 6 | 4 |
-|-----------|------|---|---|---|---|---|---|
-| minPrice  | oo   | 7 | 1 | 1 | 1 | 1 | 1 |
-| maxProfit | 0    | 0 | 0 | 4 | 4 | 5 | 5 |
-
 ```kotlin
 fun maxProfit(prices: IntArray): Int {
-    var min: Int? = null
-    var profit = 0
-    for (i in 0 until prices.size) {
-        if (min == null) {
-            min = prices[i]
+    var lowestPrice = prices[0]
+    var maxProfit = 0
+    for (i in 1 until prices.size) {
+        if (prices[i] < lowestPrice) {
+            lowestPrice = prices[i]
         } else {
-            if (prices[i] < min) min = prices[i]
-            val currentProfit = prices[i] - min
-            profit = if (currentProfit > profit) currentProfit else profit
+            maxProfit = max(maxProfit, prices[i] - lowestPrice)
         }
     }
-    return profit
+    return maxProfit
 }
 ```
 

leetcode/128.longest-consecutive-sequence.md

@@ -0,0 +1,29 @@
+## [128. Longest Consecutive Sequence](https://leetcode.com/problems/longest-consecutive-sequence/)
+
+For every number `x`, we can extend two side and check if `x - 1`, `x - 2`, ... and `x + 1`, `x + 2`, ... so on. But actually, we can check `x + 1`, `x + 2`, ... direction only, we've check if `x` is consecutive sequence when number is `x - 1`.
+
+> https://leetcode.cn/problems/longest-consecutive-sequence/solution/zui-chang-lian-xu-xu-lie-by-leetcode-solution/
+
+```kotlin
+fun longestConsecutive(nums: IntArray): Int {
+    val hashSet = hashSetOf<Int>()
+    for (num in nums) {
+        hashSet.add(num)
+    }
+
+    var maxStreak = 0
+    for (i in 0 until nums.size) {
+        val num = nums[i]
+        // This is the key, we only check ascending direction.
+        // If we have num - 1 which is consecutive to num, answer will check at num - 1 iteration, not current iteration.
+        if (!hashSet.contains(num - 1)) {
+            var next = num + 1
+            while (hashSet.contains(next)) {
+                next++
+            }
+            maxStreak = max(maxStreak, next - num)
+        }
+    }
+    return maxStreak
+}
+```

leetcode/131.palindrome-partitioning.md

@@ -0,0 +1,42 @@
+## [131. Palindrome Partitioning](https://leetcode.com/problems/palindrome-partitioning)
+
+```kotlin
+class Solution {
+
+    private val results = mutableListOf<List<String>>()
+
+    fun partition(s: String): List<List<String>> {
+        val dp = findAllPalindromes(s)
+        dfs(s, 0, mutableListOf<String>(), dp)
+        return results
+    }
+
+    private fun findAllPalindromes(s: String): Array<BooleanArray> {
+        val dp = Array(s.length) { _ -> BooleanArray(s.length) }
+        for (i in s.length - 1 downTo 0) {
+            for (j in i until s.length) {
+                if (i == j) dp[i][j] = true
+                else if (j == i + 1) dp[i][j] = s[i] == s[j]
+                else dp[i][j] = dp[i + 1][j - 1] && s[i] == s[j]
+            }
+        }
+        return dp
+    }
+
+    private fun dfs(s: String, startIndex: Int, partition: MutableList<String>, dp: Array<BooleanArray>) {
+        if (startIndex == s.length) {
+            results.add(ArrayList(partition))
+            return
+        }
+        for (i in startIndex until s.length) {
+            if (dp[startIndex][i]) {
+                partition.add(s.substring(startIndex..i))
+                dfs(s, i + 1, partition, dp)
+                partition.removeAt(partition.size - 1)
+            }
+        }
+    }
+}
+```
+
+![](../media/131.palindrome-partitioning.jpg)

leetcode/141.linked-list-cycle.md

@@ -24,34 +24,27 @@ We can use two pointers approach to solve this with `O(1)` space:
 fun hasCycle(head: ListNode?): Boolean {
     var slow: ListNode? = head
     var fast: ListNode? = head
+    // Make sure that fast pointer can move 2 steps
     while (fast != null && fast.next != null) {
         show = show?.next
         fast = fast?.next?.next
         if (fast == slow) return true
     }
     return false
 }
-```
-
-For two pointers approach, there are some equivalent implementations:
 
-> **Important**!! But we will choose above impelementation since it will affect the idea and result of [142. Linked List Cycle II](https://leetcode.com/problems/linked-list-cycle-ii/).
-
-```kotlin
-/// Slow 1, fast 2
-//	    **Slow 2, fast 4
-// Slow 2, fast 4
-//	    **Slow 3, fast 3
-// Slow 3, fast 3
-//true
-fun hasCycle2(head: ListNode?): Boolean {
+// or
+fun hasCycle(head: ListNode?): Boolean {
+    if (head == null || head?.next == null) return false
     var slow: ListNode? = head
     var fast: ListNode? = head?.next
-    while (slow != null) {
-        if (slow == fast) return true
-        slow = slow.next
+    while (slow != fast) {
+        if (fast == null || fast?.next == null) return false
+        slow = slow?.next
         fast = fast?.next?.next
     }
-    return false
+    return true
 }
 ```
+
+> Reference: Floyd’s Cycle-Finding Algorithm.

leetcode/148.sort-list.md

@@ -0,0 +1,83 @@
+## [148. Sort List](https://leetcode.com/problems/sort-list)
+
+### Merge Sort
+```kotlin
+fun sortList(head: ListNode?): ListNode? {
+    return mergeSort(head)
+}
+
+// Time Complexity: O(n lg n)
+// Space Complexity: O(lg n) for 
+private fun mergeSort(head: ListNode?): ListNode? {
+    if (head == null) return null
+    if (head?.next == null) return head
+    val middle = findMiddle(head)
+
+    // The head after merge sort might change, so we use updated head to merge.
+    val newHead = mergeSort(head)
+    val newMiddle = mergeSort(middle)
+    return merge(newHead, newMiddle)
+}
+
+private fun findMiddle(head: ListNode?): ListNode? {
+    var previous: ListNode? = null
+    var slow: ListNode? = head
+    var fast: ListNode? = head
+    while (fast != null && fast.next != null) {
+        previous = slow
+        slow = slow?.next
+        fast = fast?.next?.next
+    }
+    previous?.next = null
+    return slow
+}
+
+private fun merge(head: ListNode?, middle: ListNode?): ListNode? {
+    val sentinel = ListNode(-1)
+    var n1: ListNode? = head
+    var n2: ListNode? = middle
+    var current: ListNode? = sentinel
+    while (n1 != null && n2 != null) {
+        if (n1.`val` <= n2.`val`) {
+            current?.next = n1
+            n1 = n1.next
+        } else {
+            current?.next = n2
+            n2 = n2.next
+        }
+        current = current?.next
+    }
+    if (n1 != null) current?.next = n1
+    if (n2 != null) current?.next = n2
+    return sentinel.next
+}
+```
+
+* **Time Complexity**: `O(n lg n)`.
+* **Space Complexity**: `O(lg n)` for recursive function calls.
+
+
+### Heap
+```kotlin
+private fun sortWithExtraSpace(head: ListNode?): ListNode? {
+    val minHeap = PriorityQueue<ListNode>() { n1, n2 -> n1.`val` - n2.`val` }
+    var node: ListNode? = head
+    while (node != null) {
+        val next = node.next
+        node.next = null
+        minHeap.add(node)
+        node = next
+    }
+    
+    val sentinel = ListNode(-1)
+    node = sentinel
+    while (minHeap.isNotEmpty()) {
+        node?.next = minHeap.poll()
+        node = node?.next
+    }
+    return sentinel.next
+}
+```
+
+* **Time Complexity**: `O(n lg n)`.
+* **Space Complexity**: `O(n)`.