Add solutions to new binary search problem

Author: enginebai

.cursor/rules/note-items.mdc

@@ -3,9 +3,9 @@ description:
 globs: 
 alwaysApply: true
 ---
-## My Notes
+## Note Items
 
-If I'm asking you to help modify or improve my notes, please provide:
+If I'm asking you to help modify or improve my notes, please provide the following sections and notes:
 
 ### Hints
 - A lightweight nudge without revealing too much.
@@ -14,6 +14,7 @@ If I'm asking you to help modify or improve my notes, please provide:
 ### Breakdowns
 - Break down the problem into smaller, simpler sub-problems.
 - Answer questions like: _"Can we solve a simpler version first?"_ or _"Can we divide the problem into smaller steps?"_
+
 ### Key Insights
 - Share the intuitions and key observations that lead to different approaches.
 - Explain _how to come up with the idea_. When is it a good idea to think of this technique? I want to know the thought process and train my instinct when encountering new problems.

.cursor/rules/note-overall.mdc

@@ -3,12 +3,27 @@ description:
 globs: 
 alwaysApply: true
 ---
-## Overall
+## Overall Rules for Notes
 - I'm practicing LeetCode in **Kotlin**. Please always give me **Kotlin** solutions.
 - Please **keep the Kotlin code simple and clean**, preferring interview-friendly style (no unnecessary Kotlin tricks or extension functions).
-- For **binary search**, always use the inclusive search range: `while (left <= right)`.
 - You must **search on `leetcode.com` and `leetcode.cn`** for that problem, find the most **popular and up-voted solutions**, **summarize them**, and **provide the best one**, if there are multiple popular solutions, please also include them. (At most 3 solutions)
-- If there are valuable insights from **up-voted comments** (in either Chinese or English), please also include them.
 - Please **reference any related online resources** if helpful, and ensure the final solution is **correct (AC)** and **robust across edge cases**.
+- If there are valuable insights from **up-voted comments** (in either Chinese or English) during the search, please also include them.
 - Please use the word "two pointers", not "two-pointer" or "two-pointers" in any description.
-- If the descriptions are sentence, please add `.` at the end of sentence, especially for single sentence.
+- If the descriptions are sentence, please add `.` at the end of sentence, especially for single sentence.
+
+## Existing Note (If Exists)
+- If I have some existing notes / implementations / WA, please preserve it in a clearly labeled "My Original Notes" section at the end of the file. Then also provide your implementation with comments or explain (from your search result above) 
+- For the existing notes reference, please use file link `@[email protected]`, don't prefix `mdc:leetcode/`, and please verify to ensure that file exists from the link reference.
+- For the implementation, don't write the line comment: `// Used in solutions`.
+
+> The following sections is topic specific, please always follow if the problem or approach fits the topic
+
+## Binary Search
+- For **binary search**, always use the inclusive search range: `while (left <= right)`.
+- Please always elaborate further the key intuition, explain how to observe/analyze/breakdown the problem and figure out that we can solve this problem by binary search approach.
+- For the problem type: "binary search on value", please always provide the following items in `Key Insights` section:
+    - Monotonicity
+    - Lower bound
+    - Upper bound
+    - Feasibility

leetcode/1283.find-the-smallest-divisor-given-a-threshold.md

@@ -0,0 +1,72 @@
+# [1283. Find the Smallest Divisor Given a Threshold](https://leetcode.com/problems/find-the-smallest-divisor-given-a-threshold/)
+
+## Hints
+- What happens to the sum if you increase the divisor? Try a few examples.
+- Can you check if a given divisor is feasible in `O(n)`?
+
+## Key Insights
+The core intuition is to recognize that as the divisor increases, the sum of all `ceil(num / divisor)` strictly decreases. This is because dividing by a larger number always produces a smaller (or equal) result for each element, and rounding up preserves this monotonicity. This monotonic relationship is the key to applying binary search.
+
+How do we observe this?
+- Try a few divisors by hand from linear search: for small divisors, the sum is large; for large divisors, the sum is small.
+- For example, with `nums = [1,2,5,9]` and `threshold = 6`,
+    - divisor = 1: sum = 17
+    - divisor = 4: sum = 7
+    - divisor = 5: sum = 5
+    - As divisor increases, sum decreases.
+
+How do we analyze the feasibility?
+- For any fixed divisor, we can check in `O(n)` if the sum of all `ceil(num / divisor)` is `<= threshold`.
+- If a divisor is feasible (sum <= threshold), then any larger divisor will also be feasible (sum will be even smaller).
+- If a divisor is not feasible, any smaller divisor will also not be feasible (sum will be even larger).
+
+**Summary:**
+- When you see a problem where increasing a parameter makes a condition easier/harder in a predictable way, and you can check feasibility efficiently, consider binary search on that parameter.
+- Here, the divisor is the parameter, and the sum is monotonic with respect to it, so binary search is the optimal approach.
+
+## Binary Search
+Use binary search to find the smallest divisor such that the sum of all `ceil(num / divisor)` is `<= threshold`.
+
+- Monotonicity: `divisor` is greater, `sum` is less <= `threshold`, more feasible.
+- Lower bound: `1`, smallest possible divisor.
+- Upper bound: `max(nums)`, the number can divide all numbers into `1` (the sum is the sum of all numbers).
+- Feasibility: For a given divisor, is the sum of all `ceil(num / divisor)` <= `threshold`?
+
+> For the check, you can use integer math: `ceil(num / divisor)` is equivalent to `(num + divisor - 1) / divisor`.
+
+```kotlin
+fun smallestDivisor(nums: IntArray, threshold: Int): Int {
+    var left = 1
+    var right = nums.max()
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+        val feasible = check(nums, threshold, middle)
+        if (feasible) {
+            right = middle - 1
+        } else {
+            left = middle + 1
+        }
+    }
+    return left
+}
+
+private fun check(nums: IntArray, threshold: Int, divisor: Int): Boolean {
+    var sum = 0
+    for (num in nums) {
+        sum += ceil(num * 1f / divisor * 1f).toInt()
+    }
+    return sum <= threshold
+}
+```
+
+- **Time Complexity**: `O(n * log m)`, where `n` is the length of `nums`, `m` is the maximum value in `nums`.
+- **Space Complexity**: `O(1)`.
+
+## Edge Cases & Pitfalls
+- `nums` contains only one element: The answer is `ceil(nums[0] / threshold)`.
+- `threshold` is equal to `nums.size`: The answer is `max(nums)`.
+- All elements in `nums` are the same: The answer is `ceil(nums[0] * nums.size / threshold)`.
+- **Large values**: Make sure to avoid integer overflow in the sum calculation.
+
+## Pitfalls
+- Forgetting to use integer math for `ceil(num / divisor)`, which can lead to floating-point errors or inefficiency.

leetcode/153.find-minimum-in-rotated-sorted-array.md

@@ -1,8 +1,5 @@
 ## [153. Find Minimum in Rotated Sorted Array](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/)
 
-## Clarification Questions
-* Is the input array empty?
- 
 ## Test Cases
 ### Normal Cases
 ```

leetcode/1760.minimum-limit-of-balls-in-a-bag.md

@@ -0,0 +1,108 @@
+# [1760. Minimum Limit of Balls in a Bag](https://leetcode.com/problems/minimum-limit-of-balls-in-a-bag/description/)
+
+## Hints
+- What happens to the number of operations if you decrease the allowed maximum size of a bag?
+- Can you check if a given maximum size is feasible in `O(n)`?
+
+## Breakdowns
+> 1. Can we check if a given maximum size is feasible with at most `maxOperations` splits?
+
+Try simulating the process: for each bag, how many splits are needed to make all resulting bags ≤ the given size?
+
+## Key Insights
+> NOTE: `penalty` is the maximum size of the bag.
+
+- The key is to realize that as the allowed `penalty` decreases, we need more splits, the number of required operations (splits) increases. This is a classic monotonic property.
+- If the total operations needed is ≤ `maxOperations`, then `penalty` is feasible. If not, we need to allow a larger `penalty`.
+- For a given `penalty`, the number of operations needed is the sum over all bags of `parts - 1`, which is `ceil(num / penalty) - 1`. This counts how many splits are needed for each bag to ensure all resulting bags are ≤ `penalty`:
+
+```js
+penalty = 3
+ 8 = [3, 3, 2]          3 - 1
+ 9 = [3, 3, 3]          3 - 1
+10 = [3, 3, 3, 1]       4 - 1
+11 = [3, 3, 3, 2]       4 - 1
+12 = [3, 3, 3, 3]       4 - 1
+13 = [3, 3, 3, 3, 1]    5 - 1
+```
+
+As above example, 13 needs 5 parts `ceil(13 / 3) = 5`, it needs 4 operations. 
+
+> For each bag, the number of splits needed to make all resulting bags ≤ penalty is `(num - 1) / penalty`. This avoids floating point and is more efficient than using `ceil(num / penalty) - 1`.
+
+## Binary Search
+- **Monotonicity**: If a penalty is feasible, any larger penalty is also feasible. If not, any smaller penalty is not feasible.
+- **Lower bound**: `1`, we split as much as possible.
+- **Upper bound**: `max(nums)` (no split).
+- **Feasibility**: Given a `penality`, can we split the balls so that maximum of all balls ≤ `penality` and operations ≤ `maxOperations`?
+
+```kotlin
+fun minimumSize(nums: IntArray, maxOperations: Int): Int {
+    val maxOperations = maxOperations.toLong()
+    var left = 1L
+    var right = nums.max().toLong()
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+        val feasible = check(nums, maxOperations, middle)
+        if (feasible) {
+            right = middle - 1
+        } else {
+            left = middle + 1
+        }
+    }
+    return left.toInt()
+}
+
+private fun check(nums: IntArray, maxOperations: Long, max: Long): Boolean {
+    var operations = 0L
+    for (num in nums) {
+        val parts = ceil(num * 1.0 / max).toInt()
+        operations += parts - 1
+    }
+    return operations <= maxOperations
+}
+```
+
+- **Time Complexity**: `O(n * log(max(nums)))`, where `n` is the number of bags.
+- **Space Complexity**: `O(1)`.
+
+## Edge Cases
+- All bags are already ≤ the answer: No operation needed.
+- `maxOperations` is 0: The answer is `max(nums)`.
+- **Large values in `nums`**: Use integer division to avoid overflow and floating point errors.
+- Only one bag: The answer is `ceil(num / (maxOperations + 1))`.
+
+## WA
+My original idea is `9` = `[8,1] / [7,2] / [6,3] / [5,4]`, `num / 2` leads optimal split.
+
+But splitting into equal halves is not optimal, for example, `9 -> [4, 5] -> [2, 2, 5] -> [2, 2, 2, 3]` which needs 3 operations. But `9 -> [6, 3] -> [3, 3, 3]` which needs 2 operations that is optimal.
+
+```kotlin
+private fun checkWA(nums: IntArray, maxOperations: Long, max: Long): Boolean {
+    var operations = 0L
+    val maxHeap = PriorityQueue(reverseOrder<Int>())
+    for (num in nums) {
+        maxHeap.add(num)
+    }
+    /** 
+    Give a number, how many operations are needed to split num <= max
+    9 -> [5, 4] -> [2, 3, 4] -> [2, 3, 2, 2]
+
+    7 -> [4, 3] -> [2, 2, 3]
+    num / 2
+
+    [2, 4, 8, 2]
+
+    
+    */ 
+    while (maxHeap.peek() > max) {
+        val num = maxHeap.poll()
+        val half = num / 2
+        maxHeap.add(half)
+        maxHeap.add(num - half)
+        operations++
+        if (operations > maxOperations) return false
+    }
+    return operations <= maxOperations
+}
+```

leetcode/2439.minimize-maximum-of-array.md

@@ -0,0 +1,144 @@
+# [2439. Minimize Maximum of Array](https://leetcode.com/problems/minimize-maximum-of-array/description/)
+
+## Hints
+- What happens if you always move excess from right to left?
+- Can you check if a given maximum value is feasible using a greedy simulation?
+- Is there a way to relate the answer to prefix sums or averages?
+
+## Breakdowns
+> 1. Can we check if a given value is feasible as the maximum after all operations?
+
+Try simulating the process from right to left, moving excess to the left. If the first element can be kept ≤ threshold, it's feasible.
+
+> 2. Is there a direct formula for the answer?
+
+Notice that after all possible operations, the array becomes as flat as possible. The answer is the maximum of all prefix averages (rounded up).
+
+## Key Insights
+- The operation allows you to move any excess from right to left, so the leftmost elements can absorb all surplus.
+- The minimum possible maximum is determined by the largest prefix average (since you can't make the prefix sum smaller than its average).
+- (TODO) There is also a direct greedy solution using prefix averages, which is more efficient and elegant.
+
+## Binary Search
+- **Monotonicity**: If a value is feasible, any larger value is also feasible.
+- **Lower bound**: The minimum value in the array would be acceptable. (Consider the single element case)
+- **Upper bound**: The maximum value in the array. (Without any modification)
+- **Feasibility**: There are two ways to check if a value is feasible:
+    - Check 1: Check if we have enough buffer to absorb all excess.
+    - Check 2: Simulate moving excess from right to left and check if the first element stays ≤ threshold.
+
+```kotlin
+fun minimizeArrayValue(nums: IntArray): Int {
+    var left = nums.min()
+    var right = nums.max()
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+        val feasible = check(nums, middle)
+        if (feasible) {
+            right = middle - 1
+        } else {
+            left = middle + 1
+        }
+    }
+    return left
+}
+
+// Check 1: Check if we have enough buffer to absorb all excess.
+private fun check(nums: IntArray, threshold: Int): Boolean {
+    var buffer = 0L
+    for (num in nums) {
+        buffer += (threshold - num).toLong()
+        if (buffer < 0L) return false
+    }
+    return true
+}
+
+// Or alternatively, check 2: Simulate moving excess from right to left and check if the first element stays ≤ threshold.
+private fun check2(nums: IntArray, threshold: Int): Boolean {
+    var excess = 0L
+    for (i in nums.size - 1 downTo 1) {
+        if (nums[i] + excess > threshold) {
+            excess = nums[i] + excess - threshold
+        } else {
+            // We can't pass negative excess to the left because:
+            // 1. The operation only allows moving excess from right to left
+            // 2. If we have a deficit (negative excess), we can't "borrow" from the left
+            // 3. The left elements can only absorb surplus, not create it
+            excess = 0L
+        }
+    }
+    return nums[0] + excess <= threshold
+}
+```
+
+- **Time Complexity**: `O(n log(max(nums)))`
+- **Space Complexity**: `O(1)`
+
+## Prefix Average (Optimal Greedy)
+
+> TODO: Understand this approach later.
+
+Key idea: The answer is the maximum of all prefix averages (rounded up).
+
+```kotlin
+fun minimizeArrayValue(nums: IntArray): Int {
+    var maxAvg = 0L
+    var prefixSum = 0L
+    for (i in nums.indices) {
+        prefixSum += nums[i]
+        val avg = (prefixSum + i) / (i + 1) // ceil division
+        maxAvg = maxOf(maxAvg, avg)
+    }
+    return maxAvg.toInt()
+}
+```
+
+- **Time Complexity**: `O(n)`
+- **Space Complexity**: `O(1)`
+
+## Edge Cases
+- All elements are the same: The answer is that value.
+- Large values at the end: The excess will be pushed to the leftmost element.
+- Single element: The answer is the element itself.
+- Very large input: Use `Long` for prefix sum to avoid overflow.
+
+## Pitfalls
+- **Forgetting to use `Long` for prefix sum or excess, causing overflow.**
+- **Not resetting excess to 0 when redistributing in the binary search check.**
+- Off-by-one error in prefix average calculation (should use `(prefixSum + i) / (i + 1)` for ceiling division).
+
+## WA
+```kotlin
+fun minimizeArrayValue(nums: IntArray): Int {
+    // Binary search bounds are correct - we search between min and max values
+    var left = nums.min()
+    var right = nums.max()
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+        val feasible = check(nums, middle)
+        if (feasible) {
+            right = middle - 1
+        } else {
+            left = middle + 1
+        }
+    }
+    return left
+}
+
+private fun check(nums: IntArray, threshold: Int): Boolean {
+    // ISSUE 1: Modifying input array directly is dangerous and can affect future checks
+    // ISSUE 2: The logic doesn't properly handle the case where we need to move values from right to left
+    var max = nums.last()
+    for (i in nums.size - 1 downTo 0) {
+        if (i > 0) {
+            while (nums[i - 1] < nums[i]) {
+                nums[i]--
+                nums[i - 1]++
+            }
+        }
+        max = maxOf(max, nums[i])
+        if (threshold < max) return false
+    }
+    return true
+}
+```