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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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++) {
  
        // Initialse 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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++)
    
  
        // Initialse 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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):
  
        # Initialse 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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++)
    
  
        // Initialse 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..

chevron_right


Output:

90


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.





Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.