 GFG App
Open App Browser
Continue

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

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 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 than 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 than 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 than 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 than 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