Reduce the Array to 0 by decreasing elements by 1 or replacing at most K elements by 0
Last Updated :
14 Dec, 2022
Given an array arr[] of N integers and a positive integer K, the task is to find the minimum number of operations required to reduce all array elements to 0 such that in each operation reduce any array element by 1 and independently at most K array element can be reduced to 0.
Examples:
Input: arr[] = {4, 1, 5}, K = 1
Output: 5
Explanation: Following are the operations performed to convert all array elements to 0:
Here K = 1, So replace arr[2] by 0, converts arr[] to {4, 1, 0} –> Number of operations = 0.
Decrease arr[1] by 1, converts arr[] to {4, 0, 0} –> Number of operations = 1.
Decrease arr[0] by 1 four times, converts arr[] to {0, 0, 0} –> Number of operations = 4.
Therefore, total number of operations = 0 + 1 + 4 = 5, which is minimum possible.
Input: arr[] = {4, 2, 10, 9, 18}, K = 2
Output: 15
Approach: The given problem can be solved by using the Greedy Approach which is based on the idea is that first sort the given array arr[] in non-decreasing order and then update the K largest element to 0 and perform the given operation on the remaining array elements. Follow the steps below to solve the given problem:
- If the value of N is at most K, then replace all array elements with 0. Therefore the number of operations required in this case will be 0.
- Sort the array arr[] in non-decreasing order.
- Replace last K elements by 0.
- Print the sum of the first (N – K) elements as the resultant count of operations.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int minOperations(vector< int > arr,
int K, int N)
{
if (K >= N)
return 0;
sort(arr.begin(), arr.end());
int countOperations = 0;
for ( int i = 0; i < N - K; i++) {
countOperations += arr[i];
}
return countOperations;
}
int main()
{
vector< int > arr{ 4, 1, 5 };
int N = arr.size();
int K = 1;
cout << minOperations(arr, K, N);
return 0;
}
|
Java
import java.util.Arrays;
public class GFG {
static int minOperations( int []arr,
int K, int N)
{
if (K >= N)
return 0 ;
Arrays.sort(arr) ;
int countOperations = 0 ;
for ( int i = 0 ; i < N - K; i++) {
countOperations += arr[i];
}
return countOperations;
}
public static void main (String[] args)
{
int [] arr = { 4 , 1 , 5 };
int N = arr.length;
int K = 1 ;
System.out.println(minOperations(arr, K, N));
}
}
|
Python3
def minOperations(arr, K, N) :
if (K > = N) :
return 0 ;
arr.sort();
countOperations = 0 ;
for i in range (N - K) :
countOperations + = arr[i];
return countOperations;
if __name__ = = "__main__" :
arr = [ 4 , 1 , 5 ];
N = len (arr);
K = 1 ;
print (minOperations(arr, K, N));
|
C#
using System;
public class GFG
{
static int minOperations( int []arr,
int K, int N)
{
if (K >= N)
return 0;
Array.Sort(arr) ;
int countOperations = 0;
for ( int i = 0; i < N - K; i++) {
countOperations += arr[i];
}
return countOperations;
}
public static void Main ( string [] args)
{
int [] arr = { 4, 1, 5 };
int N = arr.Length;
int K = 1;
Console.WriteLine(minOperations(arr, K, N));
}
}
|
Javascript
<script>
function minOperations(arr, K, N)
{
if (K >= N) return 0;
arr.sort((a, b) => a - b);
let countOperations = 0;
for (let i = 0; i < N - K; i++) {
countOperations += arr[i];
}
return countOperations;
}
let arr = [4, 1, 5];
let N = arr.length;
let K = 1;
document.write(minOperations(arr, K, N));
</script>
|
Time Complexity: O(N*log N)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...