LeetCode 1760: Minimum Limit of Balls in a Bag

Problem Description

You are given an integer array nums where the i^th 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, and you should return 2.

Constraints:

1 <= nums.length <= 10⁵
1 <= maxOperations, nums[i] <= 10⁹

Difficulty: Medium

Tags: array, binary search

Rating: 96.99%

Solution

Here’s my Python solution to this problem:

class Solution:
    def minimumSize(self, nums: List[int], maxOperations: int) -> int:
        l = 1  # Minimum possible value
        r = max(nums)  # Maximum possible value

        def canAchieve(target):
            # Count operations needed to get all nums <= target
            o = 0
            for n in nums:
                o += (n-1) // target
            return o <= maxOperations
        
        res = r
        while l <= r:
            mid = (l+r)//2
            if canAchieve(mid):
                res = mid
                r = mid - 1
            else:
                l = mid + 1

        return res

Complexity Analysis

The solution has the following complexity characteristics:

Time Complexity: $O(n)$
Space Complexity: $O(1)$

Note: This is an automated analysis and may not capture all edge cases or specific algorithmic optimizations.