# Minimize maximum array element by splitting array elements into powers of two at most K times

• Last Updated : 14 Jun, 2022

Given an array arr[] consisting of N positive integers and an integer K, the task is to minimize the maximum value of the array by splitting the array element into powers of 2 at most K times.

Examples:

Input: arr[] = {2, 4, 11, 2}, K = 2
Output: 2
Explanation:
Below are the operations performed on array elements at most K(= 2) times:
Operation 1: Remove the element at index 2, i.e., arr = 11 and replace it with 11 numbers of 1s in it. Now the array arr[] modifies to {2, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2}.
Operation 2: Remove the element at index 1, i.e., arr = 4 and replace it with 4 numbers of 1s in it. Now the array arr[] modifies to {2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2}.

After performing the above operations, the maximum value of the array is 2, which is minimum possible value.

Input: arr[]= {9}, K = 2
Output: 1

Approach: The given problem can be solved by using the fact that every number can be expressed the sum of 1 which is a power of 2. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the minimum value``// of the maximum element of the array``// by splitting at most K array element``// into perfect powers of 2``void` `minimumSize(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// Sort the array element in``    ``// the ascending order``    ``sort(arr, arr + N);` `    ``// Reverse the array``    ``reverse(arr, arr + N);` `    ``// If count of 0 is equal to N``    ``if` `(count(arr, arr + N, 0) == N)``        ``cout << 0;` `    ``// Otherwise, if K is greater``    ``// than or equal to N``    ``else` `if` `(K >= N)``        ``cout << 1 << endl;` `    ``// Otherwise``    ``else``        ``cout << arr[K] << endl;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 2, 4, 8, 2 };``    ``int` `K = 2;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``minimumSize(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{` `// Function to find the minimum value``// of the maximum element of the array``// by splitting at most K array element``// into perfect powers of 2``static` `void` `minimumSize(``int` `arr[], ``int` `N, ``int` `K)``{``    ` `    ``// Sort the array element in``    ``// the ascending order``    ``Arrays.sort(arr);` `    ``// Reverse the array``    ``reverse(arr);` `    ``// If count of 0 is equal to N``    ``if` `(count(arr, ``0``) == N)``        ``System.out.println(``0``);` `    ``// Otherwise, if K is greater``    ``// than or equal to N``    ``else` `if` `(K >= N)``        ``System.out.println(``1``);` `    ``// Otherwise``    ``else``        ``System.out.println(arr[K]);``}` `static` `void` `reverse(``int``[] a)``{``    ``int` `i, k, t;``    ``int` `n = a.length;``    ` `    ``for``(i = ``0``; i < n / ``2``; i++)``    ``{``        ``t = a[i];``        ``a[i] = a[n - i - ``1``];``        ``a[n - i - ``1``] = t;``    ``}``}` `static` `int` `count(``int``[] a, ``int` `n)``{``    ``int` `freq = ``0``;``    ` `    ``for``(``int` `i = ``0``; i < a.length; i++)``    ``{``        ``if` `(a[i] == n)``            ``freq++;``    ``}``    ``return` `freq;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``2``, ``4``, ``8``, ``2` `};``    ``int` `K = ``2``;``    ``int` `N = arr.length;``    ` `    ``minimumSize(arr, N, K);``}``}` `// This code is contributed by offbeat`

## Python

 `# Python program for the above approach` `# Function to find the minimum value``# of the maximum element of the array``# by splitting at most K array element``# into perfect powers of 2``def` `minimumSize(arr, N, K):``  ` `    ``# Sort the array element in``    ``# the ascending order``    ``arr.sort()``    ` `    ``# Reverse the array``    ``arr.reverse()``    ` `    ``# If count of 0 is equal to N``    ``zero ``=` `arr.count(``0``)``    ``if` `zero ``=``=` `N:``        ``print``(``0``)``        ` `    ``# Otherwise, if K is greater``    ``# than or equal to N``    ``elif` `K >``=` `N:``        ``print``(``1``)``        ` `    ``# Otherwise``    ``else``:``        ``print``(arr[K])` `# Driver Code``arr ``=` `[``2``, ``4``, ``8``, ``2``]``K ``=` `2``N ``=` `len``(arr)``minimumSize(arr, N, K)` `# This code is contributed by sudhanshugupta2019a.`

## C#

 `// C#program for the above approach``using` `System;``class` `GFG``{` `    ``// Function to find the minimum value``    ``// of the maximum element of the array``    ``// by splitting at most K array element``    ``// into perfect powers of 2``    ``static` `void` `minimumSize(``int``[] arr, ``int` `N, ``int` `K)``    ``{` `        ``// Sort the array element in``        ``// the ascending order``        ``Array.Sort(arr);` `        ``// Reverse the array``        ``Array.Reverse(arr);` `        ``// If count of 0 is equal to N``        ``if` `(count(arr, 0) == N)``            ``Console.WriteLine(0);` `        ``// Otherwise, if K is greater``        ``// than or equal to N``        ``else` `if` `(K >= N)``            ``Console.WriteLine(1);` `        ``// Otherwise``        ``else``            ``Console.WriteLine(arr[K]);``    ``}` `    ``static` `void` `reverse(``int``[] a)``    ``{``        ``int` `i, t;``        ``int` `n = a.Length;` `        ``for` `(i = 0; i < n / 2; i++) {``            ``t = a[i];``            ``a[i] = a[n - i - 1];``            ``a[n - i - 1] = t;``        ``}``    ``}` `    ``static` `int` `count(``int``[] a, ``int` `n)``    ``{``        ``int` `freq = 0;` `        ``for` `(``int` `i = 0; i < a.Length; i++) {``            ``if` `(a[i] == n)``                ``freq++;``        ``}``        ``return` `freq;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = { 2, 4, 8, 2 };``        ``int` `K = 2;``        ``int` `N = arr.Length;` `        ``minimumSize(arr, N, K);``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``

Output:

`2`

Time Complexity: O(N * log N)
Auxiliary Space: O(1)

Another efficient approach: In the previous approach, we are sorting the array and found the (K+1)th maximum element for the K<N. Instead of sorting the array, we can use a priority queue to find the (K+1)th maximum element.

The time complexity for this approach in the worst case is O(N*log(K)) for k<N otherwise, the time complexity is O(1). Hence the given approach is much better than the previous approach for a smaller value of k.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the minimum value``// of the maximum element of the array``// by splitting at most K array element``// into perfect powers of 2``void` `minimumSize(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// If count of 0 is equal to N``    ``if` `(count(arr, arr + N, 0) == N)``        ``cout << 0;` `    ``// Otherwise, if K is greater``    ``// than or equal to N``    ``else` `if` `(K >= N)``        ``cout << 1 << endl;` `    ``// Otherwise``    ``else``    ``{``    ``// Finding (K+1)th maximum element``    ``// using a priority_queue``    ``priority_queue<``int``, vector<``int``>, greater<``int``> >pq;`` ` `    ``for` `(``int` `i = 0; i < N; ++i) {`` ` `        ``// Insert elements into``        ``// the priority queue``        ``pq.push(arr[i]);`` ` `        ``// If size of the priority``        ``// queue exceeds k+1``        ``if` `(pq.size() > (K+1)) {``            ``pq.pop();``        ``}``    ``}``    ``// Print the (K+1)th maximum element``    ``cout<

Output

`2`

Time Complexity: O(N*log(K))
Auxiliary Space: O(K)

My Personal Notes arrow_drop_up