# Reduce the Array to 0 by decreasing elements by 1 or replacing at most K elements by 0

• Last Updated : 26 Oct, 2021

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:

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[] = {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 by 0, converts arr[] to {4, 1, 0} –> Number of operations = 0.
Decrease arr by 1, converts arr[] to {4, 0, 0} –>  Number of operations = 1.
Decrease arr 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++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum number``// operations needed to convert all the``// array elements to 0``int` `minOperations(vector<``int``> arr,``                  ``int` `K, ``int` `N)``{` `    ``// If K is greater then 0 then``    ``// replace all array elements to 0``    ``if` `(K >= N)``        ``return` `0;` `    ``// Sort array in non-decreasing order``    ``sort(arr.begin(), arr.end());` `    ``// Stores the count of operations``    ``// required``    ``int` `countOperations = 0;` `    ``// Iterate loop until N - K times``    ``for` `(``int` `i = 0; i < N - K; i++) {` `        ``// Take sum of elements``        ``countOperations += arr[i];``    ``}` `    ``// Return countOperations as``    ``// the required answer``    ``return` `countOperations;``}` `// Driver Code``int` `main()``{` `    ``vector<``int``> arr{ 4, 1, 5 };``    ``int` `N = arr.size();``    ``int` `K = 1;` `    ``cout << minOperations(arr, K, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.Arrays;` `public` `class` `GFG {``    ` `    ``// Function to find the minimum number``    ``// operations needed to convert all the``    ``// array elements to 0``    ``static` `int` `minOperations(``int` `[]arr,``                      ``int` `K, ``int` `N)``    ``{``    ` `        ``// If K is greater then 0 then``        ``// replace all array elements to 0``        ``if` `(K >= N)``            ``return` `0``;``    ` `        ``// Sort array in non-decreasing order``        ``Arrays.sort(arr) ;``    ` `        ``// Stores the count of operations``        ``// required``        ``int` `countOperations = ``0``;``    ` `        ``// Iterate loop until N - K times``        ``for` `(``int` `i = ``0``; i < N - K; i++) {``    ` `            ``// Take sum of elements``            ``countOperations += arr[i];``        ``}``    ` `        ``// Return countOperations as``        ``// the required answer``        ``return` `countOperations;``    ``}` `    ``// Driver Code``    ``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));``    ``}` `}` `// This code is contributed by AnkThon`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum number``# operations needed to convert all the``# array elements to 0``def` `minOperations(arr, K, N) :` `    ``# If K is greater then 0 then``    ``# replace all array elements to 0``    ``if` `(K >``=` `N) :``        ``return` `0``;` `    ``# Sort array in non-decreasing order``    ``arr.sort();` `    ``# Stores the count of operations``    ``# required``    ``countOperations ``=` `0``;` `    ``# Iterate loop until N - K times``    ``for` `i ``in` `range``(N ``-` `K) :` `        ``# Take sum of elements``        ``countOperations ``+``=` `arr[i];` `    ``# Return countOperations as``    ``# the required answer``    ``return` `countOperations;` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:`  `    ``arr ``=` `[ ``4``, ``1``, ``5` `];``    ``N ``=` `len``(arr);``    ``K ``=` `1``;` `    ``print``(minOperations(arr, K, N));``    ` `    ``# This code is contributed by AnkThon`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `GFG``{``    ` `    ``// Function to find the minimum number``    ``// operations needed to convert all the``    ``// array elements to 0``    ``static` `int` `minOperations(``int` `[]arr,``                      ``int` `K, ``int` `N)``    ``{``    ` `        ``// If K is greater then 0 then``        ``// replace all array elements to 0``        ``if` `(K >= N)``            ``return` `0;``    ` `        ``// Sort array in non-decreasing order``        ``Array.Sort(arr) ;``    ` `        ``// Stores the count of operations``        ``// required``        ``int` `countOperations = 0;``    ` `        ``// Iterate loop until N - K times``        ``for` `(``int` `i = 0; i < N - K; i++) {``    ` `            ``// Take sum of elements``            ``countOperations += arr[i];``        ``}``    ` `        ``// Return countOperations as``        ``// the required answer``        ``return` `countOperations;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main (``string``[] args)``    ``{``    ` `        ``int``[] arr = { 4, 1, 5 };``        ``int` `N = arr.Length;``        ``int` `K = 1;``    ` `        ``Console.WriteLine(minOperations(arr, K, N));``    ``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``
Output:
`5`

Time Complexity: O(N*log N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up