Find Maximum value of abs(i – j) * min(arr[i], arr[j]) in an array arr[]
Last Updated :
21 Mar, 2023
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
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++
#include<bits/stdc++.h>
using namespace std;
int Maximum_Product( int arr[], int n)
{
int maxProduct = INT_MIN;
int currProduct;
int Left = 0, right = n-1;
while (Left < right)
{
if (arr[Left] < arr[right])
{
currProduct = arr[Left]*(right-Left);
Left++;
}
else
{
currProduct = arr[right]*(right-Left);
right--;
}
maxProduct = max(maxProduct, currProduct);
}
return maxProduct;
}
int main()
{
int arr[] = {8, 1, 9, 4};
int n = sizeof (arr)/ sizeof (arr[0]);
cout << Maximum_Product(arr,n);
return 0;
}
|
Java
import java.util.*;
class GFG {
static int Maximum_Product( int arr[], int n) {
int maxProduct = Integer.MIN_VALUE;
int currProduct;
int Left = 0 , right = n - 1 ;
while (Left < right) {
if (arr[Left] < arr[right]) {
currProduct = arr[Left] * (right - Left);
Left++;
}
else
{
currProduct = arr[right] * (right - Left);
right--;
}
maxProduct = Math.max(maxProduct, currProduct);
}
return maxProduct;
}
public static void main(String[] args)
{
int arr[] = { 8 , 1 , 9 , 4 };
int n = arr.length;
System.out.print(Maximum_Product(arr, n));
}
}
|
Python3
def Maximum_Product(arr,n):
maxProduct = - 2147483648
currProduct = 0
Left = 0
right = n - 1
while (Left < right):
if (arr[Left] < arr[right]):
currProduct = arr[Left] * (right - Left)
Left + = 1
else :
currProduct = arr[right] * (right - Left)
right - = 1
maxProduct = max (maxProduct, currProduct)
return maxProduct
arr = [ 8 , 1 , 9 , 4 ]
n = len (arr)
print (Maximum_Product(arr,n))
|
C#
using System;
class GFG {
static int Maximum_Product( int []arr,
int n)
{
int maxProduct = int .MinValue;
int currProduct;
int Left = 0, right = n - 1;
while (Left < right) {
if (arr[Left] < arr[right])
{
currProduct = arr[Left] *
(right - Left);
Left++;
}
else
{
currProduct = arr[right] *
(right - Left);
right--;
}
maxProduct = Math.Max(maxProduct,
currProduct);
}
return maxProduct;
}
public static void Main()
{
int []arr = {8, 1, 9, 4};
int n = arr.Length;
Console.Write(Maximum_Product(arr, n));
}
}
|
PHP
<?php
function Maximum_Product( $arr , $n )
{
$INT_MIN = 0;
$maxProduct = $INT_MIN ;
$currProduct ;
$Left = 0; $right = $n - 1;
while ( $Left < $right )
{
if ( $arr [ $Left ] < $arr [ $right ])
{
$currProduct = $arr [ $Left ] *
( $right - $Left );
$Left ++;
}
else
{
$currProduct = $arr [ $right ] *
( $right - $Left );
$right --;
}
$maxProduct = max( $maxProduct ,
$currProduct );
}
return $maxProduct ;
}
$arr = array (8, 1, 9, 4);
$n = sizeof( $arr ) / sizeof( $arr [0]);
echo Maximum_Product( $arr , $n );
?>
|
Javascript
<script>
function Maximum_Product(arr, n)
{
let INT_MIN = 0;
let maxProduct = INT_MIN;
let currProduct;
let Left = 0, right = n - 1;
while (Left < right)
{
if (arr[Left] < arr[right])
{
currProduct = arr[Left] *
(right - Left);
Left++;
}
else
{
currProduct = arr[right] *
(right - Left);
right--;
}
maxProduct = Math.max(maxProduct,
currProduct);
}
return maxProduct;
}
let arr = new Array(8, 1, 9, 4);
let n = arr.length;
document.write(Maximum_Product(arr, n));
</script>
|
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).
- 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.
- Similar arguments are applicable when arr[right] < arr[left].
Share your thoughts in the comments
Please Login to comment...