Boats to Save People

class Solution {
public:
    int calculateRescueBoats(vector<int>& people, int maxWeight) {
        sort(people.begin(), people.end());
        int left = 0, right = people.size() - 1;
        int totalBoats = 0;

        while (left <= right) {
            totalBoats++;
            if (people[left] + people[right] <= maxWeight)
                left++;
            right--;
        }

        return totalBoats;
    }
};

This solution to the problem "Boats to Save People" is implemented in C++. It aims to determine the minimum number of boats required to rescue all the people, given their weights and the maximum weight capacity of each boat.

The function calculateRescueBoats takes a vector of integers people representing the weights of each person and an integer maxWeight denoting the maximum weight each boat can handle. To solve the problem, follow these steps:

1. Sort the weight of people in ascending order using sort().
2. Initialize two pointers: left starting from the beginning of the vector, and right from the end.
3. Initialize a variable totalBoats to count the number of boats needed.
4. Use a loop to pair the lightest person that has not yet been paired (pointed by left) with the heaviest (pointed by right). Increment totalBoats.
5. If the combined weight of the people at left and right pointers is less than or equal to maxWeight, move the left pointer to the right (indicating that these two people can share a boat).
6. Always move the right pointer to the left (indicating that this person is now accounted for, either alone or with another).
7. The loop terminates when all people have been accounted for (left exceeds right).
8. Return the totalBoats as the result, which is the minimum number of boats required.

This method efficiently pairs the heaviest and lightest persons remaining to minimize the number of boats needed, ensuring that each boat carries the maximum possible weight without exceeding the limit.

class Solution {
    public int minBoatsRequired(int[] weights, int maxWeight) {
        Arrays.sort(weights);
        int start = 0, end = weights.length - 1;
        int boatCount = 0;

        while (start <= end) {
            boatCount++;
            if (weights[start] + weights[end] <= maxWeight)
                start++;
            end--;
        }

        return boatCount;
    }
}

The provided Java solution for the problem "Boats to Save People" involves calculating the minimum number of boats required to save people based on their weights and the maximum weight a boat can hold.

Here's a breakdown of the approach:

• First, sort the array of weights. This allows efficient pairing of the lightest and heaviest persons that can potentially share a boat.
• Initialize two pointers: start at the beginning of the array to represent the lightest person, and end at the end of the array to represent the heaviest.
• Initialize boatCount to keep track of the number of boats needed.
• Use a while loop to process the weights:
  • Increment boatCount for each iteration, assuming that at least one boat is used in each pass.
  • If the sum of the weights at the start and end pointers is less than or equal to maxWeight, increment the start pointer to consider the next lightest person for the pairing in the next iteration.
  • Decrement the end pointer to consider the next heaviest person in the next iteration regardless of whether the current pair was eligible to share a boat or not.

Return the total boatCount.

This method efficiently calculates the required number of boats by always attempting to pair the lightest and the heaviest persons remaining in the sorted list. By doing this, it ensures that each boat carries the maximum possible weight, thus minimizing the total number of boats needed.