Minimum cost of passing N persons through a given tunnel

• Difficulty Level : Easy
• Last Updated : 10 Nov, 2021

Given two positive integers X and Y and an array arr[] consisting of N positive integers such that arr[i] represents the height of the ith person and there is a tunnel of height H, the task is to find the total minimum cost required to pass all the N persons through the given tunnel such at most two-person whose sum of heights is less than H can pass at a time according to the following rules:

• When two person passes through the tunnel at a time, then the cost is Y.
• When one person passes through the tunnel at a time, then the cost is X.

Note: All array elements are less than H.

Examples:

Input: arr[] = {1, 3, 4, 4, 2}, X = 4, Y = 6, H = 9
Output: 16
Explanation:
Consider the passing of persons according to the below order:

1. Person 1 and Person 4 having heights 1 and 4 respectively has the sum of heights as 1 + 4 = 5 < H(= 9). Therefore, the cost for this operation is Y(= 6).
2. Person 2 and Person 3 having heights 3 and 4 respectively has the sum of heights as 3 + 4 = 7 < H(= 9). Therefore, the cost for this operation is Y(= 6).
3. Person 5 has height 3 which is less than H(= 9). Therefore, the cost for this operation is is X( = 4).

Therefore, the total cost is 6 + 6 + 4 = 16, which is minimum among all possible combinations.

Input: arr[] = {1, 3, 4}, X = 4, Y = 6, H = 9
Output: 10

Approach: The given problem can be solved by using the Greedy Approach and using the Two Pointer Technique. The idea is to choose those two persons whose sum of the heights is less than H with the cost of Y. Otherwise, choose the maximum height person among the two-person and pass them into the tunnel with the cost of X. Follow the steps below to solve the problem:

• Sort the given array arr[] in increasing order.
• Initialize two pointers, say i and j as 0 and (N – 1) respectively to points to the extremities of the array.
• Iterate until the value of i is less than j and perform the following steps:
• If the sum of values of arr[i] and arr[j] is less than H, then incrementing the value of cost by Y and increment the value of i and decrement the value of j by 1.
• Otherwise, decrement the value of j by 1 and update the value of cost by X.
• If the value of i and j are equal then increment the value of cost by X.
• After completing the above steps, print the value of cost as the resultant minimum cost.

Below is the implementation of the above approach:

C++

 // C++ program for the above approach #include "bits/stdc++.h"using namespace std; // Function to find the minimum total// cost of passing at most two-person// at a time through the tunnelint minimumCost(int arr[], int N, int H,                int X, int Y){     // Stores the resultant cost    int cost = 0;     // Sort the given array    sort(arr, arr + N);     // Initialize two pointers    int i = 0, j = N - 1;     // Iterate until i is less than j    while (i < j) {         // If the sum of values at        // i and j is less than H        if (arr[i] + arr[j] < H) {             // Increment the cost            cost += Y;             // Update the pointers            i++;            j--;        }         // Otherwise        else {            cost += X;            j--;        }    }     // If i and j points to the same    // element, then that person is    // not passed to the tunnel    if (i == j)        cost += X;     // Return the minimum of the total    // cost and cost of passing all the    // person individually    return min(cost, N * X);} // Driver Codeint main(){    int arr[] = { 1, 3, 4, 4, 2 };    int X = 4, Y = 6, H = 9;    int N = sizeof(arr) / sizeof(arr);    cout << minimumCost(arr, N, H, X, Y);     return 0;}

Java

 // Java program for the above approachimport java.io.*;import java.util.Arrays; class GFG{     // Function to find the minimum total// cost of passing at most two-person// at a time through the tunnelpublic static int minimumCost(int arr[], int N, int H,                              int X, int Y){         // Stores the resultant cost    int cost = 0;     // Sort the given array    Arrays.sort(arr);     // Initialize two pointers    int i = 0, j = N - 1;     // Iterate until i is less than j    while (i < j)    {                 // If the sum of values at        // i and j is less than H        if (arr[i] + arr[j] < H)        {                         // Increment the cost            cost += Y;             // Update the pointers            i++;            j--;        }         // Otherwise        else        {            cost += X;            j--;        }    }     // If i and j points to the same    // element, then that person is    // not passed to the tunnel    if (i == j)        cost += X;     // Return the minimum of the total    // cost and cost of passing all the    // person individually    return Math.min(cost, N * X);} // Driver codepublic static void main(String[] args){    int arr[] = { 1, 3, 4, 4, 2 };    int X = 4, Y = 6, H = 9;    int N = arr.length;     System.out.println(minimumCost(arr, N, H, X, Y));}} // This code is contributed by Potta Lokesh

Python3

 # Python 3 program for the above approach # Function to find the minimum total# cost of passing at most two-person# at a time through the tunneldef minimumCost(arr, N, H, X, Y):       # Stores the resultant cost    cost = 0     # Sort the given array    arr.sort()     # Initialize two pointers    i = 0    j = N - 1     # Iterate until i is less than j    while (i < j):         # If the sum of values at        # i and j is less than H        if (arr[i] + arr[j] < H):             # Increment the cost            cost += Y             # Update the pointers            i += 1            j -= 1         # Otherwise        else:            cost += X            j -= 1     # If i and j points to the same    # element, then that person is    # not passed to the tunnel    if (i == j):        cost += X     # Return the minimum of the total    # cost and cost of passing all the    # person individually    return min(cost, N * X) # Driver Codeif __name__ == '__main__':    arr = [1, 3, 4, 4, 2]    X = 4    Y = 6    H = 9    N = len(arr)    print(minimumCost(arr, N, H, X, Y))         # This code is contributed by bgangwar59.

C#

 // C# program for the above approachusing System;class GFG {     // Function to find the minimum total    // cost of passing at most two-person    // at a time through the tunnel    static int minimumCost(int[] arr, int N, int H, int X,                           int Y)    {         // Stores the resultant cost        int cost = 0;         // Sort the given array        Array.Sort(arr);         // Initialize two pointers        int i = 0, j = N - 1;         // Iterate until i is less than j        while (i < j) {             // If the sum of values at            // i and j is less than H            if (arr[i] + arr[j] < H) {                 // Increment the cost                cost += Y;                 // Update the pointers                i++;                j--;            }             // Otherwise            else {                cost += X;                j--;            }        }         // If i and j points to the same        // element, then that person is        // not passed to the tunnel        if (i == j)            cost += X;         // Return the minimum of the total        // cost and cost of passing all the        // person individually        return Math.Min(cost, N * X);    }     // Driver code    public static void Main()    {        int[] arr = { 1, 3, 4, 4, 2 };        int X = 4, Y = 6, H = 9;        int N = arr.Length;         Console.WriteLine(minimumCost(arr, N, H, X, Y));    }} // This code is contributed by subhammahato348.

Javascript


Output
16

Time Complexity: O(N*log N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up