Maximize the value of (A[i]-A[j])*A[k] for any ordered triplet of indices i, j and k

Given an array A consisting of N positive integers and for any ordered triplet( i, j, k) such that i, j, and k are all distinct and 0 ≤ i, j, k < N, the value of this triplet is (A_i − A_j)⋅A_k, the task is to find maximum value among all distinct ordered triplets.

Note: Two triplets (a, b, c) and (d, e, f) are considered to be different if at least one of the conditions is satisfied such that a ≠ d or b ≠ e or c ≠ f. As an example, (1, 2, 3) and (2, 3, 1) are two different ordered triplets.

Examples:

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

Explanation: The desired triplet is (2, 1, 0), which yields the value of (A_i−A_j)⋅A_k = (3 − 1)⋅1 = 2.

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

Approach: The problem can be solved based on the following observation:

Sort the array A in increasing order. Since we want to maximize the value of (A_i − A_j).A_k, and all elements in A are positive, it is best to maximise both (A_i − A_j) and A_k. There are two options:

• Select largest and smallest element in A as A_i and A_j, and choose second maximum element in A as A_k. The value is (A_N-1 − A₀).A_N−2
• Choose the maximum element as A_k and choose the second maximum element, and the minimum element as A_i and A_j, getting a triplet of value (A_N-2 − A₀).A_N-1

Since A_{N – 2} ≤ A_N-1, we can prove that  (A_N-1 − A₀).A_N−2 ≥ (A_N-2 − A₀).A_N-1. Hence, the maximum value we can obtain is 
(A_N-1 − A₀).A_N−2 

Follow the below steps to solve the problem:

• Sort the array in ascending order.
• Find the difference between the maximum and minimum element of the sorted array
• Then multiply the difference with the second maximum element of the sorted array to get the answer.

Below is the implementation of the above approach.

C++

// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;

// Function to find maximum value among all distinct
// ordered tuple
long maxValue(int a[], int n)
{
    sort(a, a + n);
    int min = a[0];
    int max = a[n - 1];
    int secmax = a[n - 2];
    long ans = (long)(a[n - 1] - a[0]) * a[n - 2];
    return ans;
}

// Driver Code
int main()
{
    int A[] = { 1, 1, 3 };
    int N = sizeof(A) / sizeof(A[0]);
  
    // Function call
    cout << maxValue(A, N);
    return 0;
}

// This code is contributed by aarohirai2616.

Java

// Java code to implement the approach

import java.io.*;
import java.util.*;

public class GFG {

    // Function to find maximum value among all distinct
    // ordered tuple
    public static long maxValue(int a[], int n)
    {
        Arrays.sort(a);
        int min = a[0];
        int max = a[n - 1];
        int secmax = a[n - 2];
        long ans = (long)(a[n - 1] - a[0]) * a[n - 2];
        return ans;
    }

    // Driver code
    public static void main(String[] args)
    {
        int A[] = { 1, 1, 3 };
        int N = A.length;
        // Function call
        System.out.println(maxValue(A, N));
    }
}

Python3

# Python code to implement the approach

# Function to find maximum value among all distinct ordered tuple
def maxValue(a, n):
    a.sort()
    min = a[0]
    max = a[n - 1]
    secmax = a[n - 2]
    ans = (a[n - 1] - a[0]) * a[n - 2]
    return ans

# Driver Code
if __name__ == '__main__':
    A = [1, 1, 3]
    N = len(A)

    # Function call
    print(maxValue(A, N))

    # This code is contributed by aarohirai2616.

C#

using System;

public class GFG 
{

  // Function to find maximum value among all distinct
  // ordered tuple
  public static long maxValue(int[] a, int n)
  {
    Array.Sort(a);
    long ans = (long)(a[n - 1] - a[0]) * a[n - 2];
    return ans;
  }

  // Driver code
  static public void Main()
  {
    int[] A = { 1, 1, 3 };
    int N = A.Length;
    
    // Function call
    Console.WriteLine(maxValue(A, N));
  }
}

// This code is contributed by Rohit Pradhan

Javascript

<script>

// JavaScript code to implement the approach

    // Function to find maximum value among all distinct
    // ordered tuple
    function maxValue(a, n)
    {
        a.sort();
        let min = a[0];
        let max = a[n - 1];
        let secmax = a[n - 2];
        let ans = (a[n - 1] - a[0]) * a[n - 2];
        return ans;
    }


// Driver Code
        let A = [ 1, 1, 3 ];
        let N = A.length;
        
        // Function call
        document.write(maxValue(A, N));

// This code is contributed by sanjoy_62.
</script>

Output

2

Time Complexity: O(N * log(N)) 
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up

Save