Maximize sum of product and difference between any pair of array elements possible

Given an array arr[] of size N, the task is to find the maximum value of arr[i] ∗ arr[j] + arr[i] − arr[j] for any pair (arr[i], arr[j]) from the given array, where i != j and 0 < i, j < N – 1.

Examples:

Input: arr[] = {1, 2, 3, 4, 5}
Output: 21
Explanation:
Among all the pairs of the array, the maximum value is obtained for the pair (arr[4], arr[3]), which is equal to
=> arr[4] * arr[3] + arr[4] – arr[3] = 5 * 4 + 5 – 4 = 20 + 1 = 21. 

Input: {-4, -5, 0, 1, 3}
Output: 21
Explanation:
Among all the pairs of the array, the maximum value is obtained for the pair (arr[0], arr[1]), which is equal to
=> arr[0] * arr[1] + arr[0] – arr[1] = (-4) * (-5) + (-4) – (-5) = 20 + 1 = 21. 

Naive Approach: The simplest approach to solve the problem is to traverse the array and generate all possible pairs (arr[i], arr[j]) (i != j) from the array and evaluate the expression for all the pairs. Finally, print the maximum of all the pairs.
Time Complexity: O(N²)
Auxiliary Space: O(1)

Efficient Approach: The optimal idea is based on the observation that the value of the expression can be maximum for the following 2 cases:

• If the pair includes the largest and the second-largest array elements.
• If the pair includes one smallest and the second smallest array elements are selected. This may arise when the smallest and the second smallest elements are both negative and their product will result in a positive number.

Follow the steps below to solve the problem:

• Sort the array arr[] in ascending order.
• Evaluate the expression for the pair arr[N – 1] and arr[N – 2] and store it in a variable, say max1.
• Similarly, evaluate the expression for the pair arr[1] and arr[0] and store it in a variable, say max2.
• Store the maximum of max1 and max2 in a variable, say ans.
• Print the value of ans as the result.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to evaluate given expression
int compute(int a, int b)
{
    // Store the result
    int ans = a * b + a - b;
    return ans;
}

// Function to find the maximum value of
// the given expression possible for any
// unique pair from the given array
void findMaxValue(int arr[], int N)
{
    // Sort the array in ascending order
    sort(arr, arr + N);

    // Evaluate the expression for
    // the two largest elements
    int maxm = compute(arr[N - 1], arr[N - 2]);

    // Evaluate the expression for
    // the two smallest elements
    maxm = max(maxm, compute(arr[1], arr[0]));

    // Print the maximum
    cout << maxm;
}

// Driver Code
int main()
{
    // Given array
    int arr[] = { -4, -5, 0, 1, 3 };

    // Store the size of the array
    int N = sizeof(arr) / sizeof(arr[0]);

    findMaxValue(arr, N);

    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG
{

  // Function to evaluate given expression
  static int compute(int a, int b)
  {
    // Store the result
    int ans = a * b + a - b;
    return ans;
  }

  // Function to find the maximum value of
  // the given expression possible for any
  // unique pair from the given array
  static void findMaxValue(int arr[], int N)
  {
    // Sort the array in ascending order
    Arrays.sort(arr);

    // Evaluate the expression for
    // the two largest elements
    int maxm = compute(arr[N - 1], arr[N - 2]);

    // Evaluate the expression for
    // the two smallest elements
    maxm = Math.max(maxm, compute(arr[1], arr[0]));

    // Print the maximum
    System.out.print(maxm);
  }


  // Driver Code
  public static void main(String[] args)
  {
    // Given array
    int arr[] = { -4, -5, 0, 1, 3 };

    // Store the size of the array
    int N = arr.length;

    findMaxValue(arr, N);
  }
}

// This code is contributed by saanjoy_62

Python3

# Python Program for the above approach
# Function to evaluate given expression
def compute(a, b):

    # Store the result
    res = (a * b) + (a - b)
    return res

# Function to find the maximum value of
# the given expression possible for any
# unique pair from the given array
def findMaxValue(arr, N):

    # Sort the list in ascending order
    arr.sort()

    # Evaluate the expression for
    # the two largest elements
    maxm = compute(arr[N - 1], arr[N - 2])

    # Evaluate the expression for
    # the two smallest elements
    maxm = max(maxm, compute(arr[1], arr[0]));
    print(maxm)

# Driver code
# given list
arr = [-4, -5, 0, 1, 3]

# store the size of the list
N = len(arr)
findMaxValue(arr, N)

# This code is contributed by santhoshcharan.

C#

// C# program for above approach
using System;
public class GFG
{

  // Function to evaluate given expression
  static int compute(int a, int b)
  {
    // Store the result
    int ans = a * b + a - b;
    return ans;
  }

  // Function to find the maximum value of
  // the given expression possible for any
  // unique pair from the given array
  static void findMaxValue(int[] arr, int N)
  {
    // Sort the array in ascending order
    Array.Sort(arr);

    // Evaluate the expression for
    // the two largest elements
    int maxm = compute(arr[N - 1], arr[N - 2]);

    // Evaluate the expression for
    // the two smallest elements
    maxm = Math.Max(maxm, compute(arr[1], arr[0]));

    // Print the maximum
    Console.WriteLine(maxm);
  }

// Driver code
public static void Main(String[] args)
{

    // Given array
    int[] arr = { -4, -5, 0, 1, 3 };

    // Store the size of the array
    int N = arr.Length;

    findMaxValue(arr, N);
}
}

// This code is contributed by susmitakundugoaldanga.

Javascript

<script>
// Javascript implementation of the above approach

// Function to evaluate given expression
function compute(a, b)
{
    // Store the result
    var ans = a * b + a - b;
    return ans;
}

// Function to find the maximum value of
// the given expression possible for any
// unique pair from the given array
function findMaxValue(arr, N)
{
    // Sort the array in ascending order
    arr.sort(function(a,b){return a - b});

    // Evaluate the expression for
    // the two largest elements
    var maxm = compute(arr[N - 1], arr[N - 2]);

    // Evaluate the expression for
    // the two smallest elements
    maxm = Math.max(maxm, compute(arr[1], arr[0]));

    // Print the maximum
    document.write(maxm);
}


// Driver Code
var arr = [-4, -5, 0, 1, 3];
var N = arr.length;
findMaxValue(arr, N);

// This code is contributed by Shubhamsingh10
</script>

Output

21

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