Minimum Amount of Time to Collect Garbage

Minimum Amount of Time to Collect Garbage - Problem

Imagine you're managing a smart city's waste collection system! 🚛 You have three specialized garbage trucks - one for Metal (M), one for Paper (P), and one for Glass (G).

Given an array garbage where garbage[i] represents the types of garbage at house i (containing only 'M', 'P', 'G' characters), and an array travel where travel[i] is the minutes needed to travel from house i to house i+1.

Rules:

Each truck starts at house 0 and visits houses in order
Picking up 1 unit of garbage takes 1 minute
Only one truck can operate at a time
Trucks don't need to visit every house (only where their garbage type exists)

Goal: Return the minimum total time needed to collect all garbage from all houses.

Input & Output

basic_case.py — Python

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

› Output: 21

💡 Note: Metal truck: no metal garbage, 0 time. Paper truck: travels 0->1->2 (2+4=6 minutes) + picks up 2 paper (2 minutes) = 8 minutes. Glass truck: travels 0->1->2->3 (2+4+3=9 minutes) + picks up 4 glass (4 minutes) = 13 minutes. Total: 0 + 8 + 13 = 21

all_types.py — Python

$ Input: garbage = ["MMM","PGM","GP"], travel = [3,10]

› Output: 37

💡 Note: Metal truck: travels to house 1 (3 minutes) + picks up 4 metal (4 minutes) = 7 minutes. Paper truck: travels to house 2 (3+10=13 minutes) + picks up 2 paper (2 minutes) = 15 minutes. Glass truck: travels to house 2 (3+10=13 minutes) + picks up 2 glass (2 minutes) = 15 minutes. Total: 7 + 15 + 15 = 37

single_house.py — Python

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

› Output: 3

💡 Note: All trucks start at house 0, no travel needed. Each picks up 1 unit: Metal=1, Paper=1, Glass=1. Total: 1 + 1 + 1 = 3

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Route Planning

Scan all houses to determine the farthest each truck needs to travel

Garbage Collection

Count total pickup time for each garbage type (M, P, G)

Travel Optimization

Calculate minimum travel time to each truck's final destination

Total Coordination

Sum pickup + travel time since trucks operate sequentially

Key Takeaway

🎯 Key Insight: Each truck only needs to travel to the last house containing their garbage type, optimizing the total collection time through smart route planning.

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 5

The optimal solution uses a single pass to track the last position where each garbage type appears, then calculates the total time as pickup time + travel time for each truck. Key insight: each truck only needs to travel to the last house containing their garbage type. Time complexity: O(n + m) where n is houses and m is total garbage characters.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Passes)	O(n * k)	O(1)	Simulate each truck separately, visiting all houses
One-Pass Optimal Solution	O(n + m)	O(1)	Single pass to track last positions and accumulate times efficiently
Two-Pass Optimization	O(n + m)	O(1)	First pass to find last positions, second pass to calculate times

Brute Force (Multiple Passes) — Algorithm Steps

For each garbage type, find the last house that contains it
For each garbage type, iterate from house 0 to last house
Sum up pickup time (count of garbage) and travel time
Add times for all three trucks

Visualization

Tap to expand

Step-by-Step Walkthrough

Metal Truck Pass

Scan all houses to find last Metal garbage and calculate total time

Paper Truck Pass

Scan all houses to find last Paper garbage and calculate total time

Glass Truck Pass

Scan all houses to find last Glass garbage and calculate total time

Code -

solution.c — C

int garbageCollection(char** garbage, int garbageSize, int* travel, int travelSize) {
    int getTimeForType(char garbageType) {
        int lastHouse = -1;
        int pickupTime = 0;
        
        // Find last house with this garbage type
        for (int i = 0; i < garbageSize; i++) {
            if (strchr(garbage[i], garbageType)) {
                lastHouse = i;
                for (int j = 0; garbage[i][j]; j++) {
                    if (garbage[i][j] == garbageType) pickupTime++;
                }
            }
        }
        
        if (lastHouse == -1) return 0;
        
        // Calculate travel time to last house
        int travelTime = 0;
        for (int i = 0; i < lastHouse; i++) {
            travelTime += travel[i];
        }
        
        return pickupTime + travelTime;
    }
    
    return getTimeForType('M') + getTimeForType('P') + getTimeForType('G');
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

Where n is number of houses and k=3 garbage types. We make multiple passes for each type

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and variables

✓ Linear Space

58.9K Views

Medium Frequency

~12 min Avg. Time

1.8K 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 (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler