Maximum Bags With Full Capacity of Rocks - Problem

You have n bags numbered from 0 to n - 1. You are given two 0-indexed integer arrays capacity and rocks. The i-th bag can hold a maximum of capacity[i] rocks and currently contains rocks[i] rocks.

You are also given an integer additionalRocks, the number of additional rocks you can place in any of the bags.

Return the maximum number of bags that could have full capacity after placing the additional rocks in some bags.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Bags need [1,3,3,1] rocks respectively. With 2 additional rocks, we can fill bags 0 and 3 (need 1 each), giving us 2 full bags total.

Example 2 — Already Full Bags

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

› Output: 3

💡 Note: Bag 1 is already full. Bag 0 needs 8 rocks, bag 2 needs 2 rocks. We can fill both with 100 additional rocks, so all 3 bags are full.

Example 3 — Insufficient Rocks

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

› Output: 0

💡 Note: Each bag needs 5 rocks to be full, but we only have 4 additional rocks. Cannot fill any bag completely.

Constraints

1 ≤ n ≤ 10⁵
capacity.length == rocks.length == n
1 ≤ capacity[i] ≤ 10⁹
0 ≤ rocks[i] ≤ capacity[i]
1 ≤ additionalRocks ≤ 10⁹

Visualization

Tap to expand

Asked in

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

The key insight is to use a greedy approach: always fill the bags that require the fewest additional rocks first. Calculate rocks needed for each bag, sort by requirement, then fill in ascending order until additional rocks run out. Best approach is Greedy Sorting. Time: O(n log n), Space: O(n)

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O(additionalRocks^n) Space: O(1)

Generate all possible ways to distribute additionalRocks among the bags and check which distribution gives the maximum number of full bags. This involves trying every combination of rock distributions.

Greedy - Fill Bags Needing Fewest Rocks First

⏱️ Time: O(n log n) Space: O(n)

Calculate how many additional rocks each bag needs to be full, sort by this requirement, then greedily fill bags starting with those needing the fewest rocks until we run out of additional rocks.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* capacity, int* rocks, int n, int additionalRocks) {
    int* needed = (int*)malloc(n * sizeof(int));
    int neededCount = 0;
    int fullBags = 0;

    for (int i = 0; i < n; i++) {
        int rocksNeeded = capacity[i] - rocks[i];
        if (rocksNeeded == 0) {
            fullBags++;
        } else {
            needed[neededCount++] = rocksNeeded;
        }
    }

    qsort(needed, neededCount, sizeof(int), compare);

    for (int i = 0; i < neededCount; i++) {
        if (additionalRocks >= needed[i]) {
            additionalRocks -= needed[i];
            fullBags++;
        } else {
            break;
        }
    }

    free(needed);
    return fullBags;
}

// Parse JSON array like [1,2,3] into int array, returns count
int parseJsonArray(const char* line, int* arr) {
    int count = 0;
    const char* p = line;
    while (*p && *p != '[') p++;
    if (!*p) return 0;
    p++; // skip '['
    while (*p) {
        while (*p == ' ') p++;
        if (*p == ']') break;
        char* end;
        arr[count++] = (int)strtol(p, &end, 10);
        p = end;
        while (*p == ',' || *p == ' ') p++;
    }
    return count;
}

int main() {
    char line[100000];
    int capacity[100000], rocks[100000];

    fgets(line, sizeof(line), stdin);
    int n = parseJsonArray(line, capacity);

    fgets(line, sizeof(line), stdin);
    parseJsonArray(line, rocks);

    fgets(line, sizeof(line), stdin);
    int additionalRocks = atoi(line);

    printf("%d\n", solution(capacity, rocks, n, additionalRocks));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

25.6K Views

Medium Frequency

~15 min Avg. Time

892 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