Maximum Bags With Full Capacity of Rocks - Practice Coding Problems

Maximum Bags With Full Capacity of Rocks - Problem

You're managing a rock collection warehouse with n storage bags, each with different capacities. Your goal is to maximize the number of completely full bags by strategically distributing additional rocks.

Problem Setup:

You have n bags numbered from 0 to n-1
Each bag i can hold a maximum of capacity[i] rocks
Each bag i currently contains rocks[i] rocks
You have additionalRocks extra rocks to distribute

Goal: Return the maximum number of bags that can reach their full capacity after optimally placing the additional rocks.

Example: If you have bags with capacities [2,3,4,5] and current rocks [1,2,4,4], with 2 additional rocks, you can fill the first bag (needs 1 rock) and second bag (needs 1 rock) to get 2 completely full bags.

Input & Output

example_1.py — Basic Case

$ Input: capacity = [2,3,4,5], rocks = [1,2,4,4], additionalRocks = 2

› Output: 3

💡 Note: Bag needs: [1,1,0,1]. We can fill bags needing 0, 1, and 1 rocks respectively, using all 2 additional rocks to get 3 full bags total.

example_2.py — Limited Resources

$ Input: capacity = [10,2,2], rocks = [2,2,0], additionalRocks = 100

› Output: 3

💡 Note: Bag needs: [8,0,2]. Even with 100 additional rocks, we can only fill all 3 bags since that's the maximum possible.

example_3.py — No Additional Rocks

$ Input: capacity = [2,5,3,4], rocks = [1,3,1,4], additionalRocks = 0

› Output: 1

💡 Note: Without additional rocks, only bag 3 (index 3) is already full with rocks[3] = capacity[3] = 4.

Visualization

Tap to expand

Understanding the Visualization

Calculate Shopping List

Figure out the 'price' (additional rocks needed) for each bag to become full

Sort by Price

Arrange bags from cheapest to most expensive in terms of rocks needed

Shop Greedily

Buy (fill) bags starting from cheapest until you run out of budget (additional rocks)

Count Purchases

The number of bags you successfully filled is your answer

Key Takeaway

🎯 Key Insight: Greedy algorithms work when local optimal choices lead to global optimal solutions. Here, always choosing the 'cheapest' bag to fill maximizes our total count.

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Where k is the average rocks needed per bag and n is number of bags. We try all possible ways to distribute rocks.

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels in the worst case

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
0 ≤ capacity[i], rocks[i] ≤ 10⁹
rocks[i] ≤ capacity[i] for all i
0 ≤ additionalRocks ≤ 10⁹

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a greedy strategy: calculate how many rocks each bag needs, sort by increasing need, then fill bags starting with those requiring the fewest additional rocks. This maximizes the number of bags we can completely fill with our limited resources in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(k^n)	O(n)	Generate all possible ways to distribute additional rocks and find the maximum full bags
Greedy Approach (Optimal)	O(n log n)	O(n)	Sort bags by rocks needed, then greedily fill from least needed to most needed

Brute Force (Try All Combinations) — Algorithm Steps

For each bag, calculate how many rocks it needs to be full
Use recursion to try all possible distributions of additional rocks
For each distribution, count how many bags become full
Return the maximum count found across all distributions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first bag

Try adding 0, 1, 2, ... rocks up to what's needed or available

Recursively handle remaining bags

For each choice, solve the subproblem with remaining bags and rocks

Track maximum

Keep track of the maximum number of full bags found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int min(int a, int b) {
    return a < b ? a : b;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int backtrack(int* capacity, int* rocks, int n, int index, int remainingRocks) {
    if (index == n) {
        return 0;
    }
    
    int maxFull = 0;
    int needed = capacity[index] - rocks[index];
    
    // Try adding 0 to min(needed, remainingRocks) rocks to this bag
    for (int add = 0; add <= min(needed, remainingRocks); add++) {
        int currentFull = (rocks[index] + add == capacity[index]) ? 1 : 0;
        maxFull = max(maxFull, currentFull + backtrack(capacity, rocks, n, index + 1, remainingRocks - add));
    }
    
    return maxFull;
}

int maximumBags(int* capacity, int* rocks, int n, int additionalRocks) {
    return backtrack(capacity, rocks, n, 0, additionalRocks);
}

int main() {
    printf("Brute force approach implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Where k is the average rocks needed per bag and n is number of bags. We try all possible ways to distribute rocks.

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels in the worst case

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
0 ≤ capacity[i], rocks[i] ≤ 10⁹
rocks[i] ≤ capacity[i] for all i
0 ≤ additionalRocks ≤ 10⁹

32.0K Views

Medium-High Frequency

~15 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler