# 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:**

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****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.

Input:arr[] = {1, 2, 3, 4}Output:3Explanation: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:

- Traverse the array and push all the elements which are greater than 0, in the priority queue.
- Create a variable
**op**, to store the number of operations, and initialise it with 0. - 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.

- Increment the value of variable
- Repeat the above operation until the priority queue becomes empty.
- Print
**op**, as the answer to this question.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `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;` `}` |

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

## Javascript

`<script>` `// Javascript program for the above approach` `// Function to find the minimum number` `// of operations required to make all` `// array elements zero` `function` `setElementstoZero(arr, N)` `{` ` ` `// Create a priority queue` ` ` `var` `pq = [];` ` ` `// Variable to store the number` ` ` `// of operations` ` ` `var` `op = 0;` ` ` `for` `(` `var` `i = 0; i < N; i++) {` ` ` `if` `(arr[i] > 0) {` ` ` `pq.push(arr[i]);` ` ` `}` ` ` `}` ` ` `pq.sort((a,b) => a-b);` ` ` `// Iterate over the priority queue` ` ` `// till size is greater than 1` ` ` `while` `(pq.length > 1) {` ` ` `// Increment op by 1` ` ` `op += 1;` ` ` ` ` `var` `p = pq[pq.length-1];` ` ` `pq.pop();` ` ` `var` `q = pq[pq.length-1];` ` ` `pq.pop();` ` ` `// If the element is still greater` ` ` `// than zero again push it again in pq` ` ` `if` `(p - q > 0) {` ` ` `pq.push(p);` ` ` `}` ` ` `pq.sort((a,b) => a-b);` ` ` `}` ` ` `// Return op as the answer` ` ` `return` `op;` `}` `// Driver Code` `var` `arr = [ 1, 2, 3, 4 ];` `var` `N = arr.length;` `document.write(setElementstoZero(arr, N));` `// This code is contributed by rutvik_56.` `</script>` |

**Output**

3

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