Delivering Boxes from Storage to Ports

Delivering Boxes from Storage to Ports - Problem

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

You have the task of delivering boxes from storage to their ports using only one ship. The ship has limits on the number of boxes and total weight it can carry.

You are given an array boxes where boxes[i] = [portsi, weighti], and three integers portsCount, maxBoxes, and maxWeight.

portsi is the port where you need to deliver the ith box
weightsi is the weight of the ith box
portsCount is the number of ports
maxBoxes and maxWeight are the ship's capacity limits

The boxes must be delivered in the given order. The ship follows these steps:

Take boxes from the queue without violating maxBoxes and maxWeight constraints
For each loaded box in order, make a trip to deliver it (if already at the correct port, no trip needed)
Return to storage to take more boxes

The ship must end at storage after all deliveries. Return the minimum number of trips needed.

Input & Output

Example 1 — Basic Case

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

› Output: 6

💡 Note: Trip 1: Take boxes [1,1],[4,6] but weight exceeds. Take only [1,1], deliver to port 1, return. Trip 2: Take [4,6], deliver to port 4, return. Trip 3: Take [1,2],[2,7] but weight exceeds. Take [1,2], deliver to port 1, return. Trip 4: Take [2,7], deliver to port 2, return. Trip 5: Take [3,2], deliver to port 3. Total: 6 trips.

Example 2 — Efficient Grouping

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

› Output: 4

💡 Note: Trip 1: Take all boxes [1,2],[3,3],[1,1] (weight = 6, boxes = 3). Deliver to port 1, then port 3 (port 1 again is same as current). Total: 2 trips since no return needed.

Example 3 — Single Box Per Trip

$ Input: boxes = [[1,4],[2,5]], portsCount = 2, maxBoxes = 1, maxWeight = 10

› Output: 4

💡 Note: Trip 1: Take [1,4], deliver to port 1, return. Trip 2: Take [2,5], deliver to port 2. Total: 4 trips.

Constraints

1 ≤ boxes.length ≤ 10⁵
1 ≤ portsCount, boxes[i][0] ≤ 10⁵
1 ≤ boxes[i][1] ≤ 10⁵
1 ≤ maxBoxes, maxWeight ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 25 M Microsoft 12

The key insight is to use dynamic programming to find the optimal way to group consecutive boxes into ship loads. Each load visits unique ports (counting as 2×ports trips for round-trip, except the last load). Best approach uses bottom-up DP with prefix sums. Time: O(n²), Space: O(n)

Common Approaches

✓ Optimized

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

Brute Force Dynamic Programming

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

For each position, try all possible ending positions for the current ship load and recursively solve for the remaining boxes. This explores all valid groupings of consecutive boxes.

Optimized Dynamic Programming

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

Optimize the basic DP by precomputing prefix sums for quick range calculations and using a monotonic deque to maintain the best transitions efficiently. This avoids redundant calculations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int capacity;
    int* queue;
    int size;
    int front;
    int rear;
    pthread_mutex_t mutex;
    pthread_cond_t notFull;
    pthread_cond_t notEmpty;
} BoundedBlockingQueue;

BoundedBlockingQueue* createQueue(int capacity) {
    BoundedBlockingQueue* bbq = malloc(sizeof(BoundedBlockingQueue));
    bbq->capacity = capacity;
    bbq->queue = malloc(capacity * sizeof(int));
    bbq->size = 0;
    bbq->front = 0;
    bbq->rear = 0;
    pthread_mutex_init(&bbq->mutex, NULL);
    pthread_cond_init(&bbq->notFull, NULL);
    pthread_cond_init(&bbq->notEmpty, NULL);
    return bbq;
}

void enqueue(BoundedBlockingQueue* bbq, int element) {
    pthread_mutex_lock(&bbq->mutex);
    
    while (bbq->size >= bbq->capacity) {
        pthread_cond_wait(&bbq->notFull, &bbq->mutex);
    }
    
    bbq->queue[bbq->rear] = element;
    bbq->rear = (bbq->rear + 1) % bbq->capacity;
    bbq->size++;
    
    pthread_cond_signal(&bbq->notEmpty);
    pthread_mutex_unlock(&bbq->mutex);
}

int dequeue(BoundedBlockingQueue* bbq) {
    pthread_mutex_lock(&bbq->mutex);
    
    while (bbq->size == 0) {
        pthread_cond_wait(&bbq->notEmpty, &bbq->mutex);
    }
    
    int result = bbq->queue[bbq->front];
    bbq->front = (bbq->front + 1) % bbq->capacity;
    bbq->size--;
    
    pthread_cond_signal(&bbq->notFull);
    pthread_mutex_unlock(&bbq->mutex);
    return result;
}

int size(BoundedBlockingQueue* bbq) {
    pthread_mutex_lock(&bbq->mutex);
    int result = bbq->size;
    pthread_mutex_unlock(&bbq->mutex);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    fgets(line, sizeof(line), stdin);
    
    BoundedBlockingQueue* queue = createQueue(2);
    enqueue(queue, 1);
    printf("[%d,", dequeue(queue));
    printf("%d]\n", size(queue));
    
    free(queue->queue);
    free(queue);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

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