Maximum Bags With Full Capacity of Rocks

class Solution {
public:
    int maxFilledBags(vector<int>& capacities, vector<int>& stones, int extraStones) {
        int bagsCount = int(capacities.size()), completelyFilled = 0;
    
        // Calculate remaining capacity for each bag.
        vector<int> neededCapacity(bagsCount);
    
        for (int i = 0; i < bagsCount; ++i)
            neededCapacity[i] = capacities[i] - stones[i];
        sort(neededCapacity.begin(), neededCapacity.end());
    
        // Attempt to fill bags in order of their needed capacity.
        for (int i = 0; i < bagsCount; ++i) {
            // Check if enough stones are available to fill the current bag.
            if (extraStones >= neededCapacity[i]) {
                extraStones -= neededCapacity[i];
                completelyFilled++;
            }
            else {
                break;
            }
        }
            
        // Final count of completely filled bags.
        return completelyFilled;
    }
};

The solution involves implementing a function maxFilledBags in C++ that determines the maximum number of bags that can be completely filled given arrays of their capacities and current stone counts, and an additional number of extra stones available.

• Start by calculating the difference between the bag capacities and the current number of stones in each bag. This yields the number of additional stones required for each bag.
• Sort these requirements in ascending order so that bags requiring fewer stones to be filled are considered first.
• Sequentially allocate the extra stones to the bags with the smallest requirement, thus maximizing the number of fully filled bags.
• Return the total count of bags that can be completely filled with the given total stones.

This process enhances efficiency by filling those bags first that are closest to their capacity, ensuring optimal utilization of the extra stones provided.

class Solution {
    public int fillMaxBags(int[] capacities, int[] filled, int extraRocks) {
        int count = capacities.length, completelyFilled = 0;
            
        int[] spaceLeft = new int[count];
        for (int i = 0; i < count; ++i)
            spaceLeft[i] = capacities[i] - filled[i];
        Arrays.sort(spaceLeft);
        
        for (int i = 0; i < count; ++i) {
            if (extraRocks >= spaceLeft[i]) {
                extraRocks -= spaceLeft[i];
                completelyFilled++;
            }
            else
                break;
        }
            
        return completelyFilled;
    }
}

The presented Java solution efficiently calculates the maximum number of bags that can be filled to their capacity given initial bag capacities, rocks already in them, and additional available rocks. Here's a concise overview of how the solution operates:

1. Start by determining the number of bags and initialize a counter to track how many can be completely filled.
2. Calculate the remaining space in each bag by subtracting the rocks already present from the total capacity of each bag. Store these values in an array.
3. Sort the array of space left in the bags to prioritize filling the ones with the least space left first, which optimizes the number of bags that can be completely filled using the given extra rocks.
4. Iterate through the sorted list, and as long as you have sufficient extra rocks remaining, subtract the needed rocks from the extra rocks and increase your count of completely filled bags.
5. Return the count of completely filled bags once either all bags are filled or you run out of extra rocks.

This approach ensures that you maximize the number of fully filled bags by focusing on filling the smaller gaps first, making efficient use of the available extra rocks.

class Solution:
    def maxFilledBags(self, capacities: List[int], stones: List[int], extraStones: int) -> int:
        leftover_space = [cap - stone for cap, stone in zip(capacities, stones)]
        leftover_space.sort()
        count_full = 0
            
        for space in leftover_space:
            if extraStones >= space:
                extraStones -= space
                count_full += 1
            else:
                break
            
        return count_full

The code defines a Python function maxFilledBags which determines the maximum number of bags that can be filled to their respective capacity with rocks. It takes three parameters: capacities, a list of integers representing the maximum capacity of each bag; stones, a list of integers indicating the initial number of stones in each bag; and extraStones, an integer representing additional stones available to fill the bags.

Here's a brief rundown of how this solution works:

• Calculate leftover_space for each bag by subtracting the stones already in the bag from the total capacity of the bag.
• Sort leftover_space in ascending order to prioritize bags that require fewer stones to be filled.
• Initialize a counter count_full to keep track of how many bags are filled to capacity.
• Iterate through each space requirement in leftover_space, using up the extraStones to fill each bag:
  • Subtract the required stones from extraStones and increment the count_full if the bag can be filled with the available stones.
  • Stop the process if there are not enough extraStones to fill the next bag.

The function finally returns count_full, the count of bags that could be filled to capacity. This method optimally uses the available stones by filling the smallest unfilled bags first, ensuring maximal usage of extraStones.