Boats to Save People - Practice Coding Problems

Boats to Save People - Problem

Imagine you're coordinating a rescue operation at sea! You have an unlimited number of rescue boats, but each boat can only carry a maximum of 2 people and has a strict weight limit.

Given an array people where people[i] represents the weight of the i-th person, and each boat can carry a maximum weight of limit, your mission is to find the minimum number of boats needed to rescue everyone.

Key constraints:
• Each boat carries at most 2 people
• The combined weight must not exceed the limit
• You want to minimize the total number of boats used

Example: If people weigh [1,2] and limit is 3, you need only 1 boat since 1+2=3 ≤ limit.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Both people can fit in one boat since 1 + 2 = 3 ≤ 3 (limit). Only 1 boat needed.

example_2.py — Multiple Boats

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

› Output: 3

💡 Note: After sorting: [1,2,2,3]. Boat 1: [1,2], Boat 2: [2] (can't pair with 3), Boat 3: [3]. Total: 3 boats.

example_3.py — All Alone

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

› Output: 4

💡 Note: After sorting: [3,3,4,5]. No two people can share a boat (minimum sum is 3+3=6 > 5), so each needs their own boat.

Visualization

Tap to expand

Understanding the Visualization

Sort people by weight

Arrange from lightest to heaviest for optimal pairing

Use two pointers

Left at lightest, right at heaviest person

Apply greedy strategy

If lightest + heaviest ≤ limit, pair them. Otherwise heaviest goes alone

Continue until done

Move pointers inward and repeat until everyone is rescued

Key Takeaway

🎯 Key Insight: The greedy strategy works because if the lightest person can't pair with the heaviest, then no one else can pair with the heaviest either (since everyone else is heavier than the lightest person).

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the array. The two-pointer traversal is O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra space for pointers and variables (excluding sorting space)

✓ Linear Space

Constraints

1 ≤ people.length ≤ 5 × 10⁴
1 ≤ people[i] ≤ limit ≤ 3 × 10⁴
Each boat carries at most 2 people
Total weight in boat must not exceed limit

Asked in

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

The optimal solution uses a greedy two-pointer approach after sorting. Always try to pair the lightest person with the heaviest person - if they can't share a boat together, no one else can pair with the heaviest person. This ensures O(n log n) time complexity and minimizes the number of boats needed.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Greedy Optimal)	O(n log n)	O(1)	Sort people by weight and use greedy pairing strategy
Brute Force (Try All Pairings)	O(2^n)	O(n)	Check all possible ways to group people into boats

Two Pointers (Greedy Optimal) — Algorithm Steps

Sort the people array by weight in ascending order
Initialize left pointer at start (lightest) and right pointer at end (heaviest)
While left <= right: try to pair people[left] + people[right]
If their combined weight <= limit, move both pointers (they share a boat)
Otherwise, only move right pointer (heaviest person goes alone)
Increment boat count for each iteration

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort people by weight

Arrange people from lightest to heaviest

Set left=lightest, right=heaviest

Position pointers at both ends

Try to pair them

If combined weight ≤ limit, both go together

Move pointers accordingly

Always move right, move left only if paired

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int numRescueBoats(int* people, int peopleSize, int limit) {
    qsort(people, peopleSize, sizeof(int), compare);  // Sort by weight
    int left = 0, right = peopleSize - 1;
    int boats = 0;
    
    while (left <= right) {
        // Try to pair lightest with heaviest
        if (people[left] + people[right] <= limit) {
            left++;  // Lightest person gets on boat
        }
        right--;  // Heaviest person always gets on boat
        boats++;  // One boat used
    }
    
    return boats;
}

int main() {
    int people[] = {1, 2};
    int peopleSize = 2;
    int limit = 3;
    printf("%d\n", numRescueBoats(people, peopleSize, limit));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the array. The two-pointer traversal is O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra space for pointers and variables (excluding sorting space)

✓ Linear Space

Constraints

1 ≤ people.length ≤ 5 × 10⁴
1 ≤ people[i] ≤ limit ≤ 3 × 10⁴
Each boat carries at most 2 people
Total weight in boat must not exceed limit

38.9K Views

High Frequency

~15 min Avg. Time

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

Two Pointers (Greedy Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler