 Open in App
Not now

# Minimum possible sum of prices of a Triplet from the given Array

• Difficulty Level : Medium
• Last Updated : 20 Oct, 2021

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`

## Javascript

 ``

Output:

`50`

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

My Personal Notes arrow_drop_up