Minimum Amount of Time to Fill Cups

Minimum Amount of Time to Fill Cups - Problem

You have a water dispenser that can dispense cold, warm, and hot water. Every second, you can either:

Fill up 2 cups with different types of water, or
Fill up 1 cup of any type of water

You are given a 0-indexed integer array amount of length 3 where:

amount[0] = number of cold water cups needed
amount[1] = number of warm water cups needed
amount[2] = number of hot water cups needed

Return the minimum number of seconds needed to fill up all the cups.

Input & Output

Example 1 — Balanced Distribution

$ Input: amount = [1,4,2]

› Output: 4

💡 Note: Optimal strategy: Fill warm+hot (1 sec) → [1,3,1], Fill warm+hot (1 sec) → [1,2,0], Fill cold+warm (1 sec) → [0,1,0], Fill warm (1 sec) → [0,0,0]. Total: 4 seconds.

Example 2 — One Dominant Type

$ Input: amount = [5,4,4]

› Output: 7

💡 Note: With 5 cold cups, we can pair optimally until other types run out. Cold+warm and cold+hot simultaneously for 4 seconds, then 1 cold cup remains, taking 1 more second. Total: 5 + 2 = 7 seconds.

Example 3 — Equal Amounts

$ Input: amount = [5,0,0]

› Output: 5

💡 Note: Only one type available, so we must fill one cup per second for 5 seconds. No pairing possible.

Constraints

amount.length == 3
0 ≤ amount[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 8 a Amazon 12

The key insight is recognizing this as an optimization problem where we want to maximize simultaneous operations. The optimal approach uses a mathematical formula: if the maximum cup count exceeds the sum of the other two, we're limited by that maximum; otherwise, we can pair optimally and need ceiling of (total sum / 2) seconds. Best approach is Mathematical Formula with Time: O(1), Space: O(1).

Common Approaches

✓ Greedy with Priority Queue

⏱️ Time: O(S log 3) Space: O(1)

Maintain a priority queue (max heap) of cup amounts. At each step, extract the two largest amounts, fill them, and put them back if they're still positive. This avoids the sorting overhead of the simulation approach.

Mathematical Formula

⏱️ Time: O(1) Space: O(1)

The key insight is that if the maximum amount is greater than the sum of the other two, we're limited by that maximum. Otherwise, we can pair optimally and the answer is ceiling of total sum divided by 2.

Simulation Approach

⏱️ Time: O(S log 3) Space: O(1)

Keep track of remaining cups for each type. At each step, try to fill 2 cups of different types (choosing the two largest amounts), otherwise fill 1 cup of the largest remaining type.

Greedy with Priority Queue — Algorithm Steps

Step 1: Create max heap from the three amounts
Step 2: While cups remain, extract top 2 amounts
Step 3: Decrease both by 1 and reinsert if positive
Step 4: Increment time and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Heap

Create max heap from cup amounts

Extract Pairs

Always get the two largest amounts

Reinsert

Put back remaining amounts after filling

Code -

solution.c — C

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

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

int solution(int* amount) {
    int time = 0;
    while (amount[0] + amount[1] + amount[2] > 0) {
        qsort(amount, 3, sizeof(int), compare);
        if (amount[1] > 0) {
            amount[0]--;
            amount[1]--;
        } else {
            amount[0]--;
        }
        time++;
    }
    return time;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[100];
    fgets(line, sizeof(line), stdin);
    
    int amount[3];
    char *token = strtok(line, "[,]");
    for (int i = 0; i < 3; i++) {
        amount[i] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(amount);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(S log 3)

S is sum of amounts, each heap operation is O(log 3) = O(1)

⚡ Linearithmic

Space Complexity

O(1)

Heap stores at most 3 elements

✓ Linear Space

32.0K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy with Priority Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler