Add new heap problems

Author: enginebai

leetcode/1405.longest-happy-string.md

@@ -0,0 +1,48 @@
+# [1405. Longest Happy String](https://leetcode.com/problems/longest-happy-string/description/)
+
+## Heap (Greedy)
+This is the follow-up question of [984. String Without AAA or BBB](../leetcode/984.string-without-aaa-or-bbb.md), we can use the same idea to solve this:
+1. If the count of first > second: "first * 2 second" (like "aab")
+2. If the count is the same: "first, second" (like "ab")
+
+```kotlin
+fun longestDiverseString(a: Int, b: Int, c: Int): String {
+    val count = intArrayOf(a, b, c)
+    val maxHeap = PriorityQueue<Int> { i1, i2 -> 
+        val c1 = count[i1]
+        val c2 = count[i2]
+        if (c1 == c2) i1 - i2
+        else c2 - c1
+    }
+    (0..2).forEach { 
+        if (count[it] > 0) maxHeap.add(it)
+    } 
+    val str = StringBuilder()
+    while (maxHeap.size >= 2) {
+        val i1 = maxHeap.poll()
+        val i2 = maxHeap.poll()
+        val char1 = 'a' + i1
+        var char2 = 'a' + i2
+
+        // first > second: "first * 2 second"
+        if (count[i1] > count[i2]) {
+            str.append("${char1}${char1}${char2}")
+            count[i1] -= 2
+            count[i2] -= 1
+        } else { // "first, second"
+            str.append("${char1s}${char2}")
+            count[i1] -= 1
+            count[i2] -= 1
+        }
+        if (count[i1] > 0) maxHeap.add(i1)
+        if (count[i2] > 0) maxHeap.add(i2)
+    }
+    // Append the last one character at most 2 times
+    if (maxHeap.isNotEmpty()) {
+        val i1 = maxHeap.poll()
+        val c1 = min(count[i1], 2)
+        str.append(('a' + i1).toString().repeat(c1))
+    }
+    return str.toString()
+}
+```

leetcode/1834.single-threaded-cpu.md

@@ -0,0 +1,84 @@
+# [1834. Single-Threaded CPU](https://leetcode.com/problems/single-threaded-cpu/description/)
+
+## Simulation + Heap
+We can simulate the time elapse by starting the time from 0 and increment, we can sort the tasks by enqueue time so that we can enqueue task to available tasks for CPU processing as time elapses. **But before we sort the tasks, we need to keep the original index of the task so that we can return the order of the tasks.**
+
+If CPU is idle, and the available tasks is empty (no task to process now), we can advance the current time to the next task's enqueue time. (B, and C as example)
+```js
+time:
+           t---->t
+     1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+     A----->
+                 B-------->
+                 C----->
+                             D-->  
+```
+
+If the all the tasks which enqueue time <= current time, we can add those tasks to the available tasks for CPU processing. (B, C as example) We can't add `D` because its enqueue time is 9, and the current time is 6.
+```js
+time:
+                    t
+     1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+     ...
+                 B-------->
+                 C----->
+                             D-->             
+```
+
+After adding tasks to the available tasks, we can process the task with the smallest processing time first, we can use a min heap to store the available tasks to find the task with the smallest processing time. We process the task by polling task from the min heap, advance the current time by the processing time of that task, and add the original index of the task to the order list.
+
+We can keep adding tasks to the available tasks or process the task with the smallest processing time until all the tasks are processed.
+
+```kotlin
+data class Task(
+    val enqueueTime: Int,
+    val processingTime: Int,
+    val originalIndex: Int
+)
+
+fun getOrder(originalTasks: Array<IntArray>): IntArray {
+    // We build the tasks with original index
+    val tasks = originalTasks.mapIndexed { index, task ->
+        Task(task[0], task[1], index)
+    }.toTypedArray()
+
+    val n = tasks.size
+    val order = mutableListOf<Int>()
+    val availableTasks = PriorityQueue<Task>() { t1, t2 ->
+        if (t1.processingTime == t2.processingTime) {
+            t1.originalIndex - t2.originalIndex
+        } else {
+            t1.processingTime - t2.processingTime
+        }
+    }
+    tasks.sortBy { it.enqueueTime }
+
+    var i = 0
+    var currentTime = 0
+    while (i < n || availableTasks.isNotEmpty()) {
+        // We add tasks to available tasks if the enqueue time <= current time
+        while (i < n && tasks[i].enqueueTime <= currentTime) {
+            availableTasks.add(tasks[i])
+            i++
+        }
+
+        // If CPU is idle, and no task to process now, we can advance the current time to the next task's enqueue time
+        if (i < n && availableTasks.isEmpty()) {
+            currentTime = tasks[i].enqueueTime
+            continue
+        }
+        
+        // We process the task with the smallest processing time first, we can update
+        // the process order and advance the current time
+        if (availableTasks.isNotEmpty()) {
+            val processTask = availableTasks.poll()
+            order.add(processTask.originalIndex)
+            currentTime += processTask.processingTime
+        }
+    }
+    return order.toIntArray()
+}
+```
+
+* **Time Complexity:** `O(n log n)`, where `n` is the number of tasks. We need to sort the tasks by enqueue time, and we need to add tasks to the available tasks for CPU processing, which takes O(logN) time.
+* **Space Complexity:** `O(n)`, where `n` is the number of tasks. We need to store the tasks, available tasks, and order list.

leetcode/1845.seat-reservation-manager.md

@@ -0,0 +1,60 @@
+# [1845. Seat Reservation Manager](https://leetcode.com/problems/seat-reservation-manager/submissions/)
+
+## Heap
+We initailze a priority queue with all the seats. When we reserve a seat, we poll the top element from the queue. When we unreserve a seat, we add the seat number back to the queue.
+```kotlin
+class SeatManager(private val n: Int) {
+
+    private val seats = PriorityQueue<Int>()
+
+    init {
+        (1..n).forEach {
+            seats.add(it)
+        }
+    }
+
+    fun reserve(): Int {
+        return seats.poll()
+    }
+
+    fun unreserve(seatNumber: Int) {
+        seats.add(seatNumber)
+    }
+
+}
+```
+
+* **Time Complexity:** `O(log n)` for reserve and unreserve operations, and `O(n)` for initialization, total is `O(n log n)`.
+* **Space Complexity:** `O(n)` for priority queue.
+
+Another solution is to use a marker variable, if we don't unreverse the seat, then the smallest-numbered unreserved seat is always monotonic increasing. We can use a variable to store the smallest unreserved seat number, and increase it by 1 when we reserve a seat.
+
+It guarantees that we invoke `unreserve(x)` after `reserve()`, so `x < marker`. We use a min heap to maintain the unreserved seats, similar idea as [2336. Smallest Number in Infinite Set](../leetcode/2336.smallest-number-in-infinite-set.md).
+
+```js
+1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
+            |---> marker
+|--heap--|
+```
+
+```kotlin
+class SeatManager(private val n: Int) {
+
+    private var marker = 1
+    private val unreservedSeats = PriorityQueue<Int>()
+    
+    fun reserve(): Int {
+        if (unreservedSeats.isEmpty()) {
+            return marker++
+        }
+        return unreservedSeats.poll()
+    }
+
+    fun unreserve(seatNumber: Int) {
+        unreservedSeats.add(seatNumber)
+    }
+}
+```
+
+* **Time Complexity:** `O(log n)` for reserve and unreserve operations, and `O(1)` for initialization, total is `O(n log n)`.
+* **Space Complexity:** `O(q)` for priority queue.

leetcode/2336.smallest-number-in-infinite-set.md

@@ -0,0 +1,108 @@
+# [2336. Smallest Number in Infinite Set](https://leetcode.com/problems/smallest-number-in-infinite-set/description/)
+
+## Test Cases
+### Edge / Corner Cases
+```js
+1, 2, 3, 4, 5
+X  X  X  X  O // pop 4 times
+
+1, 2, 3, 4, 5
+X  O  O  X  O // add 2, 3 back
+
+pop() = 2
+pop() = 3
+pop() = 5 // It's 5, not 4
+```
+
+```js
+add(2) // add the number that is still in the set
+pop() = 1
+```
+
+## Heap + Set (or `TreeSet`)
+We can add all possible numbers to the set as the initial set, and use a minimum heap to find the smallest number in the set, including the numbers that are added back. But this approach is not efficient, because the set could be infinite.
+
+How can we solve this problem efficiently? Let's break down the problem:
+* If we don't add number back, we can just use a variable to store the current smallest number in the infinite set. 
+* If we support adding numbers back, we need a data structure that can find the smallest number dynamically, which is heap. And we need a set to avoid duplicate adding. So if we add the number back, we can add it to the heap and set.
+
+```js
+1, 2, 3, 4, 5, 6, ...
+X  X  X  X  |
+            | -----> // handle by `num`
+            num
+  <------|  
+// handle by heap and set 
+```
+
+To summarize to our approach:
+* `popSmallest()`: we check if heap is empty, if not, there are some numbers added back, we just pop the smallest number from the heap. If the heap is empty, we return the current smallest number in the infinite set, that is maintained by a variable.
+* `addBack(number)`: we check if the number is still in the infinite set, if not, we add it to the heap and set.
+
+```js
+1, 2, 3, 4, 5, 6, ...
+X  X  X  X  |
+            | 
+            num
+               add(6) // num < 6: It's still in the infinite set
+
+add(1) // add 1 to heap and set
+pop() = 1
+            pop() = 5
+```
+
+```kotlin
+class SmallestInfiniteSet() {
+    // The smallest number in the infinite set.
+    private var currentSmallest = 1
+
+    // The heap and set to store the numbers that are added back.
+    private val minHeap = PriorityQueue<Int>()
+    private val set = HashSet<Int>()
+
+    fun popSmallest(): Int {
+        // If we have added some numbers back, we just pop the smallest number from the heap.
+        if (set.isNotEmpty()) {
+            val value = minHeap.poll()
+            set.remove(value)
+            return value
+        } else {
+            // Otherwise, we just return the current smallest number in the infinite set.
+            return currentSmallest++
+        }
+    }
+
+    fun addBack(number: Int) {
+        if (currentSmallest <= number || // If we add the number that is still in the infinite set.
+            set.contains(number)) { // Or we add the number that is already added back.
+            return
+        }
+
+        set.add(number)
+        minHeap.add(number)
+    }
+}
+
+// Or equivalently using TreeSet
+class SmallestInfiniteSet() {
+    private val set = TreeSet<Int>() // To store the numbers that are removed and added back
+    private var currentSmallest = 1
+
+    fun popSmallest(): Int {
+        if (set.isNotEmpty()) {
+            val value = set.pollFirst()
+            return value
+        } else {
+            return currentSmallest++
+        }
+    }
+
+    fun addBack(number: Int) {
+        if (currentSmallest <= number || set.contains(number)) return
+        set.add(number)
+    }
+}
+```
+
+* **Time Complexity:** `O(log n)` for `popSmallest()`, `O(log n)` for `addBack()`
+* **Space Complexity:** `O(n)`