Skip to content
Related Articles

Related Articles

Minimise the maximum element of N subarrays of size K
  • Last Updated : 15 Sep, 2020
GeeksforGeeks - Summer Carnival Banner

Given an array arr[] and two integers N and K, the task is to choose non-overlapping N subarrays of size K such that the maximum element of all subarrays is minimum.
Note: If it is not possible to choose N such subarrays then return -1. 
Examples: 

Input: arr[] = {1, 10, 3, 10, 2}, N = 3, K = 1 
Output:
Explanation: 
The three non-overlapping subarrays are – 
Subarrays => {{1}, {2}, {3}} 
Maximum of these subarrays are => 3 
Input: arr[] = {7, 7, 7, 7, 12, 7, 7}, N = 2, K = 3 
Output: 12 
Explanation: 
The two non-overlapping subarrays are – 
Subarrays => {{7, 7, 7}, {7, 12, 7}} 
Maximum element of these subarrays are => 12 

Approach: The idea is to use a binary search. Below is the illustration of the binary search:

  • Search space: As we have to find the maximum element from the N subarrays which is one of the elements from the array. Therefore, the search space will be the minimum element to the maximum element of the array.
  • Function for binary search: The function for binary search is to find the count of K sized array possible in the with all the elements less than the given number which will be the middle of the search space.
  • Left Search Space: The condition when the count of K sized subarrays possible is greater than or equal to N, Then the answer possible can lie in the left search space.
  • Right Search Space: The condition when the count of K sized subarrays possible is less than N, Then the answer possible scan lies in the right search space.

Below is the implementation of the above approach:

C++




// C++ implementation to choose
// N subarrays of size K such that
// the maximum element of
// subarrays is minimum
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to choose
// N subarrays of size K such that
// the maximum element of
// subarrays is minimum
int minDays(vector<int>& arr,
                int n, int k)
{
    int l = arr.size(),
left = 1, right = 1e9;
 
    // Condition to check if it
    // is not possible to choose k
    // sized N subarrays
    if (n * k > l)
        return -1;
 
    // Using binary search
    while (left < right) {
 
        // calculating mid
        int mid = (left + right) / 2,
                 cnt = 0, product = 0;
                  
        // Loop to find the count of the
        // K sized subarrays possible with
        // elements less than  mid
        for (int j = 0; j < l; ++j) {
            if (arr[j] > mid) {
                cnt = 0;
            }
            else if (++cnt >= k) {
                product++;
                cnt = 0;
            }
        }
     
        // Condition to check if the
        // answer is in right subarray
        if (product < n) {
            left = mid + 1;
        }
        else {
            right = mid;
        }
    }
    return left;
}
 
// Driver Code
int main()
{
    vector<int> arr{ 1, 10, 3, 10, 2 };
    int n = 3, k = 1;
     
    // Function Call
    cout << minDays(arr, n, k) << endl;
    return 0;
}

Java




// Java implementation to choose
// N subarrays of size K such that
// the maximum element of
// subarrays is minimum
class GFG{
 
// Function to choose
// N subarrays of size K such that
// the maximum element of
// subarrays is minimum
static int minDays(int []arr,
                   int n, int k)
{
    int l = arr.length,
        left = 1, right = (int) 1e9;
 
    // Condition to check if it
    // is not possible to choose k
    // sized N subarrays
    if (n * k > l)
        return -1;
 
    // Using binary search
    while (left < right)
    {
 
        // calculating mid
        int mid = (left + right) / 2,
                   cnt = 0, product = 0;
                 
        // Loop to find the count of the
        // K sized subarrays possible with
        // elements less than mid
        for (int j = 0; j < l; ++j)
        {
            if (arr[j] > mid)
            {
                cnt = 0;
            }
            else if (++cnt >= k)
            {
                product++;
                cnt = 0;
            }
        }
     
        // Condition to check if the
        // answer is in right subarray
        if (product < n)
        {
            left = mid + 1;
        }
        else
        {
            right = mid;
        }
    }
    return left;
}
 
// Driver Code
public static void main(String[] args)
{
    int []arr = {1, 10, 3, 10, 2};
    int n = 3, k = 1;
     
    // Function Call
    System.out.print(minDays(arr, n, k) + "\n");
}
}
 
// This code is contributed by Amit Katiyar

Python3




# Python3 implementation to choose
# N subarrays of size K such that
# the maximum element of
# subarrays is minimum
  
# Function to choose
# N subarrays of size K such that
# the maximum element of
# subarrays is minimum
def minDays(arr, n, k):
 
    l = len(arr)
    left = 1
    right = 1e9
  
    # Condition to check if it
    # is not possible to choose k
    # sized N subarrays
    if (n * k > l):
        return -1
  
    # Using binary search
    while (left < right):
  
        # calculating mid
        mid = (left + right) // 2
        cnt = 0
        product = 0
                   
        # Loop to find the count of the
        # K sized subarrays possible with
        # elements less than  mid
        for j in range (l):
            if (arr[j] > mid):
                cnt = 0
            else:
                cnt += 1
                if (cnt >= k):
                    product += 1
                    cnt = 0
      
        # Condition to check if the
        # answer is in right subarray
        if (product < n):
            left = mid + 1
        else:
            right = mid
      
    return left
  
# Driver Code
if __name__ == "__main__":
    arr = [1, 10, 3, 10, 2]
    n = 3
    k = 1
      
    # Function Call
    print (int(minDays(arr, n, k)))
     
# This code is contributed by Chitranayal

C#




// C# implementation to choose N 
// subarrays of size K such that
// the maximum element of
// subarrays is minimum
using System;
class GFG{
 
// Function to choose N subarrays 
// of size K such that the maximum
// element of subarrays is minimum
static int minDays(int []arr,
                   int n, int k)
{
    int l = arr.Length;
    int left = 1, right = (int)1e9;
 
    // Condition to check if it
    // is not possible to choose k
    // sized N subarrays
    if (n * k > l)
        return -1;
 
    // Using binary search
    while (left < right)
    {
 
        // Calculating mid
        int mid = (left + right) / 2,
                   cnt = 0, product = 0;
                 
        // Loop to find the count of the
        // K sized subarrays possible with
        // elements less than mid
        for(int j = 0; j < l; ++j)
        {
           if (arr[j] > mid)
           {
               cnt = 0;
           }
           else if (++cnt >= k)
           {
               product++;
               cnt = 0;
           }
        }
     
        // Condition to check if the
        // answer is in right subarray
        if (product < n)
        {
            left = mid + 1;
        }
        else
        {
            right = mid;
        }
    }
    return left;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 1, 10, 3, 10, 2 };
    int n = 3, k = 1;
     
    // Function Call
    Console.Write(minDays(arr, n, k) + "\n");
}
}
 
// This code is contributed by Amit Katiyar
Output: 
3

 

Time Complexity: O(N*logN)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :