Related Articles
Minimise the maximum element of N subarrays of size K
• Last Updated : 15 Sep, 2020

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 ``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