Capacity To Ship Packages Within D Days - Practice Coding Problems

Capacity To Ship Packages Within D Days - Problem

Shipping Problem: You're managing a shipping company that needs to transport packages from port A to port B. You have a conveyor belt with packages that must be shipped within a specific time frame.

Given an array weights where weights[i] represents the weight of the i-th package, and an integer days representing the maximum days allowed for shipping, you need to determine the minimum weight capacity of the ship required to transport all packages within the given time limit.

Key Rules:

Packages must be loaded in order from the conveyor belt
You cannot exceed the ship's weight capacity on any given day
All packages must be shipped within days days

Goal: Find the least weight capacity that allows all packages to be shipped within the time constraint.

Input & Output

example_1.py — Basic Case

$ Input: weights = [1,2,3,4,5,6,7,8,9,10], days = 5

› Output: 15

💡 Note: A ship capacity of 15 is sufficient: Day 1: [1,2,3,4,5] = 15kg, Day 2: [6,7] = 13kg, Day 3: [8] = 8kg, Day 4: [9] = 9kg, Day 5: [10] = 10kg. All packages are shipped within 5 days.

example_2.py — Tight Constraint

$ Input: weights = [3,2,2,4,1,4], days = 3

› Output: 6

💡 Note: A ship capacity of 6 works: Day 1: [3,2] = 5kg, Day 2: [2,4] = 6kg, Day 3: [1,4] = 5kg. Capacity 5 would fail because [2,4] = 6kg exceeds the limit.

example_3.py — Single Day

$ Input: weights = [1,2,3,1,1], days = 1

› Output: 8

💡 Note: All packages must be shipped in one day, so the ship needs capacity equal to the sum of all weights: 1+2+3+1+1 = 8kg.

Visualization

Tap to expand

Understanding the Visualization

Start Day 1

Begin loading packages in order until capacity reached

Capacity Check

If next package exceeds capacity, start a new day

Continue Loading

Repeat process until all packages are loaded

Validate Timeline

Check if total days used is within the allowed limit

Key Takeaway

🎯 Key Insight: The monotonic property (if capacity X works, then capacity > X works) allows us to use binary search instead of testing every possible capacity value, reducing time complexity from O(n × sum) to O(n × log(sum)).

Time & Space Complexity

Time Complexity

⏱️

O(n × log(sum))

Binary search runs log(sum) iterations, each requiring O(n) simulation of package loading

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for binary search bounds and simulation

✓ Linear Space

Constraints

1 ≤ days ≤ weights.length ≤ 5 × 10⁴
1 ≤ weights[i] ≤ 500
Packages must be shipped in the given order
Ship capacity must be at least the weight of the heaviest package

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses binary search on the ship capacity range. The key insight is recognizing the monotonic property: if capacity X works, then any capacity > X also works. We search between the minimum possible capacity (heaviest single package) and maximum needed capacity (sum of all packages), testing each candidate with a simulation. This achieves O(n × log(sum)) time complexity, much better than the brute force O(n × sum) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Capacity (Optimal)	O(n × log(sum))	O(1)	Use binary search to efficiently find the minimum viable capacity
Brute Force (Linear Search)	O((sum - max) × n)	O(1)	Try every possible capacity from minimum to maximum

Binary Search on Capacity (Optimal) — Algorithm Steps

Set left boundary to max single package weight (minimum possible capacity)
Set right boundary to sum of all packages (maximum needed capacity)
While left < right, calculate mid capacity
Test if mid capacity works using simulation
If it works, search left half (right = mid), otherwise search right half (left = mid + 1)
Return the final capacity when left equals right

Visualization

Tap to expand

Step-by-Step Walkthrough

Set search bounds

Left = max single weight (15), Right = total weight (55)

Test middle capacity

Mid = (15 + 55) / 2 = 35, simulate shipping

Adjust search range

If 35 works, try smaller (right = 35), else try larger (left = 36)

Converge to answer

Continue until left equals right, giving minimum viable capacity

Code -

solution.c — C

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

int canShip(int* weights, int n, int days, int capacity) {
    int currentWeight = 0;
    int daysNeeded = 1;
    
    for (int i = 0; i < n; i++) {
        if (currentWeight + weights[i] > capacity) {
            daysNeeded++;
            currentWeight = weights[i];
            if (daysNeeded > days) {
                return 0;
            }
        } else {
            currentWeight += weights[i];
        }
    }
    
    return 1;
}

int shipWithinDays(int* weights, int n, int days) {
    int left = 0;
    int right = 0;
    
    for (int i = 0; i < n; i++) {
        if (weights[i] > left) {
            left = weights[i];
        }
        right += weights[i];
    }
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (canShip(weights, n, days, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

int main() {
    int weights[500];
    int n = 0;
    int days;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " ");
    while (token != NULL) {
        weights[n++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    scanf("%d", &days);
    
    printf("%d\n", shipWithinDays(weights, n, days));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log(sum))

Binary search runs log(sum) iterations, each requiring O(n) simulation of package loading

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for binary search bounds and simulation

✓ Linear Space

Constraints

1 ≤ days ≤ weights.length ≤ 5 × 10⁴
1 ≤ weights[i] ≤ 500
Packages must be shipped in the given order
Ship capacity must be at least the weight of the heaviest package

42.4K Views

High Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search on Capacity (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler