Skip to content

Complete Interview Preparation at 20% off | Use code: PREPAREKARO Check Now

Related Articles

Related Articles

Minimum cost of choosing 3 increasing elements in an array of size N

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 17 Aug, 2021

Given two arrays arr[] and cost[] where cost[i] is the cost associated with arr[i], the task is to find the minimum cost of choosing three elements from the array such that arr[i] < arr[j] < arr[j].

Examples: 

Input: arr[] = {2, 4, 5, 4, 10}, cost[] = {40, 30, 20, 10, 40} 
Output: 90 
(2, 4, 5), (2, 4, 10) and (4, 5, 10) are 
the only valid triplets with cost 90.

Input: arr[] = {1, 2, 3, 4, 5, 6}, cost[] = {10, 13, 11, 14, 15, 12} 
Output: 33 
 

Naive approach: A basic approach is two-run three nested loops and to check every possible triplet. The time complexity of this approach will be O(n3).

Efficient approach: An efficient approach is to fix the middle element and search for the smaller element with minimum cost on its left and the larger element with minimum cost on its right in the given array. If a valid triplet is found then update the minimum cost far. The time complexity of this approach will be O(n2).

Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the minimum required cost
int minCost(int arr[], int cost[], int n)
{
 
    // To store the cost of choosing three elements
    int costThree = INT_MAX;
 
    // Fix the middle element
    for (int j = 0; j < n; j++) {
 
        // Initialize cost of the first
        // and the third element
        int costI = INT_MAX, costK = INT_MAX;
 
        // Search for the first element
        // in the left subarray
        for (int i = 0; i < j; i++) {
 
            // If smaller element is found
            // then update the cost
            if (arr[i] < arr[j])
                costI = min(costI, cost[i]);
        }
 
        // Search for the third element
        // in the right subarray
        for (int k = j + 1; k < n; k++) {
 
            // If greater element is found
            // then update the cost
            if (arr[k] > arr[j])
                costK = min(costK, cost[k]);
        }
 
        // If a valid triplet was found then
        // update the minimum cost so far
        if (costI != INT_MAX && costK != INT_MAX) {
            costThree = min(costThree, cost[j]
                                           + costI
                                           + costK);
        }
    }
 
    // No such triplet found
    if (costThree == INT_MAX)
        return -1;
    return costThree;
}
 
// Driver code
int main()
{
    int arr[] = { 2, 4, 5, 4, 10 };
    int cost[] = { 40, 30, 20, 10, 40 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << minCost(arr, cost, n);
 
    return 0;
}

Java



// Java implementation of the approach
class GFG
{
     
// Function to return the minimum required cost
static int minCost(int arr[], int cost[], int n)
{
 
    // To store the cost of choosing three elements
    int costThree = Integer.MAX_VALUE;
 
    // Fix the middle element
    for (int j = 0; j < n; j++)
    {
 
        // Initialize cost of the first
        // and the third element
        int costI = Integer.MAX_VALUE;
        int costK = Integer.MAX_VALUE;
 
        // Search for the first element
        // in the left subarray
        for (int i = 0; i < j; i++)
        {
 
            // If smaller element is found
            // then update the cost
            if (arr[i] < arr[j])
                costI = Math.min(costI, cost[i]);
        }
 
        // Search for the third element
        // in the right subarray
        for (int k = j + 1; k < n; k++)
        {
 
            // If greater element is found
            // then update the cost
            if (arr[k] > arr[j])
                costK = Math.min(costK, cost[k]);
        }
 
        // If a valid triplet was found then
        // update the minimum cost so far
        if (costI != Integer.MAX_VALUE &&
            costK != Integer.MAX_VALUE)
        {
            costThree = Math.min(costThree, cost[j] +
                                    costI + costK);
        }
    }
 
    // No such triplet found
    if (costThree == Integer.MAX_VALUE)
        return -1;
         
    return costThree;
}
 
// Driver code
public static void main (String[] args)
{
    int arr[] = { 2, 4, 5, 4, 10 };
    int cost[] = { 40, 30, 20, 10, 40 };
    int n = arr.length;
 
    System.out.println(minCost(arr, cost, n));
}
}
 
// This code is contributed by AnkitRai01
Python3



# Python3 implementation of the approach
 
# Function to return the minimum required cost
def minCost(arr, cost, n):
 
    # To store the cost of choosing three elements
    costThree = 10**9
 
    # Fix the middle element
    for j in range(n):
 
        # Initialize cost of the first
        # and the third element
        costI = 10**9
        costK = 10**9
 
        # Search for the first element
        # in the left subarray
        for i in range(j):
 
            # If smaller element is found
            # then update the cost
            if (arr[i] < arr[j]):
                costI = min(costI, cost[i])
 
        # Search for the third element
        # in the right subarray
        for k in range(j + 1, n):
 
            # If greater element is found
            # then update the cost
            if (arr[k] > arr[j]):
                costK = min(costK, cost[k])
 
        # If a valid triplet was found then
        # update the minimum cost so far
        if (costI != 10**9 and costK != 10**9):
            costThree = min(costThree, cost[j] +
                               costI + costK)
 
    # No such triplet found
    if (costThree == 10**9):
        return -1
    return costThree
 
# Driver code
arr = [2, 4, 5, 4, 10]
cost = [40, 30, 20, 10, 40]
n = len(arr)
 
print(minCost(arr, cost, n))
 
# This code is contributed by Mohit Kumar
C#



// C# implementation of the approach
using System;
 
class GFG
{
         
// Function to return the
// minimum required cost
static int minCost(int []arr,
                   int []cost, int n)
{
 
    // To store the cost of
    // choosing three elements
    int costThree = int.MaxValue;
 
    // Fix the middle element
    for (int j = 0; j < n; j++)
    {
 
        // Initialize cost of the first
        // and the third element
        int costI = int.MaxValue;
        int costK = int.MaxValue;
 
        // Search for the first element
        // in the left subarray
        for (int i = 0; i < j; i++)
        {
 
            // If smaller element is found
            // then update the cost
            if (arr[i] < arr[j])
                costI = Math.Min(costI, cost[i]);
        }
 
        // Search for the third element
        // in the right subarray
        for (int k = j + 1; k < n; k++)
        {
 
            // If greater element is found
            // then update the cost
            if (arr[k] > arr[j])
                costK = Math.Min(costK, cost[k]);
        }
 
        // If a valid triplet was found then
        // update the minimum cost so far
        if (costI != int.MaxValue &&
            costK != int.MaxValue)
        {
            costThree = Math.Min(costThree, cost[j] +
                                    costI + costK);
        }
    }
 
    // No such triplet found
    if (costThree == int.MaxValue)
        return -1;
         
    return costThree;
}
 
// Driver code
static public void Main ()
{
    int []arr = { 2, 4, 5, 4, 10 };
    int []cost = { 40, 30, 20, 10, 40 };
    int n = arr.Length;
 
    Console.Write(minCost(arr, cost, n));
}
}
 
// This code is contributed by Sachin..
Javascript



<script>
 
// JavaScript implementation of the approach
 
// Function to return the minimum required cost
function minCost(arr,cost,n)
{
    // To store the cost of choosing three elements
    let costThree = Number.MAX_VALUE;
   
    // Fix the middle element
    for (let j = 0; j < n; j++)
    {
   
        // Initialize cost of the first
        // and the third element
        let costI = Number.MAX_VALUE;
        let costK = Number.MAX_VALUE;
   
        // Search for the first element
        // in the left subarray
        for (let i = 0; i < j; i++)
        {
   
            // If smaller element is found
            // then update the cost
            if (arr[i] < arr[j])
                costI = Math.min(costI, cost[i]);
        }
   
        // Search for the third element
        // in the right subarray
        for (let k = j + 1; k < n; k++)
        {
   
            // If greater element is found
            // then update the cost
            if (arr[k] > arr[j])
                costK = Math.min(costK, cost[k]);
        }
   
        // If a valid triplet was found then
        // update the minimum cost so far
        if (costI != Number.MAX_VALUE &&
            costK != Number.MAX_VALUE)
        {
            costThree = Math.min(costThree, cost[j] +
                                    costI + costK);
        }
    }
   
    // No such triplet found
    if (costThree == Number.MAX_VALUE)
        return -1;
           
    return costThree;
}
 
// Driver code
let arr=[2, 4, 5, 4, 10];
let cost=[40, 30, 20, 10, 40 ];
let n = arr.length;
document.write(minCost(arr, cost, n));
 
 
// This code is contributed by unknown2108
 
</script>
Output: 
90
 

My Personal Notes
arrow_drop_up
Previous
Replace elements with absolute difference of smallest element on left and largest element on right
Next

Nitish Kumar - Geek on the top | "An opportunity may come from anywhere, so always be prepared"
Recommended Articles
Page :
Minimum cost to convert all elements of a K-size subarray to 0 from given Ternary Array with subarray sum as cost
05, Jul 21
Minimize cost of choosing and skipping array elements to reach end of the given array
25, Oct 20
Minimize cost to reduce Array if for choosing every 2 elements, 3rd one is chosen for free
26, Jan 22
Minimize cost by splitting given Array into subsets of size K and adding highest K/2 elements of each subset into cost
26, Jan 22
Find the maximum cost of an array of pairs choosing at most K pairs
23, Apr 19
Minimum sum by choosing minimum of pairs from array
25, Oct 17
Minimum operations to choose Array elements with sum as K by choosing element from front, or rear or both
29, Nov 21
Minimum cost to empty Array where cost of removing an element is 2^(removed_count) * arr[i]
20, Jul 20
Calculate cost of visiting all array elements in increasing order
12, Mar 21
Minimize cost to sort the Array by moving elements with cost as the value itself
29, Sep 21
Maximize the subarray sum by choosing M subarrays of size K
01, Nov 21
Minimum cost to complete given tasks if cost of 1, 7 and 30 days are given
09, Jul 21
Maximum modified Array sum possible by choosing elements as per the given conditions
19, Aug 20
Minimum cost to make array size 1 by removing larger of pairs
23, Dec 17
Minimum sum obtained by choosing N number from given N pairs
02, Jul 20
Minimize cost to sort an Array by swapping any pair of element (X, Y) with cost as (X + Y)
20, Jul 21
Minimize cost to empty given array where cost of removing an element is its absolute difference with Time instant
08, Dec 20
Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset
03, Jan 21
Minimize cost to traverse the Arrays with given Array switching cost
27, Apr 22
Minimize the sum after choosing elements from the given three arrays
29, May 19
Maximize the product of sum and least power by choosing at most K elements from given value and power Arrays
28, Oct 21
Minimum size Subarray with maximum sum in non-increasing order
16, Apr 20
Minimum cost required to convert all Subarrays of size K to a single element
07, Aug 20
Divide given numeric string into at most two increasing subsequences which form an increasing string upon concatenation
03, Sep 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
manoje1729
@manoje1729
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!