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

Last Updated : 18 Sep, 2023

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:

• Initialize the dp[] array to INT_MAX.
• Initialize the current minimum sum(say current_sum) to INT_MAX.
• 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.
• 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[0]);` `    `  `    ``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)

Efficient approach : Space optimization O(1)

To optimize the space complexity since we only need to access the values of dp[i] and dp[i-1] to compute dp[i+1], we can just use two variables to store these values instead of an entire array. This way, the space complexity will be reduced from O(N) to O(1)

Implementation Steps:

• We can observe that we only need to keep track of the two most recent values of dp[j] for a given i.
• Therefore, we can replace the dp[] array with just two variables, dp[0] and dp[1].
• We can initialize both variables to INT_MAX at the start of each iteration of i.
• In the inner loop, we can update dp[1] instead of dp[j], and update ans using dp[0] instead of dp[i].
• At the end of each iteration of i, we can copy the value of dp[1] to dp[0] and reset dp[1] to INT_MAX.
• At last return -1 if ans is still INT_MAX, or return ans.

Implementation:

## C++

 `// C++ program for above approach`   `#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[2];`   `    ``for` `(``int` `i = 0; i < 2; 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[1] = (``long``)min((``long``)dp[1],` `                                  ``(``long``)price[i]` `                                      ``+ (``long``)price[j]);`   `                ``// Update the minimum` `                ``// sum as ans` `                ``ans = min(ans,` `                          ``(``long``)dp[0] + (``long``)price[j]);` `            ``}` `        ``}` `        ``// Copy dp[1] to dp[0] for the next iteration` `        ``dp[0] = dp[1];` `        ``dp[1] = INT_MAX;` `    ``}`   `    ``// If there is no minimum sum exist` `    ``// then print -1 else print the ans` `    ``return` `ans != INT_MAX ? ans : -1;` `    ``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[0]);`   `    ``cout << (minSum(n, num, price));` `}` `// this code is contributed by bhardwajji`

## Java

 `public` `class` `Main {`   `    ``// Function to minimize the sum of price by taking a triplet` `    ``public` `static` `long` `minSum(``int` `n, ``int``[] num, ``int``[] price) {` `        ``long``[] dp = ``new` `long``[``2``];`   `        ``// Initialize dp[] array` `        ``for` `(``int` `i = ``0``; i < ``2``; i++) {` `            ``dp[i] = 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 the stored value` `                    ``dp[``1``] = Math.min(dp[``1``], (``long``) price[i] + (``long``) price[j]);`   `                    ``// Update the minimum sum as ans` `                    ``ans = Math.min(ans, (``long``) dp[``0``] + (``long``) price[j]);` `                ``}` `            ``}` `            ``// Copy dp[1] to dp[0] for the next iteration` `            ``dp[``0``] = dp[``1``];` `            ``dp[``1``] = Integer.MAX_VALUE;` `        ``}`   `        ``// If there is no minimum sum exist then return -1, else return the ans` `        ``return` `ans != Integer.MAX_VALUE ? ans : -``1``;` `    ``}`   `    ``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));` `    ``}` `}`

## Python

 `def` `min_sum(n, num, price):` `    ``# Initialize a dp[] array` `    ``dp ``=` `[``float``(``'inf'``)] ``*` `2`   `    ``# Stores the final result` `    ``ans ``=` `float``(``'inf'``)`   `    ``# 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[``1``] ``=` `min``(dp[``1``], price[i] ``+` `price[j])` `                ``# Update the minimum sum as ans` `                ``ans ``=` `min``(ans, dp[``0``] ``+` `price[j])`   `        ``# Copy dp[1] to dp[0] for the next iteration` `        ``dp[``0``], dp[``1``] ``=` `dp[``1``], ``float``(``'inf'``)`   `    ``# If there is no minimum sum exist then return -1, else return the ans` `    ``return` `ans ``if` `ans !``=` `float``(``'inf'``) ``else` `-``1`     `# Driver Code` `num ``=` `[``2``, ``4``, ``6``, ``7``, ``8``]` `price ``=` `[``10``, ``20``, ``100``, ``20``, ``40``]` `n ``=` `len``(price)`   `print``(min_sum(n, num, price))`

## C#

 `using` `System;`   `class` `Program` `{` ` ``// Function to minimize the sum of` `// price by taking a triplet` `    ``static` `long` `MinSum(``int` `n, ``int``[] num, ``int``[] price)` `    ``{` `      ``// Initialize a dp[] array` `        ``long``[] dp = ``new` `long``[2];` `        ``for` `(``int` `i = 0; i < 2; i++)` `            ``dp[i] = ``int``.MaxValue;` `        ``// Stores the final 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++)` `            ``{` `                ``if` `(num[j] > num[i])` `                ``{` `                    ``dp[1] = Math.Min(dp[1], (``long``)price[i] + (``long``)price[j]);` `                    ``ans = Math.Min(ans, (``long``)dp[0] + (``long``)price[j]);` `                ``}` `            ``}`   `            ``dp[0] = dp[1];` `            ``dp[1] = ``int``.MaxValue;` `        ``}`   `        ``return` `ans != ``int``.MaxValue ? ans : -1;` `    ``}`   `    ``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));` `    ``}` `}`

## Javascript

 `// Function to minimize the sum of` `// price by taking a triplet` `function` `minSum(n, num, price) {` `// Initialize a dp[] array` `let dp = [Infinity, Infinity];` `// Stores the final result` `let ans = Infinity;`   `// Iterate for all values till N` `for` `(let i = 0; i < n; i++) {` `    ``for` `(let 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[1] = Math.min(dp[1], price[i] + price[j]);`   `            ``// Update the minimum` `            ``// sum as ans` `            ``ans = Math.min(ans, dp[0] + price[j]);` `        ``}` `    ``}` `    ``// Copy dp[1] to dp[0] for the next iteration` `    ``dp[0] = dp[1];` `    ``dp[1] = Infinity;` `}`   `// If there is no minimum sum exist` `// then print -1 else print the ans` `return` `ans != Infinity ? ans : -1;` `}`   `// Driver Code` `let num = [2, 4, 6, 7, 8];` `let price = [10, 20, 100, 20, 40];`   `let n = price.length;`   `console.log(minSum(n, num, price));`

Output

```50

```

Time Complexity: O(N^2)
Auxiliary Space: O(1)