Maximize the maximum among minimum of K consecutive sub-arrays
Given an integer K and an array arr[], the task is to split the array arr[] into K consecutive subarrays to find the maximum possible value of the maximum among the minimum value of K consecutive sub-arrays.
Examples:
Input: arr[] = {1, 2, 3, 4, 5}, K = 2
Output: 5
Split the array as [1, 2, 3, 4] and [5]. The minimum of the 2 consecutive sub-arrays is 1 and 5.
Maximum(1, 5) = 5. This splitting ensures maximum possible value.
Input: arr[] = {-4, -5, -3, -2, -1}, K = 1
Output: -5
Only one sub-array is possible. Hence, min(-4, -5, -3, -2, -1) = -5
Approach: The solution can be split into 3 possible cases:
- When K = 1: In this case, the answer is always equal to the minimum of the array, since the array is split into only one sub-array i.e the array itself.
- When K ? 3: In this case, the answer is always equal to the maximum of the array. When the array has to be split into 3 or more segments, then always keep one segment containing only a single element from the array i.e. the maximum element.
- When K = 2: This is the trickiest case. There will only be a prefix and a suffix as there can be only two sub-arrays. Maintain an array of prefix minimums and suffix minimums. Then for every element arr[i], update ans = max(ans, max(prefix min value at i, suffix minimum value at i + 1)).
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maximizeMinimumOfKSubarrays( const int * arr, int n, int k)
{
int m = INT_MAX;
int M = INT_MIN;
for ( int i = 0; i < n; i++) {
m = min(m, arr[i]);
M = max(M, arr[i]);
}
if (k == 1) {
return m;
}
else if (k >= 3) {
return M;
}
else {
int L[n], R[n];
L[0] = arr[0];
R[n - 1] = arr[n - 1];
for ( int i = 1; i < n; i++)
L[i] = min(L[i - 1], arr[i]);
for ( int i = n - 2; i >= 0; i--)
R[i] = min(R[i + 1], arr[i]);
int maxVal = INT_MIN;
for ( int i = 0; i < n - 1; i++)
maxVal = max(maxVal, max(L[i], R[i + 1]));
return maxVal;
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 2;
cout << maximizeMinimumOfKSubarrays(arr, n, k);
return 0;
}
|
Java
class GFG {
static int maximizeMinimumOfKSubarrays( int arr[], int n, int k)
{
int m = Integer.MAX_VALUE;
int M = Integer.MIN_VALUE;
for ( int i = 0 ; i < n; i++) {
m = Math.min(m, arr[i]);
M = Math.max(M, arr[i]);
}
if (k == 1 ) {
return m;
}
else if (k >= 3 ) {
return M;
}
else {
int L[] = new int [n], R[] = new int [n];
L[ 0 ] = arr[ 0 ];
R[n - 1 ] = arr[n - 1 ];
for ( int i = 1 ; i < n; i++)
L[i] = Math.min(L[i - 1 ], arr[i]);
for ( int i = n - 2 ; i >= 0 ; i--)
R[i] = Math.min(R[i + 1 ], arr[i]);
int maxVal = Integer.MIN_VALUE;
for ( int i = 0 ; i < n - 1 ; i++)
maxVal = Math.max(maxVal, Math.max(L[i], R[i + 1 ]));
return maxVal;
}
}
public static void main(String args[])
{
int arr[] = { 1 , 2 , 3 , 4 , 5 };
int n = arr.length;
int k = 2 ;
System.out.println(maximizeMinimumOfKSubarrays(arr, n, k));
}
}
|
Python3
import sys
def maximizeMinimumOfKSubarrays(arr, n, k) :
m = sys.maxsize;
M = - (sys.maxsize - 1 );
for i in range (n) :
m = min (m, arr[i]);
M = max (M, arr[i]);
if (k = = 1 ) :
return m;
elif (k > = 3 ) :
return M;
else :
L = [ 0 ] * n;
R = [ 0 ] * n;
L[ 0 ] = arr[ 0 ];
R[n - 1 ] = arr[n - 1 ];
for i in range ( 1 , n) :
L[i] = min (L[i - 1 ], arr[i]);
for i in range (n - 2 , - 1 , - 1 ) :
R[i] = min (R[i + 1 ], arr[i]);
maxVal = - (sys.maxsize - 1 );
for i in range (n - 1 ) :
maxVal = max (maxVal, max (L[i],
R[i + 1 ]));
return maxVal;
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 ];
n = len (arr);
k = 2 ;
print (maximizeMinimumOfKSubarrays(arr, n, k));
|
C#
using System;
public class GFG {
static int maximizeMinimumOfKSubarrays( int [] arr, int n, int k)
{
int m = int .MaxValue;
int M = int .MinValue;
for ( int i = 0; i < n; i++) {
m = Math.Min(m, arr[i]);
M = Math.Max(M, arr[i]);
}
if (k == 1) {
return m;
}
else if (k >= 3) {
return M;
}
else {
int [] L = new int [n];
int [] R = new int [n];
L[0] = arr[0];
R[n - 1] = arr[n - 1];
for ( int i = 1; i < n; i++)
L[i] = Math.Min(L[i - 1], arr[i]);
for ( int i = n - 2; i >= 0; i--)
R[i] = Math.Min(R[i + 1], arr[i]);
int maxVal = int .MinValue;
for ( int i = 0; i < n - 1; i++)
maxVal = Math.Max(maxVal, Math.Max(L[i], R[i + 1]));
return maxVal;
}
}
public static void Main()
{
int [] arr = { 1, 2, 3, 4, 5 };
int n = arr.Length;
int k = 2;
Console.WriteLine(maximizeMinimumOfKSubarrays(arr, n, k));
}
}
|
PHP
<?php
function maximizeMinimumOfKSubarrays( $arr , $n , $k )
{
$m = PHP_INT_MAX;
$M = PHP_INT_MIN;
for ( $i = 0; $i < $n ; $i ++)
{
$m = min( $m , $arr [ $i ]);
$M = max( $M , $arr [ $i ]);
}
if ( $k == 1)
{
return $m ;
}
else if ( $k >= 3)
{
return $M ;
}
else
{
$L [0] = $arr [0];
$R [ $n - 1] = $arr [ $n - 1];
for ( $i = 1; $i < $n ; $i ++)
$L [ $i ] = min( $L [ $i - 1], $arr [ $i ]);
for ( $i = $n - 2; $i >= 0; $i --)
$R [ $i ] = min( $R [ $i + 1], $arr [ $i ]);
$maxVal = PHP_INT_MIN;
for ( $i = 0; $i < $n - 1; $i ++)
$maxVal = max( $maxVal ,
max( $L [ $i ], $R [ $i + 1]));
return $maxVal ;
}
}
$arr = array ( 1, 2, 3, 4, 5 );
$n = sizeof( $arr );
$k = 2;
echo maximizeMinimumOfKSubarrays( $arr , $n , $k );
?>
|
Javascript
<script>
function maximizeMinimumOfKSubarrays(arr, n, k)
{
let m = Number.MAX_VALUE;
let M = Number.MIN_VALUE;
for (let i = 0; i < n; i++) {
m = Math.min(m, arr[i]);
M = Math.max(M, arr[i]);
}
if (k == 1) {
return m;
}
else if (k >= 3) {
return M;
}
else {
let L = new Array(n);
L.fill(0);
let R = new Array(n);
R.fill(0);
L[0] = arr[0];
R[n - 1] = arr[n - 1];
for (let i = 1; i < n; i++)
L[i] = Math.min(L[i - 1], arr[i]);
for (let i = n - 2; i >= 0; i--)
R[i] = Math.min(R[i + 1], arr[i]);
let maxVal = Number.MIN_VALUE;
for (let i = 0; i < n - 1; i++)
maxVal = Math.max(maxVal, Math.max(L[i], R[i + 1]));
return maxVal;
}
}
let arr = [ 1, 2, 3, 4, 5 ];
let n = arr.length;
let k = 2;
document.write(maximizeMinimumOfKSubarrays(arr, n, k));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Last Updated :
25 Aug, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...