Maximum Containers on a Ship - Practice Coding Problems

Maximum Containers on a Ship - Problem

Math Easy

You're the cargo operations manager for a shipping company, and you need to maximize the number of containers loaded onto a cargo ship.

Given:

n - the dimensions of an n × n cargo deck
w - the weight of each container (all containers weigh exactly the same)
maxWeight - the ship's maximum weight capacity

Each cell on the deck can hold exactly one container. Your goal is to determine the maximum number of containers you can load without exceeding the ship's weight limit.

Example: If you have a 3×3 deck (9 possible positions), each container weighs 5 units, and your ship can carry at most 20 units, you can load at most 20 ÷ 5 = 4 containers.

Input & Output

example_1.py — Basic Case

$ Input: n = 3, w = 5, maxWeight = 20

› Output: 4

💡 Note: We have a 3×3 deck (9 positions total). Each container weighs 5 units. Maximum capacity is 20 units. We can load at most 20 ÷ 5 = 4 containers, which is less than the 9 available positions.

example_2.py — Weight Constraint

$ Input: n = 5, w = 10, maxWeight = 15

› Output: 1

💡 Note: We have a 5×5 deck (25 positions total). Each container weighs 10 units. Maximum capacity is 15 units. We can only load 15 ÷ 10 = 1 container (integer division), even though we have 25 positions available.

example_3.py — Space Constraint

$ Input: n = 2, w = 3, maxWeight = 100

› Output: 4

💡 Note: We have a 2×2 deck (4 positions total). Each container weighs 3 units. Maximum capacity is 100 units. Theoretically we could load 100 ÷ 3 = 33 containers, but we're limited by deck space to only 4 containers.

Constraints

1 ≤ n ≤ 10³
1 ≤ w ≤ 10⁴
1 ≤ maxWeight ≤ 2 × 10⁶
All containers have identical weight w

Visualization

Tap to expand

Understanding the Visualization

Calculate Weight Constraint

Divide total weight capacity by individual container weight

Calculate Space Constraint

Count total available positions on the n×n deck

Choose Minimum

The smaller value is our answer - we're limited by the tighter constraint

Key Takeaway

🎯 Key Insight: This problem demonstrates that sometimes the most efficient algorithm is pure mathematics - O(1) time complexity by recognizing the dual constraint nature of the problem.

Asked in

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

This problem reduces to a simple mathematical calculation: find the minimum between maxWeight ÷ w (weight constraint) and n² (space constraint). The optimal solution runs in O(1) time with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^(n²))	O(n²)	Generate all possible combinations of container placements and check weight limits

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible subsets of deck positions (2^(n²) combinations)
For each combination, calculate total weight by multiplying container count by weight
Check if total weight ≤ maxWeight
Keep track of maximum valid container count

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Combinations

Create every possible way to place containers on the deck

Calculate Weight

For each combination, multiply container count by weight

Check Validity

Verify if total weight is within ship's capacity

Track Maximum

Keep the highest valid container count found

Code -

solution.c — C

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

int popcount(int x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

int maxContainers(int n, int w, int maxWeight) {
    // Brute force - trying all combinations (impractical)
    int totalPositions = n * n;
    int maxContainerCount = 0;
    
    // Try all possible combinations (2^(n²))
    for (int mask = 0; mask < (1 << totalPositions); mask++) {
        int containerCount = popcount(mask);
        int totalWeight = containerCount * w;
        
        if (totalWeight <= maxWeight) {
            if (containerCount > maxContainerCount) {
                maxContainerCount = containerCount;
            }
        }
        
        // Early termination if we exceed theoretical maximum
        if (containerCount > maxWeight / w) {
            break;
        }
    }
    
    return maxContainerCount;
}

int main() {
    int n, w, maxWeight;
    scanf("%d %d %d", &n, &w, &maxWeight);
    printf("%d\n", maxContainers(n, w, maxWeight));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n²))

We generate 2^(n²) subsets where n² is the total deck positions

⚠ Quadratic Growth

Space Complexity

O(n²)

Need to store current combination of positions being tested

⚠ Quadratic Space

23.5K Views

Medium Frequency

~5 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler