Open In App

Find maximum sum of triplets in an array such than i < j < k and a[i] < a[j] < a[k]

Last Updated : 18 Apr, 2024
Improve
Improve
Like Article
Like
Save
Share
Report

Given an array of positive integers of size n. Find the maximum sum of triplet( ai + aj + ak ) such that 0 <= i < j < k < n and ai < aj < ak. 

Input: a[] = 2 5 3 1 4 9
Output: 16

Explanation:
All possible triplets are:-
2 3 4 => sum = 9
2 5 9 => sum = 16
2 3 9 => sum = 14
3 4 9 => sum = 16
1 4 9 => sum = 14
Maximum sum = 16

Simple Approach is to traverse for every triplet with three nested ‘for loops’ and find update the sum of all triplets one by one. Time complexity of this approach is O(n3) which is not sufficient for a larger value of ‘n’. 

Better approach is to make further optimization in above approach. Instead of traversing through every triplets with three nested loops, we can traverse through two nested loops. While traversing through each number(assume as middle element(aj)), find maximum number(ai) smaller than aj preceding it and maximum number(ak) greater than aj beyond it. Now after that, update the maximum answer with calculated sum of ai + aj + ak 

C++ 
// C++ program to find maximum triplet sum
#include <bits/stdc++.h>
using namespace std;

// Function to calculate maximum triplet sum
int maxTripletSum(int arr[], int n)
{
    // Initialize the answer
    int ans = 0;

    for (int i = 1; i < n - 1; ++i) {
        int max1 = 0, max2 = 0;

        // find maximum value(less than arr[i])
        // from 0 to i-1
        for (int j = 0; j < i; ++j)
            if (arr[j] < arr[i])
                max1 = max(max1, arr[j]);

        // find maximum value(greater than arr[i])
        // from i+1 to n-1
        for (int j = i + 1; j < n; ++j)
            if (arr[j] > arr[i])
                max2 = max(max2, arr[j]);

        // store maximum answer
        if(max1 && max2)
             ans=max(ans,max1+arr[i]+max2);
    }

    return ans;
}

// Driver code
int main()
{
    int arr[] = { 2, 5, 3, 1, 4, 9 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << maxTripletSum(arr, n);
    return 0;
}
Java 
// Java program to find maximum triplet sum

import java.io.*;
import java.math.*;

class GFG {

    // Function to calculate maximum triplet sum
    static int maxTripletSum(int arr[], int n)
    {
        // Initialize the answer
        int ans = 0;

        for (int i = 1; i < n - 1; ++i) {
            int max1 = 0, max2 = 0;

            // find maximum value(less than arr[i])
            // from 0 to i-1
            for (int j = 0; j < i; ++j)
                if (arr[j] < arr[i])
                    max1 = Math.max(max1, arr[j]);

            // find maximum value(greater than arr[i])
            // from i+1 to n-1
            for (int j = i + 1; j < n; ++j)
                if (arr[j] > arr[i])
                    max2 = Math.max(max2, arr[j]);

            // store maximum answer
        if(max1 > 0 && max2 > 0)
            ans = Math.max(ans, max1 + arr[i] + max2);
        }

        return ans;
    }

    // Driver code
    public static void main(String args[])
    {
        int arr[] = { 2, 5, 3, 1, 4, 9 };
        int n = arr.length;
        System.out.println(maxTripletSum(arr, n));
    }
}

// This code is contributed by Nikita Tiwari.
Python3 
# Python 3 program to
# find maximum triplet sum

# Function to calculate
# maximum triplet sum


def maxTripletSum(arr, n):

    # Initialize the answer
    ans = 0

    for i in range(1, (n - 1)):
        max1 = 0
        max2 = 0

        # find maximum value(less than arr[i])
        # from 0 to i-1
        for j in range(0, i):
            if (arr[j] < arr[i]):
                max1 = max(max1, arr[j])

        # find maximum value(greater than arr[i])
        # from i + 1 to n-1
        for j in range((i + 1), n):
            if (arr[j] > arr[i]):
                max2 = max(max2, arr[j])

        # store maximum answer
                if (max1 > 0 and max2 >0):
                    ans = max(ans, max1 + arr[i] + max2)

    return ans


# Driver code

arr = [2, 5, 3, 1, 4, 9]
n = len(arr)
print(maxTripletSum(arr, n))


# This code is contributed
# by Nikita Tiwari.
C# 
// C# program to find maximum triplet sum
using System;

class GFG {

    // Function to calculate maximum triplet sum
    static int maxTripletSum(int[] arr, int n)
    {
        
        // Initialize the answer
        int ans = 0;

        for (int i = 1; i < n - 1; ++i)
        {
            int max1 = 0, max2 = 0;

            // find maximum value(less than 
            // arr[i]) from 0 to i-1
            for (int j = 0; j < i; ++j)
                if (arr[j] < arr[i])
                    max1 = Math.Max(max1, arr[j]);

            // find maximum value(greater than
            // arr[i]) from i+1 to n-1
            for (int j = i + 1; j < n; ++j)
                if (arr[j] > arr[i])
                    max2 = Math.Max(max2, arr[j]);

            // store maximum answer
        if(max1 > 0 && max2 > 0)
            ans = Math.Max(ans, max1 + arr[i] + max2);
        }

        return ans;
    }

    // Driver code
    public static void Main()
    {
        
        int[] arr = { 2, 5, 3, 1, 4, 9 };
        int n = arr.Length;
        
        Console.WriteLine(maxTripletSum(arr, n));
    }
}

// This code is contributed by vt_m.
Javascript 
<script>

// JavaScript program to find maximum triplet sum

// Function to calculate maximum triplet sum
function maxTripletSum(arr, n)
{
    // Initialize the answer
    let ans = 0;

    for (let i = 1; i < n - 1; ++i) {
        let max1 = 0, max2 = 0;

        // find maximum value(less than arr[i])
        // from 0 to i-1
        for (let j = 0; j < i; ++j)
            if (arr[j] < arr[i])
                max1 = Math.max(max1, arr[j]);

        // find maximum value(greater than arr[i])
        // from i+1 to n-1
        for (let j = i + 1; j < n; ++j)
            if (arr[j] > arr[i])
                max2 = Math.max(max2, arr[j]);

        // store maximum answer
        if(max1 && max2)
            ans=Math.max(ans,max1+arr[i]+max2);
    }

    return ans;
}

// Driver code
    let arr = [ 2, 5, 3, 1, 4, 9 ];
    let n = arr.length;
    document.write(maxTripletSum(arr, n));



// This code is contributed by Surbhi Tyagi.

</script>
PHP 
<?php
// PHP program to find maximum triplet sum

// Function to calculate maximum triplet sum
function maxTripletSum($arr, $n)
{
    
    // Initialize the answer
    $ans = 0;

    for ($i = 1; $i < $n - 1; ++$i) 
    {
        $max1 = 0; $max2 = 0;

        // find maximum value(less than
        // arr[i]) from 0 to i-1
        for ($j = 0; $j < $i; ++$j)
            if ($arr[$j] < $arr[$i])
                $max1 = max($max1, $arr[$j]);

        // find maximum value(greater than
        // arr[i]) from i+1 to n-1
        for ($j = $i + 1; $j < $n; ++$j)
            if ($arr[$j] > $arr[$i])
                $max2 = max($max2, $arr[$j]);

        // store maximum answer
        if($max1 && $max2)
             $ans = max($ans, $max1 + $arr[$i] + $max2);
    }

    return $ans;
}

    // Driver code
    $arr = array(2, 5, 3, 1, 4, 9);
    $n = sizeof($arr);
    echo maxTripletSum($arr, $n);

// This code is contributed by nitin mittal.
?>

Output : 

16

Time complexity: O(n2) 
Auxiliary space: O(1)

Best and efficient approach is use the concept of maximum suffix-array and binary search. 

  • For finding a maximum number greater than given number beyond it, we can maintain a maximum suffix-array such that for any number(suffixi) it would contain maximum number from index i, i+1, … n-1. Suffix array can be calculated in O(n) time.
  • For finding maximum number smaller than the given number preceding it, we can maintain a sorted list of numbers before a given number such we can simply perform a binary search to find a number which is just smaller than the given number. In C++ language, we can perform this by using set associative container of STL library. 
     
C++ 
// C++ program to find maximum triplet sum
#include <bits/stdc++.h>
using namespace std;

// Utility function to get the lower last min
// value of 'n'
int getLowValue(set<int>& lowValue, int& n)
{
    auto it = lowValue.lower_bound(n);

    // Since 'lower_bound' returns the first
    // iterator greater than 'n', thus we
    // have to decrement the pointer for
    // getting the minimum value
    --it;

    return (*it);
}

// Function to calculate maximum triplet sum
int maxTripletSum(int arr[], int n)
{
    // Initialize suffix-array
    int maxSuffArr[n + 1];

    // Set the last element
    maxSuffArr[n] = 0;

    // Calculate suffix-array containing maximum
    // value for index i, i+1, i+2, ... n-1 in
    // arr[i]
    for (int i = n - 1; i >= 0; --i)
        maxSuffArr[i] = max(maxSuffArr[i + 1], arr[i]);

    int ans = 0;

    // Initialize set container
    set<int> lowValue;

    // Insert minimum value for first comparison
    // in the set
    lowValue.insert(INT_MIN);

    for (int i = 0; i < n - 1; ++i) {
        if (maxSuffArr[i + 1] > arr[i]) {
            int left = getLowValue(lowValue, arr[i]);
            if (left == INT_MIN) {
                // Insert arr[i] in set<> for further
                // processing
                lowValue.insert(arr[i]);
                continue;
            }
            ans = max(ans,
                      left + arr[i] + maxSuffArr[i + 1]);

            // Insert arr[i] in set<> for further
            // processing
            lowValue.insert(arr[i]);
        }
    }
    return ans;
}

// Driver code
int main()
{
    int arr[] = { 2, 5, 3, 1, 4, 9 };
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << maxTripletSum(arr, n);
    return 0;
}
Java 
// Java program to find maximum triplet sum
import java.io.*;
import java.util.*;

class GFG {

    // Function to calculate maximum triplet sum
    public static int maxTripletSum(int arr[], int n)
    {

        // Initialize suffix-array
        int maxSuffArr[] = new int[n + 1];

        // Set the last element
        maxSuffArr[n] = 0;

        // Calculate suffix-array containing maximum
        // value for index i, i+1, i+2, ... n-1 in
        // arr[i]
        for (int i = n - 1; i >= 0; --i)
            maxSuffArr[i]
                = Math.max(maxSuffArr[i + 1], arr[i]);

        int ans = 0;

        // Initialize set container
        TreeSet<Integer> lowValue = new TreeSet<Integer>();

        // Insert minimum value for first comparison
        // in the set
        lowValue.add(Integer.MIN_VALUE);

        for (int i = 0; i < n - 1; ++i) {
            if (maxSuffArr[i + 1] > arr[i]) {
                int left = lowValue.lower(arr[i]);
                if (left == Integer.MIN_VALUE) {
                    // Insert arr[i] in set<> for further
                    // processing
                    lowValue.add(arr[i]);
                    continue;
                }
                ans = Math.max(
                    ans, left + arr[i] + maxSuffArr[i + 1]);

                // Insert arr[i] in set<> for further
                // processing
                lowValue.add(arr[i]);
            }
        }
        return ans;
    }

    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { 2, 5, 3, 1, 4, 9 };
        int n = arr.length;

        System.out.println(maxTripletSum(arr, n));
    }
}
Python3 
# Python code for the above approach

import bisect
import sys

# Function to get the lower last min value of 'n'
def getLowValue(lowValue, n):
    it = bisect.bisect_left(lowValue, n)
    if it == 0:
        return -sys.maxsize
    else:
        return lowValue[it-1]

# Function to calculate maximum triplet sum
def maxTripletSum(arr, n):
    # Initialize suffix-array
    maxSuffArr = [0] * (n + 1)

    # Set the last element
    maxSuffArr[n] = 0

    # Calculate suffix-array containing maximum
    # value for index i, i+1, i+2, ... n-1 in arr[i]
    for i in range(n-1, -1, -1):
        maxSuffArr[i] = max(maxSuffArr[i + 1], arr[i])

    ans = 0

    # Initialize list to store minimum values
    lowValue = [-sys.maxsize]

    for i in range(n - 1):
        if maxSuffArr[i + 1] > arr[i]:
            ans = max(ans, getLowValue(lowValue, arr[i])
                      + arr[i] + maxSuffArr[i + 1])

            # Insert arr[i] in list for further processing
            bisect.insort_left(lowValue, arr[i])

    return ans

# Driver code
arr = [2, 5, 3, 1, 4, 9]
n = len(arr)

print(maxTripletSum(arr, n))

# This code is contributed by sdeaditysharma

Output:

16

Time complexity: O(n*log(n)) 
Auxiliary space: O(n)


 



Like Article
Suggest improvement
Previous
Count the number of ways to divide an array into three contiguous parts having equal sum
Next
Minimum element whose n-th power is greater than product of an array of size n
Share your thoughts in the comments

Similar Reads

Number of triplets such that each value is less than N and each pair sum is a multiple of K
Find triplet such that number of nodes connecting these triplets is maximum
Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
Maximum removals possible from an array such that sum of its elements is greater than or equal to that of another array
Find number of triplets in array such that a[i]>a[j]>a[k] and i<j<k
Count of triplets from the given Array such that sum of any two elements is the third element
Count all Grandparent-Parent-Child Triplets in a binary tree whose sum is greater than X
Print triplets with sum less than k
C++ Program to Count triplets with sum smaller than a given value
Java Program to Count triplets with sum smaller than a given value
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Article Tags :
Practice Tags :
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