Open In App

Find Maximum value of abs(i – j) * min(arr[i], arr[j]) in an array arr[]

Improve
Improve
Like Article
Like
Save
Share
Report

Given an array of n distinct elements. Find the maximum of product of Minimum of two numbers in the array and absolute difference of their positions, i.e., find maximum value of abs(i – j) * min(arr[i], arr[j]) where i and j vary from 0 to n-1. 

Examples : 

Input : arr[] = {3, 2, 1, 4}
Output: 9
// arr[0] = 3 and arr[3] = 4 minimum of them is 3 and 
// absolute difference between their position is 
// abs(0-3) = 3. So product is 3*3 = 9

Input : arr[] = {8, 1, 9, 4}
Output: 16
// arr[0] = 8 and arr[2] = 9 minimum of them is 8 and 
// absolute difference between their position is 
// abs(0-2) = 2. So product is 8*2 = 16 
Recommended Practice

A simple solution for this problem is to take each element one by one and compare this element with the elements on right of it. Then calculate product of minimum of them and absolute difference between their indexes and maximize the result. Time complexity for this approach is O(n^2).

An efficient solution to solves the problem in linear time complexity. We take two iterators Left=0 and Right=n-1, compare elements arr[Left] and arr[right].  

left = 0, right = n-1
maxProduct = -INF
While (left < right)
    If arr[Left] < arr[right] 
        currProduct = arr[Left]*(right-Left) 
        Left++ . 
    If arr[right] < arr[Left] 
        currProduct = arr[Right]*(Right-Left) 
        Right-- . 
  
    maxProduct = max(maxProduct, currProduct)

Below is the implementation of above idea. 

C++




// C++ implementation of code
#include<bits/stdc++.h>
using namespace std;
 
// Function to calculate maximum value of
// abs(i - j) * min(arr[i], arr[j]) in arr[]
int Maximum_Product(int arr[], int n)
{
    int maxProduct = INT_MIN; // Initialize result
    int currProduct; // product of current pair
 
    // loop  until they meet with each other
    int Left = 0, right = n-1;
    while (Left < right)
    {
        if (arr[Left] < arr[right])
        {
            currProduct = arr[Left]*(right-Left);
            Left++;
        }
        else // arr[right] is smaller
        {
            currProduct = arr[right]*(right-Left);
            right--;
        }
 
        // maximizing the product
        maxProduct = max(maxProduct, currProduct);
    }
 
    return maxProduct;
}
 
// Driver program to test the case
int main()
{
    int arr[] = {8, 1, 9, 4};
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << Maximum_Product(arr,n);
    return 0;
}


Java




// Java implementation of code
import java.util.*;
 
class GFG {
     
    // Function to calculate maximum value of
    // abs(i - j) * min(arr[i], arr[j]) in arr[]
    static int Maximum_Product(int arr[], int n) {
         
    // Initialize result
    int maxProduct = Integer.MIN_VALUE;
     
    // product of current pair
    int currProduct;           
 
    // loop until they meet with each other
    int Left = 0, right = n - 1;
    while (Left < right) {
    if (arr[Left] < arr[right]) {
        currProduct = arr[Left] * (right - Left);
        Left++;
    }
     
    // arr[right] is smaller
    else
    {
        currProduct = arr[right] * (right - Left);
        right--;
    }
 
    // maximizing the product
    maxProduct = Math.max(maxProduct, currProduct);
    }
 
    return maxProduct;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = {8, 1, 9, 4};
    int n = arr.length;
    System.out.print(Maximum_Product(arr, n));
}
}
 
// This code is contributed by Anant Agarwal.


Python3




# Python implementation of code
# Function to calculate
# maximum value of
# abs(i - j) * min(arr[i],
# arr[j]) in arr[]
def Maximum_Product(arr,n):
     
    # Initialize result
    maxProduct = -2147483648
 
    # product of current pair
    currProduct=0
  
    # loop until they meet with each other
    Left = 0
    right = n-1
    while (Left < right):
     
        if (arr[Left] < arr[right]):
         
            currProduct = arr[Left]*(right-Left)
            Left+=1
         
        else:
 
            # arr[right] is smaller
            currProduct = arr[right]*(right-Left)
            right-=1
         
  
        # maximizing the product
        maxProduct = max(maxProduct, currProduct)
     
  
    return maxProduct
 
# Driver code
 
arr = [8, 1, 9, 4]
n = len(arr)
 
print(Maximum_Product(arr,n))
 
# This code is contributed
# by Anant Agarwal.


C#




// C# implementation of code
using System;
 
class GFG {
     
// Function to calculate maximum
// value of abs(i - j) * min(arr[i],
// arr[j]) in arr[]
static int Maximum_Product(int []arr,
                           int n)
{
         
    // Initialize result
    int maxProduct = int.MinValue;
     
    // product of current pair
    int currProduct;        
 
    // loop until they meet
    // with each other
    int Left = 0, right = n - 1;
    while (Left < right) {
    if (arr[Left] < arr[right])
    {
        currProduct = arr[Left] *
                      (right - Left);
        Left++;
    }
     
    // arr[right] is smaller
    else
    {
        currProduct = arr[right] *
                      (right - Left);
        right--;
    }
 
    // maximizing the product
    maxProduct = Math.Max(maxProduct,
                          currProduct);
    }
 
    return maxProduct;
}
 
// Driver code
public static void Main()
{
    int []arr = {8, 1, 9, 4};
    int n = arr.Length;
    Console.Write(Maximum_Product(arr, n));
}
}
 
// This code is contributed by nitin mittal.


PHP




<?php
// PHP implementation of code
 
// Function to calculate
// maximum value of
// abs(i - j) * min(arr[i],
// arr[j]) in arr[]
function Maximum_Product($arr, $n)
{
    $INT_MIN = 0;
     
    // Initialize result
    $maxProduct = $INT_MIN;
     
    // product of current pair
    $currProduct;
 
    // loop until they meet
    // with each other
    $Left = 0; $right = $n - 1;
    while ($Left < $right)
    {
        if ($arr[$Left] < $arr[$right])
        {
            $currProduct = $arr[$Left] *
                          ($right - $Left);
            $Left++;
        }
         
        // arr[right] is smaller
        else
        {
            $currProduct = $arr[$right] *
                          ($right - $Left);
            $right--;
        }
 
        // maximizing the product
        $maxProduct = max($maxProduct,
                          $currProduct);
    }
 
    return $maxProduct;
}
 
// Driver Code
$arr = array(8, 1, 9, 4);
$n = sizeof($arr) / sizeof($arr[0]);
echo Maximum_Product($arr, $n);
 
// This code is contributed
// by nitin mittal.
?>


Javascript




<script>
 
// Javascript implementation of code
 
// Function to calculate
// maximum value of
// abs(i - j) * min(arr[i],
// arr[j]) in arr[]
function Maximum_Product(arr, n)
{
    let INT_MIN = 0;
 
    // Initialize result
    let maxProduct = INT_MIN;
 
    // Product of current pair
    let currProduct;
 
    // Loop until they meet
    // with each other
    let Left = 0, right = n - 1;
    while (Left < right)
    {
        if (arr[Left] < arr[right])
        {
            currProduct = arr[Left] *
                 (right - Left);
            Left++;
        }
 
        // arr[right] is smaller
        else
        {
            currProduct = arr[right] *
                 (right - Left);
            right--;
        }
 
        // Maximizing the product
        maxProduct = Math.max(maxProduct,
                              currProduct);
    }
    return maxProduct;
}
 
// Driver Code
let arr = new Array(8, 1, 9, 4);
let n = arr.length;
document.write(Maximum_Product(arr, n));
 
// This code is contributed by Saurabh Jaiswal
 
</script>


Output

16

Time Complexity : O(N log N), here N is length of Array.

Space Complexity : O(1), since no extra space used.

How does this work? 
The important thing to show that we don’t miss any potential pair in above linear algorithm, i.e., we need to show that doing left++ or right– doesn’t lead to a case where we would have got higher value of maxProduct.

Please note that we always multiply with (right – left). 

  1. If arr[left] < arr[right], then smaller values of right for current left are useless as they can not produce higher value of maxProduct (because we multiply with arr[left] with (right – left)). What if arr[left] was greater than any of the elements on its left side. In that case, a better pair for that element must have been found with current right. Therefore we can safely increase left without missing any better pair with current left.
  2. Similar arguments are applicable when arr[right] < arr[left].


Last Updated : 21 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads