Minimum Amount of Time to Collect Garbage

Minimum Amount of Time to Collect Garbage - Problem

You are given a 0-indexed array of strings garbage where garbage[i] represents the assortment of garbage at the i-th house. garbage[i] consists only of the characters 'M', 'P' and 'G' representing one unit of metal, paper and glass garbage respectively.

Picking up one unit of any type of garbage takes 1 minute.

You are also given a 0-indexed integer array travel where travel[i] is the number of minutes needed to go from house i to house i + 1.

There are three garbage trucks in the city, each responsible for picking up one type of garbage. Each garbage truck starts at house 0 and must visit each house in order; however, they do not need to visit every house.

Only one garbage truck may be used at any given moment. While one truck is driving or picking up garbage, the other two trucks cannot do anything.

Return the minimum number of minutes needed to pick up all the garbage.

Input & Output

Example 1 — Basic Case

$ Input: garbage = ["G","P","GP","GG"], travel = [2,4,3]

› Output: 21

💡 Note: G truck: 4 units (1+0+1+2) + 9 travel time (2+4+3 to reach house 3) = 13 min. P truck: 2 units (0+1+1+0) + 6 travel time (2+4 to reach house 2) = 8 min. M truck: 0 units + 0 travel = 0 min. Total = 13+8+0 = 21 minutes.

Example 2 — All Types at First House

$ Input: garbage = ["MPG","M","P","GPG"], travel = [1,3,2]

› Output: 21

💡 Note: M truck: 2 units (1+1+0+0) + 1 travel time (1 to house 1) = 3 min. P truck: 3 units (1+0+1+1) + 6 travel time (1+3+2 to house 3) = 9 min. G truck: 3 units (1+0+0+2) + 6 travel time to house 3 = 9 min. Total = 3+9+9 = 21 minutes.

Example 3 — Single House

$ Input: garbage = ["MMM"], travel = []

› Output: 3

💡 Note: Only M truck needs to work: 3 units of metal at house 0, no travel required. Total = 3 minutes.

Constraints

1 ≤ garbage.length ≤ 10⁵
1 ≤ garbage[i].length ≤ 10
garbage[i] consists of only the letters 'M', 'P', and 'G'
1 ≤ travel.length ≤ 10⁴
1 ≤ travel[i] ≤ 100
travel.length == garbage.length - 1

Visualization

Tap to expand

Asked in

a Amazon 12 M Microsoft 8

The key insight is that each garbage truck only needs to travel to its last pickup location, not visit every house. We can optimize by using prefix sums for travel times and processing each garbage type separately. Best approach uses prefix sum optimization: Time O(n), Space O(n).

Common Approaches

✓ Brute Force - Calculate Each Truck Separately

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

For each garbage type (M, P, G), iterate through all houses to count pickup time and find the last house that contains this type. Then calculate travel time to that last house.

Optimized with Prefix Sum

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

Calculate prefix sums of travel times for O(1) range queries. Then for each garbage type, find the last house and use prefix sums to get travel time instantly.

Brute Force - Calculate Each Truck Separately — Algorithm Steps

Step 1: For each garbage type, scan all houses to count total units
Step 2: Find the last house containing each garbage type
Step 3: Calculate travel time from house 0 to each last house
Step 4: Sum pickup time + travel time for all three trucks

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Garbage

Count each type of garbage across all houses

Find Last House

Determine the last house each truck needs to visit

Calculate Times

Sum pickup time + travel time for each truck

Code -

solution.c — C

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

int solution(char garbage[][100], int garbageSize, int* travel, int travelSize) {
    int totalTime = 0;
    char garbageTypes[] = {'M', 'P', 'G'};
    
    // Process each garbage type
    for (int t = 0; t < 3; t++) {
        char garbageType = garbageTypes[t];
        int pickupTime = 0;
        int lastHouse = -1;
        
        // Find pickup time and last house for this type
        for (int i = 0; i < garbageSize; i++) {
            int count = 0;
            for (int j = 0; garbage[i][j] != '\0'; j++) {
                if (garbage[i][j] == garbageType) {
                    count++;
                }
            }
            if (count > 0) {
                pickupTime += count;
                lastHouse = i;
            }
        }
        
        // Calculate travel time to last house
        int travelTime = 0;
        for (int i = 0; i < lastHouse; i++) {
            travelTime += travel[i];
        }
        
        totalTime += pickupTime + travelTime;
    }
    
    return totalTime;
}

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[10000];
    char garbage[100][100];
    int travel[100];
    int garbageSize = 0, travelSize = 0;
    
    // Parse garbage array
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, "[\"]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ',' && token[0] != ' ' && token[0] != '\n') {
            strcpy(garbage[garbageSize++], token);
        }
        token = strtok(NULL, "[\"]");
    }
    
    // Parse travel array
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[],");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ' && token[0] != '\n') {
            travel[travelSize++] = atoi(token);
        }
        token = strtok(NULL, "[],");
    }
    
    int result = solution(garbage, garbageSize, travel, travelSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three passes through garbage array (one per type) plus travel time calculation

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and variables

⚡ Linearithmic Space

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

Brute Force - Calculate Each Truck Separately — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler