Find Maximum Sum of Mountain Triplets

Given an array A[] of integers. Then the task is to output the maximum sum of a triplet (A_i, A_j, A_k) such that it must follow the conditions: (i < j < k) and (A_i< A_j > A_k). If no such triplet exists, then output -1.

Examples:

Input: A[] = {1, 5, 4, 7, 3}

Output: 15

Explanation: There are following 6 possible triplets following the condition (i < j < k) and (A_i< A_j > A_k):

(A₁, A₂, A₃): Sum = 1 + 5 + 4 = 10
(A₁, A₂, A₅): Sum = 1 + 5 + 3 = 13
(A₁, A₃, A₅): Sum = 1 + 4 + 3 = 8
(A₁, A₄, A₅): Sum = 1 + 7 + 3 = 11
(A₂, A₄, A₅): Sum = 5 + 7 + 3 = 15
(A₃, A₄, A₅): Sum = 4 + 7 + 3 = 14
It is clearly visible the maximum sum is 15, given by the triplet (A₂, A₄, A₅). Therefore, output is 15.

Input: A[] = {2, 1, 3, 4}

Output: -1

Explanation: No valid triplet exists following both of given conditions. Therefore, output is -1.

Brute Force Approach: The basic idea to solve the problem is as follows:

Use 3 nested loops to iterate over all possible triplets following the conditions (i < j < k) and (A_i< A_j > A_k).

Steps were taken to solve the problem:

Create a variable let say MaxSum to store the maximum sum of triplet.
Run 3 nested loops to create all possible triplets and follow the condition inside the innermost nested loop:
- If (A_j > A_i && A_j > A_k)
  - Sum = A_i + A_j + A_k
  - MaxSum = max(Sum, MaxSum)
If (MaxSum == 0), then return -1 else return MaxSum.

Code to implement the approach:

C++

#include <iostream>
using namespace std;

// Function to return maximum sum of triplet if it exists
int MaxTripletSum(int A[], int N)
{
    // Variable to store max sum
    int maxSum = 0;

    // Three nested loops to iterate over all possible triplets
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {
            for (int k = j + 1; k < N; k++) {

                // Checking for the condition mentioned
                if (A[j] > A[i] && A[j] > A[k]) {
                    // Adding elements of triplets
                    int sum = A[i] + A[j] + A[k];

                    // Updating max if sum is greater than max
                    maxSum = max(maxSum, sum);
                }
            }
        }
    }

    // Returning maxSum if triplet exists, else returning -1
    return maxSum == 0 ? -1 : maxSum;
}

// Driver Function
int main()
{
    // Input A[]
    int A[] = {1, 5, 4, 7, 3};
    int N = sizeof(A) / sizeof(A[0]);

    // Function call
    cout << MaxTripletSum(A, N) << endl;

    return 0;
}

Java

// Java code to implement the brute
// force approach

// Driver Class
class Main {

    // Driver Function
    public static void main(String[] args)
    {
        // Input A[]
        int A[] = { 1, 5, 4, 7, 3 };

        // Function call
        System.out.print(MaxTripletSum(A));
    }

    // Method to return maximum sum of triplet
    // If it exists
    static int MaxTripletSum(int[] A)
    {

        int N = A.length;

        // Variable to store max sum
        int maxSum = 0;

        // Three nested loops for iterate over
        // all possible triplets
        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
                for (int k = j + 1; k < N; k++) {

                    // Checking for the condition
                    // mentioned
                    if (A[j] > A[i] && A[j] > A[k]) {
                        // Adding element of
                        // triplets
                        int sum = A[i] + A[j] + A[k];

                        // Updating max if sum is
                        // greater than max
                        maxSum = Math.max(maxSum, sum);
                    }
                }
            }
        }

        // Returning maxSum if triplet exists
        // Else returning -1
        return maxSum == 0 ? -1 : maxSum;
    }
}

using System;

class GFG {
    // Driver Function
    public static void Main(string[] args)
    {
        // Input A[]
        int[] A = { 1, 5, 4, 7, 3 };

        // Function call
        Console.Write(MaxTripletSum(A));
    }

    // Method to return maximum sum of triplet
    // If it exists
    static int MaxTripletSum(int[] A)
    {
        int N = A.Length;

        // Variable to store max sum
        int maxSum = 0;

        // Three nested loops for iterate over
        // all possible triplets
        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
                for (int k = j + 1; k < N; k++) {
                    // Checking for the condition
                    // mentioned
                    if (A[j] > A[i] && A[j] > A[k]) {
                        // Adding element of
                        // triplets
                        int sum = A[i] + A[j] + A[k];

                        // Updating max if sum is
                        // greater than max
                        maxSum = Math.Max(maxSum, sum);
                    }
                }
            }
        }

        // Returning maxSum if triplet exists
        // Else returning -1
        return maxSum == 0 ? -1 : maxSum;
    }
}

JavaScript

// JavaScript code to implement the brute
// force approach

// Function to return maximum sum 
// of triplet if it exists
function MaxTripletSum(A) {
    const N = A.length;

    // Variable to store max sum
    let maxSum = 0;

    // Three nested loops for iterating
    // over all possible triplets
    for (let i = 0; i < N; i++) {
        for (let j = i + 1; j < N; j++) {
            for (let k = j + 1; k < N; k++) {
                // Checking for the condition mentioned
                if (A[j] > A[i] && A[j] > A[k]) {
                // Adding elements of triplets
                    const sum = A[i] + A[j] + A[k];

                    // Updating max if sum is greater than max
                    maxSum = Math.max(maxSum, sum);
                }
            }
        }
    }

    // Returning maxSum if triplet
    // exists, else returning -1
    return maxSum === 0 ? -1 : maxSum;
}

// Input A[]
const A = [1, 5, 4, 7, 3];

// Function call
console.log(MaxTripletSum(A));

Python3

# Python code to implement the brute
# force approach

def max_triplet_sum(arr):
    n = len(arr)
    max_sum = 0

    # Three nested loops to iterate over all possible triplets
    for i in range(n):
        for j in range(i + 1, n):
            for k in range(j + 1, n):
                # Checking for the condition mentioned
                if arr[j] > arr[i] and arr[j] > arr[k]:
                    # Adding elements of triplets
                    _sum = arr[i] + arr[j] + arr[k]

                    # Updating max if sum is greater than max
                    max_sum = max(max_sum, _sum)

    # Returning max_sum if triplet exists, else returning -1
    return max_sum if max_sum != 0 else -1

# Driver code
if __name__ == "__main__":
    # Input array A
    A = [1, 5, 4, 7, 3]

    # Function call
    result = max_triplet_sum(A)
    
    print(result)

Output

Time Complexity: O(N³)
Auxiliary Space: O(1)

Efficient approach: To solve the problem follow the below idea:

Create an array let say LeftMax[] and for each index i(2 <= i <= N) store the maximum value from the range [A₁, A_i-1] at i_th index of leftMax[] and initialize leftMax₁ as A₁. After that run a loop from right end of A[] and simultaneously calculate max element to right from the current index in a variable let say RightMax. If the condition (leftMax[i] < A[i] > RightMax) met, then triplet (leftMax[i], A[i], RightMax) is valid triplet, calculate the sum of all 3 elements and update it with MaxSum.