# Merge first two minimum elements of the array until all the elements are greater than K

Given an array arr[] and an integer K, the task is to find the number of merge operation required such that all the elements of the array is greater than or equal to K.

Merge Process of the Element –

```New Element =
1 * (First Minimum element) +
2 * (Second Minimum element)```

Examples:

Input: arr[] = {1, 2, 3, 9, 10, 12}, K = 7
Output:
Explanation:
After the first merge operation elements 1 and 2 is removed,
and the element (1*1 + 2*2 = 5) is inserted into the array
{3, 5, 9, 10, 12}
After the second merge operation elements 3 and 5 is removed,
and the element (3*1 + 5*2 = 13) is inserted into the array
{9, 10, 12, 13}
Thus, 2 operations are required such that all elements are greater than K.

Input: arr[] = {52, 96, 13, 37}, K = 10
Output:
Explanation:
All the elements of the array are greater than K already.
Therefore, no merge operation is required.

Approach: The idea is to use Min-Heap to store the elements and then merge the two minimum elements of the array until the minimum element of the array is greater than or equal to K.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to merge the``// elements of the array until all``// the array element of the array``// greater than or equal to K` `#include ` `using` `namespace` `std;` `// Function to find the minimum ``// operation required to merge``// elements of the array``int` `minOperations(``int` `arr[], ``int` `K, ``                          ``int` `size)``{``    ``int` `least, second_least, ``       ``min_operations = 0,``       ``new_ele = 0, flag = 0;` `    ``// Heap to store the elements``    ``// of the array and to extract ``    ``// minimum elements of O(logN)``    ``priority_queue<``int``, vector<``int``>, ``                 ``greater<``int``> > heap;``                 ` `    ``// Loop to push all the elements``    ``// of the array into heap``    ``for` `(``int` `i = 0; i < size; i++) {``        ``heap.push(arr[i]);``    ``}``    ` `    ``// Loop to merge the minimum ``    ``// elements until there is only``    ``// all the elements greater than K``    ``while` `(heap.size() != 1) {``        ` `        ``// Condition to check minimum``        ``// element of the array is ``        ``// greater than the K``        ``if` `(heap.top() >= K) {``            ``flag = 1;``            ``break``;``        ``}``        ` `        ``// Merge the two minimum ``        ``// elements of the heap``        ``least = heap.top();``        ``heap.pop();``        ``second_least = heap.top();``        ``heap.pop();``        ``new_ele = (1 * least) + ``            ``(2 * second_least);``        ``min_operations++;``        ``heap.push(new_ele);``    ``}``    ``if` `(heap.top() >= K) {``        ``flag = 1;``    ``}``    ``if` `(flag == 1) {``        ``return` `min_operations;``    ``}``    ``return` `-1;``}` `// Driver Code``int` `main()``{``    ``int` `N = 6, K = 7;``    ``int` `arr[] = { 1, 2, 3, 9, 10, 12 };``    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << minOperations(arr, K, size);``    ``return` `0;``}`

## Java

 `// Java implementation to merge the``// elements of the array until all``// the array element of the array``// greater than or equal to K``import` `java.util.Collections;``import` `java.util.PriorityQueue;` `class` `GFG{` `// Function to find the minimum``// operation required to merge``// elements of the array``static` `int` `minOperations(``int` `arr[], ``int` `K, ``                         ``int` `size) ``{``    ``int` `least, second_least,``        ``min_operations = ``0``, ``        ``new_ele = ``0``, flag = ``0``;` `    ``// Heap to store the elements``    ``// of the array and to extract``    ``// minimum elements of O(logN)``    ``PriorityQueue heap = ``new` `PriorityQueue<>();``    ` `    ``// priority_queue,``    ``// greater > heap;` `    ``// Loop to push all the elements``    ``// of the array into heap``    ``for``(``int` `i = ``0``; i < size; i++) ``    ``{``        ``heap.add(arr[i]);``    ``}` `    ``// Loop to merge the minimum``    ``// elements until there is only``    ``// all the elements greater than K``    ``while` `(heap.size() != ``1``) ``    ``{``        ` `        ``// Condition to check minimum``        ``// element of the array is``        ``// greater than the K``        ``if` `(heap.peek() >= K) ``        ``{``            ``flag = ``1``;``            ``break``;``        ``}` `        ``// Merge the two minimum``        ``// elements of the heap``        ``least = heap.poll();``        ``second_least = heap.poll();``        ``new_ele = (``1` `* least) + ``                  ``(``2` `* second_least);``        ``min_operations++;``        ``heap.add(new_ele);``    ``}``    ``if` `(heap.peek() >= K)``    ``{``        ``flag = ``1``;``    ``}``    ``if` `(flag == ``1``) ``    ``{``        ``return` `min_operations;``    ``}``    ``return` `-``1``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``6``, K = ``7``;``    ``int` `arr[] = { ``1``, ``2``, ``3``, ``9``, ``10``, ``12` `};``    ``int` `size = arr.length;``    ` `    ``System.out.println(minOperations(arr, K, size));``}``}` `// This code is contributed by sanjeev2552`

## Python3

 `# Python3 implementation to merge the``# elements of the array until all``# the array element of the array``# greater than or equal to K``# importing heapq module as hq` `import` `heapq as hq` `# Function to find the minimum``# operation required to merge``# elements of the array`  `def` `minOperations(arr, K, size):` `    ``least, second_least ``=` `0``, ``0``    ``min_operations ``=` `0``    ``new_ele, flag ``=` `0``, ``0``    ``# Heap to store the elements``    ``# of the array and to extract``    ``# minimum elements of O(logN)``    ``hq.heapify(arr)``    ``# Loop to merge the minimum``    ``# elements until there is only``    ``# all the elements greater than K``    ``while` `len``(arr) > ``0``:``        ``# Condition to check minimum``        ``# element of the array is``        ``# greater than the K``        ``if` `arr[``0``] >``=` `K:``            ``flag ``=` `1``            ``break``        ``# Merge the two minimum``        ``# elements of the heap``        ``least ``=` `arr[``0``]``        ``arr[``0``] ``=` `arr[``-``1``]``        ``# reducing the size of the heap``        ``#it is O(1) time operation..``        ``arr.pop()``        ``# maintaining the min heap property``        ``#O(log n) time needed for heapifying``        ``hq.heapify(arr)``        ``# extracting the second_least element``        ``# from the heap``        ``second_least ``=` `arr[``0``]``        ``arr[``0``] ``=` `arr[``-``1``]``        ``arr.pop()``        ``# creating the new_ele``        ``new_ele ``=` `least``+``2``*``second_least``        ``# increasing the min_operations``        ``min_operations ``+``=` `1``        ``# inserting new_ele back to heap``        ``arr.append(new_ele)``        ``# now again maintaining the min heap property again``        ``# using the heapify function``        ``hq.heapify(arr)``    ``if` `arr[``0``] >``=` `K:``        ``flag ``=` `1``    ``if` `flag ``=``=` `1``:``        ``return` `min_operations``    ``return` `-``1`  `# Driver code``K ``=` `7``arr ``=` `[``1``, ``2``, ``3``, ``9``, ``10``, ``12``]``size ``=` `len``(arr)``print``(minOperations(arr, K, size))``'''Code is written by Rajat Kumar'''`

## C#

 `// C# implementation to merge the``// elements of the array until all``// the array element of the array``// greater than or equal to K``using` `System;``using` `System.Collections.Generic;``class` `GFG``{` `  ``// Function to find the minimum``  ``// operation required to merge``  ``// elements of the array``  ``static` `int` `minOperations(``int``[] arr, ``int` `K, ``int` `size) ``  ``{``    ``int` `least, second_least, min_operations = 0, ``    ``new_ele = 0, flag = 0;` `    ``// Heap to store the elements``    ``// of the array and to extract``    ``// minimum elements of O(logN)``    ``List<``int``> heap = ``new` `List<``int``>();` `    ``// priority_queue,``    ``// greater > heap;` `    ``// Loop to push all the elements``    ``// of the array into heap``    ``for``(``int` `i = 0; i < size; i++)``    ``{``      ``heap.Add(arr[i]);``    ``}``    ``heap.Sort();``    ``heap.Reverse();` `    ``// Loop to merge the minimum``    ``// elements until there is only``    ``// all the elements greater than K``    ``while``(heap.Count != 1)``    ``{` `      ``// Condition to check minimum``      ``// element of the array is``      ``// greater than the K``      ``if``(heap[heap.Count - 1] >= K)``      ``{``        ``flag = 1;``        ``break``;``      ``}` `      ``// Merge the two minimum``      ``// elements of the heap``      ``least = heap[heap.Count - 1];``      ``heap.RemoveAt(heap.Count - 1);``      ``second_least = heap[heap.Count - 1];``      ``heap.RemoveAt(heap.Count - 1);``      ``new_ele = (1 * least) +(2 * second_least);``      ``min_operations++;``      ``heap.Add(new_ele);``      ``heap.Sort();``      ``heap.Reverse();           ``    ``}``    ``if``(heap[heap.Count - 1] >= K)``    ``{``      ``flag = 1;``    ``}``    ``if``(flag == 1)``    ``{``      ``return` `min_operations;``    ``}``    ``return` `-1;        ``  ``}` `  ``// Driver Code``  ``static` `public` `void` `Main ()``  ``{``    ``int` `K = 7;``    ``int``[] arr = { 1, 2, 3, 9, 10, 12 };``    ``int` `size = arr.Length;``    ``Console.WriteLine(minOperations(arr, K, size));``  ``}``}` `// This code is contributed by avanitrachhadiya2155`

## Javascript

 ``

Output:
`2`

Time Complexity: Complexity of the above algorithms is determined by one by while loop and second by heapify operation. Time taken by while loop is O(N) and inside the same while loop heapify() operation is used that will take

O(Log n) time, so overall time complexity will be O(N* Log N).

Space Complexity: O(N) space would be required for the storing elements into heap.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next