GeeksforGeeks App
Open App
Browser
Continue

# Minimum operations for reducing Array to 0 by subtracting smaller element from a pair repeatedly

Given an array arr[] of size N, the task is to find the minimum number of operations required to make all array elements zero. In one operation, select a pair of elements and subtract the smaller element from both elements in the array.

Example:

Input: arr[] = {1, 2, 3, 4}
Output: 3
Explanation: Pick the elements in the following sequence:
Operation 1: Pick elements at indices {3, 2}: arr[]={1, 2, 0, 1}
Operation 2: Pick elements at indices {1, 3}: arr[]={1, 1, 0, 0}
Operation 3: Pick elements at indices {2, 1}: arr[]={0, 0, 0, 0}

Input: arr[] = {2, 2, 2, 2}
Output: 2

Approach:  This problem can be solved using a priority queue. To solve the below problem, follow the below steps:

1. Traverse the array and push all the elements which are greater than 0, in the priority queue.
2. Create a variable op, to store the number of operations, and initialise it with 0.
3. Now, iterate over the priority queue pq till its size is greater than one in each iteration:
• Increment the value of variable op.
• Then select the top two elements, let’s say p and q to apply the given operation.
• After applying the operation, one element will definitely become 0. Push the other one back into the priority queue if it is greater than zero.
4. Repeat the above operation until the priority queue becomes empty.
5. Print op, as the answer to this question.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the minimum number``// of operations required to make all``// array elements zero``int` `setElementstoZero(``int` `arr[], ``int` `N)``{` `    ``// Create a priority queue``    ``priority_queue<``int``> pq;` `    ``// Variable to store the number``    ``// of operations``    ``int` `op = 0;` `    ``for` `(``int` `i = 0; i < N; i++) {``        ``if` `(arr[i] > 0) {``            ``pq.push(arr[i]);``        ``}``    ``}` `    ``// Iterate over the priority queue``    ``// till size is greater than 1``    ``while` `(pq.size() > 1) {``        ``// Increment op by 1``        ``op += 1;` `        ``auto` `p = pq.top();``        ``pq.pop();``        ``auto` `q = pq.top();``        ``pq.pop();` `        ``// If the element is still greater``        ``// than zero again push it again in pq``        ``if` `(p - q > 0) {``            ``pq.push(p);``        ``}``    ``}` `    ``// Return op as the answer``    ``return` `op;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 4 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << setElementstoZero(arr, N);` `    ``return` `0;``}`

## Java

 `// Java code for the above approach``import` `java.util.*;``class` `CustomComparator ``implements` `Comparator {``    ``@Override``    ``public` `int` `compare(Integer number1, Integer number2)``    ``{``        ``int` `value = number1.compareTo(number2);``      ` `        ``// elements are sorted in reverse order``        ``if` `(value > ``0``) {``            ``return` `-``1``;``        ``}``        ``else` `if` `(value < ``0``) {``            ``return` `1``;``        ``}``        ``else` `{``            ``return` `0``;``        ``}``    ``}``}``class` `GFG``{``  ` `    ``// Function to find the minimum number``    ``// of operations required to make all``    ``// array elements zero``    ``static` `int` `setElementstoZero(``int` `arr[], ``int` `N)``    ``{``      ` `        ``// Create a priority queue``        ``PriorityQueue pq``            ``= ``new` `PriorityQueue(``                ``new` `CustomComparator());``      ` `        ``// Variable to store the number``        ``// of operations``        ``int` `op = ``0``;``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``if` `(arr[i] > ``0``) {``                ``pq.add(arr[i]);``            ``}``        ``}``        ``// Iterate over the priority queue``        ``// till size is greater than 1``        ``while` `(pq.size() > ``1``)``        ``{``          ` `            ``// Increment op by 1``            ``op = op + ``1``;``            ``Integer p = pq.poll();``            ``Integer q = pq.poll();``          ` `            ``// If the element is still greater``            ``// than zero again push it again in pq``            ``if` `(p - q > ``0``) {``                ``pq.add(p);``            ``}``        ``}``      ` `        ``// Return op as the answer``        ``return` `op;``    ``}``  ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``1``, ``2``, ``3``, ``4` `};``        ``int` `N = arr.length;``        ``System.out.println(setElementstoZero(arr, N));``    ``}``}` `// This code is contributed by Potta Lokesh`

## Python3

 `# Python program for the above approach` `# Function to find the minimum number``# of operations required to make all``# array elements zero``def` `setElementstoZero(arr, N):` `    ``# Create a priority queue``    ``pq ``=` `[]` `    ``# Variable to store the number``    ``# of operations``    ``op ``=` `0` `    ``for` `i ``in` `range``(N):``        ``if` `(arr[i] > ``0``):``            ``pq.append(arr[i])` `    ``pq.sort()` `    ``# Iterate over the priority queue``    ``# till size is greater than 1``    ``while` `(``len``(pq) > ``1``):``        ``# Increment op by 1``        ``op ``+``=` `1` `        ``p ``=` `pq[``len``(pq) ``-` `1``]``        ``pq.pop()``        ``q ``=` `pq[``len``(pq)``-``1``]``        ``pq.pop()` `        ``# If the element is still greater``        ``# than zero again push it again in pq``        ``if` `(p ``-` `q > ``0``):``            ``pq.append(p)``        ``pq.sort()` `    ``# Return op as the answer``    ``return` `op`  `# Driver Code``arr ``=` `[``1``, ``2``, ``3``, ``4``]``N ``=` `len``(arr)``print``(setElementstoZero(arr, N))` `# This code is contributed by Saurabh Jaiswal`

## C#

 `// C# code for the above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `  ``// Function to find the minimum number``  ``// of operations required to make all``  ``// array elements zero``  ``static` `int` `setElementstoZero(``int``[] arr, ``int` `N)``  ``{` `    ``// Create a priority queue``    ``List<``int``> pq = ``new` `List<``int``>();` `    ``// Variable to store the number``    ``// of operations``    ``int` `op = 0;``    ``for` `(``int` `i = 0; i < N; i++) {``      ``if` `(arr[i] > 0) {``        ``pq.Add(arr[i]);``      ``}``    ``}``    ` `    ``// Iterate over the priority queue``    ``// till size is greater than 1``    ``while` `(pq.Count > 1) {``      ``pq.Sort();``      ``pq.Reverse();``      ` `      ``// Increment op by 1``      ``op = op + 1;``      ``int` `p = pq[0];` `      ``int` `q = pq[1];``      ``pq.RemoveRange(0, 2);` `      ``// If the element is still greater``      ``// than zero again push it again in pq``      ``if` `(p - q > 0) {``        ``pq.Add(p);``      ``}``    ``}` `    ``// Return op as the answer``    ``return` `op;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int``[] arr = { 1, 2, 3, 4 };``    ``int` `N = arr.Length;``    ``Console.WriteLine(setElementstoZero(arr, N));``  ``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

`3`

Time Complexity: O(NlogN)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up