---
description: Binary Search
---

# LeetCode 1760. Minimum Limit of Balls in a Bag



You are given an integer array `nums` where the `ith` bag contains `nums[i]` balls. You are also given an integer `maxOperations`.

You can perform the following operation at most `maxOperations` times:

* Take any bag of balls and divide it into two new bags with a **positive** number of balls.
  * For example, a bag of `5` balls can become two new bags of `1` and `4` balls, or two new bags of `2` and `3` balls.

Your penalty is the **maximum** number of balls in a bag. You want to **minimize** your penalty after the operations.

Return _the minimum possible penalty after performing the operations_.

**Example 1:**

```
Input: nums = [9], maxOperations = 2
Output: 3
Explanation: 
- Divide the bag with 9 balls into two bags of sizes 6 and 3. [9] -> [6,3].
- Divide the bag with 6 balls into two bags of sizes 3 and 3. [6,3] -> [3,3,3].
The bag with the most number of balls has 3 balls, so your penalty is 3 and you should return 3.
```

**Example 2:**

```
Input: nums = [2,4,8,2], maxOperations = 4
Output: 2
Explanation:
- Divide the bag with 8 balls into two bags of sizes 4 and 4. [2,4,8,2] -> [2,4,4,4,2].
- Divide the bag with 4 balls into two bags of sizes 2 and 2. [2,4,4,4,2] -> [2,2,2,4,4,2].
- Divide the bag with 4 balls into two bags of sizes 2 and 2. [2,2,2,4,4,2] -> [2,2,2,2,2,4,2].
- Divide the bag with 4 balls into two bags of sizes 2 and 2. [2,2,2,2,2,4,2] -> [2,2,2,2,2,2,2,2].
The bag with the most number of balls has 2 balls, so your penalty is 2 an you should return 2.
```

**Example 3:**

```
Input: nums = [7,17], maxOperations = 2
Output: 7
```

**Constraints:**

* `1 <= nums.length <= 10^5`
* `1 <= maxOperations, nums[i] <= 10^9`

## Solution:

[English Version in Youtube](https://youtu.be/5RLgPa7TWMY)

[中文版解答Youtube Link](https://youtu.be/C2s5lMLwyBE)

[中文版解答Bilibili Link](https://www.bilibili.com/video/BV1wb4y1R7F5/)

```
class Solution {
    
    bool check(const vector<int>& nums, int maxOperations, int penalty) {
        int ops = 0;
        for (int num : nums) {
            ops += (num-1) / penalty;
        }
        return ops <= maxOperations;
    }
    
public:
    int minimumSize(vector<int>& nums, int maxOperations) {
        int left = 1, right = *max_element(nums.begin(), nums.end());
        
        while (left < right) {
            int mid = (left + right) / 2;
            
            bool can_do_it = check(nums, maxOperations, mid);
            
            if (can_do_it) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        
        return left;
    }
};
```
