Delivering Boxes from Storage to Ports - Practice Coding Problems

Delivering Boxes from Storage to Ports - Problem

Array Dynamic Programming Segment Tree Queue Heap (Priority Queue) Prefix Sum Monotonic Queue Hard

Imagine you're managing a shipping company with one cargo ship that must deliver boxes from a central storage facility to various ports. Your ship has constraints: it can only carry a limited number of boxes and a maximum weight at any time.

You're given an array boxes where boxes[i] = [port_i, weight_i] representing the destination port and weight of each box. You also have three constraints: portsCount (total number of ports), maxBoxes (ship's box capacity), and maxWeight (ship's weight capacity).

The Challenge: Boxes must be delivered in the given order, and your ship follows this process:

Load boxes from storage (respecting capacity limits)
Visit ports in order of loaded boxes, delivering each box
Return to storage for the next batch

Your goal is to find the minimum number of trips needed to deliver all boxes, where each trip is either going to a port or returning to storage.

Input & Output

example_1.py — Basic case

$ Input: boxes = [[1,1],[2,1],[1,1]], portsCount = 2, maxBoxes = 3, maxWeight = 3

› Output: 4

💡 Note: Ship takes all boxes in one trip: storage→port1→port2→port1→storage. Total: 4 trips

example_2.py — Weight constraint

$ Input: boxes = [[1,2],[3,3],[2,1],[1,1],[2,4]], portsCount = 3, maxBoxes = 3, maxWeight = 6

› Output: 6

💡 Note: First trip: boxes [1,2] and [3,3] (weight=5), trips: storage→1→3→storage = 3. Second trip: remaining boxes, trips: storage→2→1→2→storage = 3. Total: 6

example_3.py — Box constraint

$ Input: boxes = [[1,4],[1,2],[2,1],[2,1],[3,2],[3,4]], portsCount = 3, maxBoxes = 2, maxWeight = 7

› Output: 9

💡 Note: Must make multiple trips due to maxBoxes=2 constraint, requiring optimal grouping

Visualization

Tap to expand

Understanding the Visualization

Analyze constraints

Identify valid shipment boundaries based on weight/box limits

Calculate costs

Count unique ports visited plus return trip for each shipment

Optimize transitions

Use deque to maintain only promising previous states

Build solution

DP forward to find minimum total trips

Key Takeaway

🎯 Key Insight: Use monotonic deque to maintain optimal candidates while sliding window ensures only valid shipment boundaries are considered, achieving O(n) complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is added and removed from deque at most once

✓ Linear Growth

Space Complexity

O(n)

DP array and deque storage, plus prefix sum arrays

⚡ Linearithmic Space

Constraints

1 ≤ boxes.length ≤ 10⁵
1 ≤ portsCount, boxes[i][0] ≤ 10⁵
1 ≤ maxBoxes, boxes[i][1], maxWeight ≤ 10⁹
Boxes must be delivered in the given order

Asked in

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

This problem requires dynamic programming with deque optimization to achieve optimal O(n) complexity. The key insight is using a monotonic deque to maintain only the relevant previous states for DP transitions, while prefix sums help calculate costs efficiently. The sliding window approach ensures we only consider valid shipment boundaries.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Dynamic Programming	O(n²)	O(n)	Try all possible ways to group consecutive boxes using basic DP
Dynamic Programming with Deque Optimization	O(n)	O(n)	Optimize DP transitions using monotonic deque to achieve O(n) complexity

Brute Force Dynamic Programming — Algorithm Steps

For each starting position, try all possible ending positions for current shipment
Check if the shipment is valid (within weight and box constraints)
Calculate trips needed for this shipment (unique ports + 1 return trip)
Recursively solve for remaining boxes
Take minimum across all valid partitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from end

Begin DP from the last box position

Try all partitions

For each position, try all valid ending positions

Calculate cost

Count unique ports + return trip for each partition

Code -

solution.c — C

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

int boxDelivering(int** boxes, int boxesSize, int portsCount, int maxBoxes, int maxWeight) {
    int* dp = (int*)malloc((boxesSize + 1) * sizeof(int));
    for (int i = 0; i <= boxesSize; i++) {
        dp[i] = INT_MAX;
    }
    dp[boxesSize] = 0;
    
    for (int i = boxesSize - 1; i >= 0; i--) {
        int weight = 0;
        int boxCount = 0;
        int ports[1001] = {0}; // Assuming max 1000 ports
        int uniquePorts = 0;
        
        for (int j = i; j < boxesSize; j++) {
            if (boxCount >= maxBoxes || weight + boxes[j][1] > maxWeight) {
                break;
            }
            
            weight += boxes[j][1];
            boxCount++;
            if (!ports[boxes[j][0]]) {
                ports[boxes[j][0]] = 1;
                uniquePorts++;
            }
            
            int trips = uniquePorts + 1;
            if (dp[i] > trips + dp[j + 1]) {
                dp[i] = trips + dp[j + 1];
            }
        }
    }
    
    int result = dp[0];
    free(dp);
    return result;
}

int main() {
    // Input parsing implementation needed
    printf("Input parsing implementation needed\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we try up to n different ending positions

⚠ Quadratic Growth

Space Complexity

O(n)

DP array to store minimum trips for each starting position

⚡ Linearithmic Space

Constraints

1 ≤ boxes.length ≤ 10⁵
1 ≤ portsCount, boxes[i][0] ≤ 10⁵
1 ≤ maxBoxes, boxes[i][1], maxWeight ≤ 10⁹
Boxes must be delivered in the given order

28.5K Views

Medium Frequency

~35 min Avg. Time

890 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler