Add some solutions to new problems

1642. Furthest Building You Can Reach
278. First Bad Version
983. Minimum Cost For Tickets
287. Find the Duplicate Number
669. Trim a Binary Search Tree
2115. Find All Possible Recipes from Given Supplies
103. Binary Tree Zigzag Level Order Traversal
219. Contains Duplicate II
856. Score of Parentheses
617. Merge Two Binary Trees
1046. Last Stone Weight]()
645. Set Mismatch
684. Redundant Connection

Author: enginebai

leetcode/103.binary-tree-zigzag-level-order-traversal.md

@@ -0,0 +1,34 @@
+## [103. Binary Tree Zigzag Level Order Traversal](https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal)
+
+```kotlin
+fun zigzagLevelOrder(root: TreeNode?): List<List<Int>> {
+    val results = mutableListOf<List<Int>>()
+    if (root == null) return results
+    val queue = ArrayDeque<TreeNode>()
+    queue.addLast(root)
+    // Odd: left to right, even: right to left
+    var level = 1
+    while (queue.isNotEmpty()) {
+        val size = queue.size
+        val list = LinkedList<Int>()
+        for (i in 0 until size) {
+            val node = queue.removeFirst()
+            if (level % 2 != 0) {
+                list.add(node.`val`)
+            } else {
+                list.addFirst(node.`val`)
+            }
+            if (node.left != null) {
+                queue.addLast(node.left)
+            }
+            if (node.right != null) {
+                queue.addLast(node.right)
+            }
+        }
+        results.add(list)
+        level++
+    }
+
+    return results
+}
+```

leetcode/1046.last-stone-weight.md

@@ -0,0 +1,20 @@
+## [1046. Last Stone Weight](https://leetcode.com/problems/last-stone-weight)
+
+```kotlin
+fun lastStoneWeight(stones: IntArray): Int {
+    val maxHeap = PriorityQueue<Int>() { n1, n2 -> n2 - n1 }
+    for (stone in stones) maxHeap.add(stone)
+
+    while (maxHeap.isNotEmpty()) {
+        val first = maxHeap.poll()
+        if (maxHeap.isEmpty()) return first
+        val second = maxHeap.poll()
+
+        if (first != second) maxHeap.add(abs(first - second))
+    }
+    return 0
+}
+```
+
+* **Time Complexity**: `O(n lg n)`, comparsion take `n - 1` times and every time take `lg n` to poll the largest two stones.
+* **Space Complexity**: `O(n)`.

leetcode/124.binary-tree-maximum-path-sum.md

@@ -45,6 +45,10 @@ class Solution {
     }
 }
 ```
+
+* **Time Complexity**: `O(n)`.
+* **Space Complexity**: `O(n)`.
+
 ### Failed Cases
 ```js
     -2
@@ -58,4 +62,8 @@ class Solution {
   -2
   / \
  1   3
+```
+
+```js
+-3
 ```

leetcode/1642.furthest-building-you-can-reach.md

@@ -0,0 +1,49 @@
+## [1642. Furthest Building You Can Reach](https://leetcode.com/problems/furthest-building-you-can-reach)
+
+We use ladder first if we have enough ladder, but if we don't have enough ladder, then we change the smallest height difference to use brick if the number of brick is enough for that smallest height difference.
+
+```js
+    [6, 5, 5, 10, 12, 100, 106, 208, 207, 208], 10 bricks, 2 ladders
+diff   -1, 0,  5,  2,  82,   6, 102, -1,    
+                        *         *
+             // We should use ladder here
+```
+
+```kotlin
+fun furthestBuilding(heights: IntArray, bricks: Int, ladders: Int): Int {
+    var furthestIndex = 0
+    val minHeap = PriorityQueue<Int>()
+    var remainingBricks = bricks
+
+    // Iterate i from the 2nd height to that last
+    for (i in 1 until heights.size) {
+        // Calculate the height diffence
+        val heightDiff = heights[i] - heights[i - 1]
+
+        // If difference <= 0, we can move without any bricks or ladders
+        if (heightDiff <= 0) {
+            furthestIndex = i
+        } else {
+            minHeap.add(heightDiff)
+            // We have enough ladder, just use it
+            if (minHeap.size <= ladders) {
+                furthestIndex = i
+            } else {
+                // We don't have enough ladder, then try to change
+                // the smallest height difference
+                // to use the remaining brick.
+                if (minHeap.isNotEmpty() && minHeap.peek() <= remainingBricks) {
+                    remainingBricks -= minHeap.poll()
+                    furthestIndex = i
+                } else {
+                    break
+                }
+            }
+        }
+    }
+    return furthestIndex
+}
+```
+
+* **Time Complexity**: `O(n lg k)`, `k` is the number of ladders.
+* **Space Complexity**: `O(lg k)`

leetcode/17.letter-combinations-of-a-phone-number.md

@@ -1,7 +1,7 @@
 ## [17. Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/)
 
 ```kotlin
-private val letterMapping = hashMapOf<String, String>(
+private val mapping = hashMapOf<String, String>(
     "2" to "abc",
     "3" to "def",
     "4" to "ghi",
@@ -11,29 +11,24 @@ private val letterMapping = hashMapOf<String, String>(
     "8" to "tuv",
     "9" to "wxyz"
 )
-
 private val results = mutableListOf<String>()
 
 fun letterCombinations(digits: String): List<String> {
     if (digits.isEmpty()) return results
-    val lettersList = mutableListOf<String>()
-    for (digit in digits) {
-        lettersList.add(letterMapping[digit.toString()]!!)
-    }
-    dfs(lettersList, mutableListOf<String>())
+    dfs(digits, 0, mutableListOf<String>())
     return results
 }
 
-private fun dfs(lettersList: List<String>, combination: MutableList<String>) {
-    if (combination.size == lettersList.size) {
+private fun dfs(digits: String, index: Int, combination: MutableList<String>) {
+    if (combination.size == digits.length) {
         results.add(combination.joinToString(""))
-        return 
+        return
     }
 
-    val letters = lettersList[combination.size]
+    val letters = mapping[digits[index].toString()]!!
     for (letter in letters) {
         combination.add(letter.toString())
-        dfs(lettersList, combination)
+        dfs(digits, index + 1, combination)
         combination.removeAt(combination.size - 1)
     }
 }

leetcode/207.course-schedule.md

@@ -1,5 +1,6 @@
 ## [207. Course Schedule](https://leetcode.com/problems/course-schedule/)
 
+### DFS
 The problem is equivalent to detect a cycle in a directed graph. If there exists a cycle, then we can't find the topological sort.
 
 ```kotlin
@@ -48,6 +49,65 @@ class Solution {
 }
 ```
 
+* **Time Complexity**: `O(m + n)`, `m` is the number of courses, `n` is the number of prerequisites.
+* **Space Complexity**: `O(m + n)`, we build a adjacent list that takes `O(m + n)`, and enque all courses that takes `O(n)`.
+
+### BSF
+BFS approach uses the indegrees of every vertex, for a course (vertex), the indegrees represents how many prerequisites we have to take before so that we can finish the current one.
+
+For example, the `prerequisites` is `[[2, 0], [2, 1]]`, that means that I have to finish course `0` and `1` so that I can finish `2`, that can be represented in graph like this:
+
+```js
+0 -> 2
+1 -> 2
+```
+
+So course (vertex) `2` has 2 indegree edges, and the number of indegrees is `2`.
+
+To solve this problem, we build a graph with indegree array for every courses (vertices), and enqueue course if I finish all its prerequisites, and count how many courses did I finished.
+
+```kotlin
+fun canFinish(numCourses: Int, prerequisites: Array<IntArray>): Boolean {
+    val edges = Array<MutableList<Int>>(numCourses) { _ -> mutableListOf<Int>() }
+
+    val inDegrees = IntArray(numCourses)
+    for (p in prerequisites) {
+        val before = p[1]
+        val after = p[0]
+        // p[1] -> p[0]
+        edges[before].add(after)
+        inDegrees[after]++
+    }
+
+    // Queue enques all the course that we can study now. (no or finished all prerequisites)
+    val queue = ArrayDeque<Int>()
+    for (i in 0 until numCourses) {
+        // Study all the courses without any prerequisites.
+        if (inDegrees[i] == 0) queue.addLast(i)
+    }
+
+    var studiedCourses = 0
+    while (queue.isNotEmpty()) {
+        val course = queue.removeFirst()
+        studiedCourses++
+
+        // Find all courses after the current course
+        edges[course].forEach { afterCourse ->
+            inDegrees[afterCourse]--
+
+            // If all prerequiistes are finished, then I can study this after course.
+            if (inDegrees[afterCourse] == 0) {
+                queue.addLast(afterCourse)
+            }
+        }
+    }
+    return studiedCourses == numCourses
+}
+```
+
+* **Time Complexity**: As same as DFS.
+* **Space Complexity**: As same as DFS.
+
 ### Clarification Questions
 1. Are all the prerequisites pair unique?
 2. What if `prerequisites` is empty? (but `numCourses` is 1 or greater than 1)

leetcode/2115.find-all-possible-recipes-from-given-supplies.md

@@ -0,0 +1,138 @@
+## [2115. Find All Possible Recipes from Given Supplies](https://leetcode.com/problems/find-all-possible-recipes-from-given-supplies)
+
+Suppose we the following recipes, ingredients and supplies:
+```js
+Recipes = [R2, R1]
+Ingredients = [[C, R1, D, B], [A, B]]
+Supplies = [A, B, C, D]
+```
+
+For each recipe `recipes[i]`, we have the `ingredients[i]` that can make it, we take them as edges from ingredient to recipe:
+
+```js
+// Graph (visualization)
+C, R1, D, B => R2
+A, B        => R1
+```
+
+And we can use topological sort to find out what recipes can be made from our ingredients, supplies and even recipes we just have made it.
+
+So we build the graph from ingredients and count the indegrees for every recipes, and run BFS.
+```js
+// Graph (data structure)
+C: [R2]
+R1:[R2]
+D: [R2]
+B: [R2, R1]
+A: [R1]
+
+// Indegrees:
+R2: 4
+R1: 2
+```
+
+### Topological Sort (BFS)
+```kotlin
+fun findAllRecipes(recipes: Array<String>, ingredients: List<List<String>>, supplies: Array<String>): List<String> {
+    val graph = hashMapOf<String, MutableList<String>>()
+    val indegrees = hashMapOf<String, Int>()
+    for (i in 0 until ingredients.size) {
+        for (ingredient in ingredients[i]) {
+            if (!graph.containsKey(ingredient)) graph[ingredient] = mutableListOf<String>()
+            graph[ingredient]!!.add(recipes[i])
+        }   
+        indegrees[recipes[i]] = ingredients[i].size
+    }
+
+    val queue = ArrayDeque<String>()
+    for (supply in supplies) {
+        queue.addLast(supply)
+    }
+
+    val results = mutableListOf<String>()
+    while (queue.isNotEmpty()) {
+        val current = queue.removeFirst()
+        graph[current]?.forEach { r ->
+            var indegree = indegrees[r]!!
+            // Remember to check this, it means not finished.
+            if (indegree > 0) {
+                indegree--
+                // We can make it
+                if (indegree == 0) {
+                    results.add(r)
+                    queue.addLast(r)
+                }
+                indegrees[r] = indegree
+            }
+        }
+    }
+    return results
+}
+```
+
+* **Time Complexity**: `O(R*I + S + R)` = `O(R*I + S)` where `R`, `I`, `S` represent the number of recipes, ingredients and supplies.
+* **Space Complexity**: `O(R*I + S)` for graph and queue.
+
+### ~~Brute Force~~
+```kotlin
+fun findAllRecipes(recipes: Array<String>, ingredients: List<List<String>>, supplies: Array<String>): List<String> {
+
+    val finishedRecipes = hashSetOf<String>()
+    val suppliesSet = hashSetOf<String>()
+    for (s in supplies) { suppliesSet.add(s) }
+
+    var recipeIndex = 0
+    while (recipeIndex < recipes.size) {
+        if (finishedRecipes.contains(recipes[recipeIndex])) {
+            recipeIndex++
+            continue
+        }
+        val ingredient = ingredients[recipeIndex]
+        var canMake = true
+        for (i in 0 until ingredient.size) {
+            if (!suppliesSet.contains(ingredient[i]) && !finishedRecipes.contains(ingredient[i])) {
+                canMake = false
+                break
+            }
+        }
+
+        if (canMake) {
+            finishedRecipes.add(recipes[recipeIndex])
+            recipeIndex = 0
+        } else {
+            recipeIndex++
+        }
+    }
+    return ArrayList<String>(finishedRecipes)
+}
+```
+
+* **Time Complexity**: `O(S + R^2 * I)`, where `R`, `I` and `S` represents the number of recipes, the max length in `ingredient[i]`, and the number of supplies.
+* **Space Complexity**: `O(R + S)`.
+
+
+```js
+// Recipes = [R2, R1]
+// Ingredients = [[C, R1, D, B], [A, B]]
+// Supplies = [A, B, C, D]
+
+// Graph (visualization)
+// C, R1, D, B => R2
+// A, B        => R1
+
+// Graph (data structure)
+C: [R2]
+R1:[R2]
+D: [R2]
+B: [R2, R1]
+A: [R1]
+
+// Indegrees:
+R2: 0
+R1: 0
+
+Queue: , , , , R2
+Current: R2
+
+Results: R1, R2
+```