Boats to Save People

Boats to Save People - Problem

You are given an array people where people[i] is the weight of the i-th person, and an infinite number of boats where each boat can carry a maximum weight of limit.

Each boat carries at most two people at the same time, provided the sum of the weight of those people is at most limit.

Return the minimum number of boats to carry every given person.

Input & Output

Example 1 — Basic Pairing

$ Input: people = [1,2], limit = 3

› Output: 1

💡 Note: Both people can fit in one boat: 1 + 2 = 3 ≤ 3, so we need only 1 boat total

Example 2 — Mixed Pairing

$ Input: people = [3,2,2,1], limit = 3

› Output: 3

💡 Note: After sorting [1,2,2,3]: pair (1,2)→boat 1, remaining 2 and 3 need separate boats since 2+3>3

Example 3 — No Pairing Possible

$ Input: people = [5,5,5,5], limit = 5

› Output: 4

💡 Note: Each person weighs exactly the limit, so each needs their own boat. Total: 4 boats

Constraints

1 ≤ people.length ≤ 5 × 10⁴
1 ≤ people[i] ≤ limit ≤ 3 × 10⁴

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 32 f Facebook 28 M Microsoft 24

The key insight is using a greedy two-pointer approach after sorting. Always try to pair the lightest remaining person with the heaviest - this guarantees optimal boat usage. Best approach is Two Pointers with Sorting. Time: O(n log n), Space: O(1)

Common Approaches

✓ One Pass Hash

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

Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ) Space: O(n)

Try every possible combination of grouping people into boats with at most 2 people per boat. Check all valid configurations and return the minimum number of boats needed.

Greedy with Sorting

⏱️ Time: O(n log n) Space: O(1)

Sort the people array by weight. Use a greedy approach: always try to put the lightest remaining person with the heaviest remaining person in the same boat if they fit within the limit.

Two Pointers Optimization

⏱️ Time: O(n log n) Space: O(1)

After sorting, use two pointers approach where we always try to pair the lightest remaining person with the heaviest remaining person. This greedy strategy guarantees the optimal solution.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int minBoats;
static int boats[100][2]; // boats[i][0] = weight1, boats[i][1] = weight2 (-1 if empty)
static int boatSizes[100]; // number of people in each boat

void backtrack(int idx, int numBoats, const int* people, int n, int limit) {
    if (numBoats >= minBoats) {
        return; // pruning
    }
    if (idx == n) {
        if (numBoats < minBoats) {
            minBoats = numBoats;
        }
        return;
    }
    
    // Try adding person to existing boats
    for (int i = 0; i < numBoats; i++) {
        if (boatSizes[i] < 2) {
            int sum = 0;
            for (int j = 0; j < boatSizes[i]; j++) {
                sum += boats[i][j];
            }
            if (sum + people[idx] <= limit) {
                boats[i][boatSizes[i]] = people[idx];
                boatSizes[i]++;
                backtrack(idx + 1, numBoats, people, n, limit);
                boatSizes[i]--;
            }
        }
    }
    
    // Try creating new boat
    boats[numBoats][0] = people[idx];
    boatSizes[numBoats] = 1;
    backtrack(idx + 1, numBoats + 1, people, n, limit);
    boatSizes[numBoats] = 0;
}

int solution(const int* people, int n, int limit) {
    if (n == 1) {
        return 1;
    }
    
    minBoats = n; // worst case: one person per boat
    
    // Initialize boats
    for (int i = 0; i < 100; i++) {
        boatSizes[i] = 0;
        boats[i][0] = boats[i][1] = -1;
    }
    
    backtrack(0, 0, people, n, limit);
    return minBoats;
}

int main() {
    char line[1000];
    
    // Read people array
    fgets(line, sizeof(line), stdin);
    
    // Parse people array
    int people[100];
    int n = 0;
    
    // Remove [ and ]
    char* start = strchr(line, '[') + 1;
    char* end = strchr(line, ']');
    *end = '\0';
    
    // Parse numbers
    char* token = strtok(start, ",");
    while (token != NULL) {
        people[n++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    // Read limit
    fgets(line, sizeof(line), stdin);
    int limit = atoi(line);
    
    int result = solution(people, n, limit);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

186.8K Views

Medium Frequency

~15 min Avg. Time

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