Minimum operations for reducing Array to 0 by subtracting smaller element from a pair repeatedly
Last Updated :
16 Feb, 2022
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:
- 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.
- 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++
#include <bits/stdc++.h>
using namespace std;
int setElementstoZero( int arr[], int N)
{
priority_queue< int > pq;
int op = 0;
for ( int i = 0; i < N; i++) {
if (arr[i] > 0) {
pq.push(arr[i]);
}
}
while (pq.size() > 1) {
op += 1;
auto p = pq.top();
pq.pop();
auto q = pq.top();
pq.pop();
if (p - q > 0) {
pq.push(p);
}
}
return op;
}
int main()
{
int arr[] = { 1, 2, 3, 4 };
int N = sizeof (arr) / sizeof (arr[0]);
cout << setElementstoZero(arr, N);
return 0;
}
|
Java
import java.util.*;
class CustomComparator implements Comparator<Integer> {
@Override
public int compare(Integer number1, Integer number2)
{
int value = number1.compareTo(number2);
if (value > 0 ) {
return - 1 ;
}
else if (value < 0 ) {
return 1 ;
}
else {
return 0 ;
}
}
}
class GFG
{
static int setElementstoZero( int arr[], int N)
{
PriorityQueue<Integer> pq
= new PriorityQueue<Integer>(
new CustomComparator());
int op = 0 ;
for ( int i = 0 ; i < N; i++) {
if (arr[i] > 0 ) {
pq.add(arr[i]);
}
}
while (pq.size() > 1 )
{
op = op + 1 ;
Integer p = pq.poll();
Integer q = pq.poll();
if (p - q > 0 ) {
pq.add(p);
}
}
return op;
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 };
int N = arr.length;
System.out.println(setElementstoZero(arr, N));
}
}
|
Python3
def setElementstoZero(arr, N):
pq = []
op = 0
for i in range (N):
if (arr[i] > 0 ):
pq.append(arr[i])
pq.sort()
while ( len (pq) > 1 ):
op + = 1
p = pq[ len (pq) - 1 ]
pq.pop()
q = pq[ len (pq) - 1 ]
pq.pop()
if (p - q > 0 ):
pq.append(p)
pq.sort()
return op
arr = [ 1 , 2 , 3 , 4 ]
N = len (arr)
print (setElementstoZero(arr, N))
|
C#
using System;
using System.Collections.Generic;
public class GFG {
static int setElementstoZero( int [] arr, int N)
{
List< int > pq = new List< int >();
int op = 0;
for ( int i = 0; i < N; i++) {
if (arr[i] > 0) {
pq.Add(arr[i]);
}
}
while (pq.Count > 1) {
pq.Sort();
pq.Reverse();
op = op + 1;
int p = pq[0];
int q = pq[1];
pq.RemoveRange(0, 2);
if (p - q > 0) {
pq.Add(p);
}
}
return op;
}
public static void Main(String[] args)
{
int [] arr = { 1, 2, 3, 4 };
int N = arr.Length;
Console.WriteLine(setElementstoZero(arr, N));
}
}
|
Javascript
<script>
function setElementstoZero(arr, N)
{
var pq = [];
var op = 0;
for ( var i = 0; i < N; i++) {
if (arr[i] > 0) {
pq.push(arr[i]);
}
}
pq.sort((a,b) => a-b);
while (pq.length > 1) {
op += 1;
var p = pq[pq.length-1];
pq.pop();
var q = pq[pq.length-1];
pq.pop();
if (p - q > 0) {
pq.push(p);
}
pq.sort((a,b) => a-b);
}
return op;
}
var arr = [ 1, 2, 3, 4 ];
var N = arr.length;
document.write(setElementstoZero(arr, N));
</script>
|
Time Complexity: O(NlogN)
Auxiliary Space: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...