Related Articles
Minimum possible sum of prices of a Triplet from the given Array
• Difficulty Level : Medium
• Last Updated : 17 Sep, 2020

Given an array num[] of N integers where each element is associated with a price given by another array price[], the task is to minimize the sum of price by taking a triplet such that num[i] < num[j] < num[k]. If there is no such triplet then print -1.

Examples:

Input: num[]={2, 4, 6, 7, 8}, price[]={10, 20, 100, 20, 40}
Output: 50
Explanation:
Selecting the triplet {2, 4, 7} because (2 < 4 < 7), and the price is 10 + 20 + 20 = 50 which is the minimum possible.

Input: num[]={100, 101, 100}, price[]={2, 4, 5}
Output: -1
Explanation:
No possible triplet exists.

Naive Approach:
The simplest approach is to generate all possible triplets (i, j, k) such that i < j < k and num[i] < num[j] < num[k] then find the sum of prices[i], prices[j], and prices[k]. Print the minimum sum of all such triplets.

Time Complexity: O(N3)
Auxiliary Space: O(1)

Efficient Approach: The idea is to use auxiliary array dp[] to store the minimum sum of prices of all such triplets and print the minimum of all the prices stored in it. Below are the steps:

1. Initialize the dp[] array to INT_MAX.
2. Initialize the current minimum sum(say current_sum) to INT_MAX.
3. Generate all possible pairs (i, j) such that j > i. If nums[j] > num[i] then update dp[j] = min(dp[j], price[i] + price[j]) as this is one of the possible pairs.
4. In each pair (i, j) in the above steps update the minimum sum of triplets to min(current_sum, dp[i] + price[j]). This step will ensure that the possible triplets (i, j, k) is formed as dp[i] will store the sum of the price at index i and j, and j is the value of k.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach``#include``#include``using` `namespace` `std;`` ` `// Function to minimize the sum of``// price by taking a triplet``long` `minSum(``int` `n, ``int` `num[], ``int` `price[])``{``     ` `    ``// Initialize a dp[] array``    ``long` `dp[n];`` ` `    ``for``(``int` `i = 0; i < n; i++)``        ``dp[i] = INT_MAX;`` ` `    ``// Stores the final result``    ``long` `ans = INT_MAX;`` ` `    ``// Iterate for all values till N``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``for``(``int` `j = i + 1; j < n; j++)``        ``{``             ` `            ``// Check if num[j] > num[i]``            ``if` `(num[j] > num[i]) ``            ``{``                 ` `                ``// Update dp[j] if it is``                ``// greater than stored value``                ``dp[j] = (``long``)min((``long``)dp[j],``                                  ``(``long``)price[i] +``                                  ``(``long``)price[j]);`` ` `                ``// Update the minimum``                ``// sum as ans``                ``ans = min(ans, (``long``)dp[i] +``                               ``(``long``)price[j]);``            ``}``        ``}``    ``}``     ` `    ``// If there is no minimum sum exist``    ``// then print -1 else print the ans``    ``return` `ans != INT_MAX ? ans : -1;``}`` ` `// Driver Code``int` `main()``{``    ``int` `num[] = { 2, 4, 6, 7, 8 };``    ``int` `price[] = { 10, 20, 100, 20, 40 };``     ` `    ``int` `n = ``sizeof``(price) / ``sizeof``(price);``     ` `    ``cout << (minSum(n, num, price));``}`` ` `// This code is contributed by chitranayal`

## Java

 `// Java Program to implement``// the above approach``import` `java.util.*;``import` `java.io.*;`` ` `public` `class` `Main {`` ` `    ``// Function to minimize the sum of``    ``// price by taking a triplet``    ``public` `static` `long` `minSum(``int` `n, ``int` `num[],``                              ``int` `price[])``    ``{`` ` `        ``// Initialize a dp[] array``        ``long` `dp[] = ``new` `long``[n];`` ` `        ``Arrays.fill(dp, Integer.MAX_VALUE);`` ` `        ``// Stores the final result``        ``long` `ans = Integer.MAX_VALUE;`` ` `        ``// Iterate for all values till N``        ``for` `(``int` `i = ``0``; i < n; i++) {`` ` `            ``for` `(``int` `j = i + ``1``; j < n; j++) {`` ` `                ``// Check if num[j] > num[i]``                ``if` `(num[j] > num[i]) {`` ` `                    ``// Update dp[j] if it is``                    ``// greater than stored value``                    ``dp[j] = (``long``)Math.min(``                        ``(``long``)dp[j],``                        ``(``long``)price[i]``                            ``+ (``long``)price[j]);`` ` `                    ``// Update the minimum``                    ``// sum as ans``                    ``ans = Math.min(``                        ``ans, (``long``)dp[i]``                                 ``+ (``long``)price[j]);``                   ` `                ``}``            ``}``        ``}``       ` ` ` `        ``// If there is no minimum sum exist``        ``// then print -1 else print the ans``        ``return` `ans != Integer.MAX_VALUE ? ans : -``1``;``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void``        ``main(String[] args)``    ``{`` ` `        ``int` `num[] = { ``2``, ``4``, ``6``, ``7``, ``8` `};``        ``int` `price[] = { ``10``, ``20``, ``100``, ``20``, ``40` `};`` ` `        ``int` `n = price.length;`` ` `        ``System.out.println(minSum(n, num, price));``    ``}``}`

## Python3

 `# Python3 program to implement``# the above approach``import` `sys;`` ` `# Function to minimize the sum of``# price by taking a triplet``def` `minSum(n, num, price):``     ` `    ``# Initialize a dp[] list``    ``dp ``=` `[``0` `for` `i ``in` `range``(n)]``    ``for` `i ``in` `range``(n):``        ``dp[i] ``=` `sys.maxsize`` ` `    ``# Stores the final result``    ``ans ``=` `sys.maxsize`` ` `    ``# Iterate for all values till N``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(i ``+` `1``, n):``             ` `            ``# Check if num[j] > num[i]``            ``if` `(num[j] > num[i]):``                 ` `                ``# Update dp[j] if it is``                ``# greater than stored value``                ``dp[j] ``=` `min``(dp[j], price[i] ``+` `                                   ``price[j])`` ` `                ``# Update the minimum``                ``# sum as ans``                ``ans ``=` `min``(ans, dp[i] ``+` `price[j])``                 ` `    ``# If there is no minimum sum exist``    ``# then print -1 else print the ans``    ``if` `ans ``is` `not` `sys.maxsize:``        ``return` `ans``    ``else``:``        ``return` `-``1`` ` `# Driver code``if` `__name__``=``=``'__main__'``:``     ` `    ``num ``=` `[ ``2``, ``4``, ``6``, ``7``, ``8` `]``    ``price ``=` `[ ``10``, ``20``, ``100``, ``20``, ``40` `]``     ` `    ``n ``=` `len``(price)``     ` `    ``print``(minSum(n, num, price))`` ` `# This code is contributed by rutvik_56`

## C#

 `// C# program to implement``// the above approach``using` `System;`` ` `class` `GFG{`` ` `// Function to minimize the sum of``// price by taking a triplet``public` `static` `long` `minSum(``int` `n, ``int` `[]num,``                          ``int` `[]price)``{``     ` `    ``// Initialize a []dp array``    ``long` `[]dp = ``new` `long``[n];``    ``for``(``int` `i = 0; i < n; i++)``        ``dp[i] = ``int``.MaxValue;`` ` `    ``// Stores the readonly result``    ``long` `ans = ``int``.MaxValue;`` ` `    ``// Iterate for all values till N``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``for``(``int` `j = i + 1; j < n; j++)``        ``{`` ` `            ``// Check if num[j] > num[i]``            ``if` `(num[j] > num[i]) ``            ``{`` ` `                ``// Update dp[j] if it is``                ``// greater than stored value``                ``dp[j] = (``long``)Math.Min((``long``)dp[j],``                                       ``(``long``)price[i] +``                                       ``(``long``)price[j]);`` ` `                ``// Update the minimum``                ``// sum as ans``                ``ans = Math.Min(ans, (``long``)dp[i] +``                                    ``(``long``)price[j]);``            ``}``        ``}``    ``}``     ` `    ``// If there is no minimum sum exist``    ``// then print -1 else print the ans``    ``return` `ans != ``int``.MaxValue ? ans : -1;``}`` ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]num = { 2, 4, 6, 7, 8 };``    ``int` `[]price = { 10, 20, 100, 20, 40 };`` ` `    ``int` `n = price.Length;`` ` `    ``Console.WriteLine(minSum(n, num, price));``}``}`` ` `// This code is contributed by 29AjayKumar`
Output:
```50
```

Time Complexity: O(N2)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up