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

<script>
// Javascript program for the above approach

// Function to find the minimum number
// operations needed to convert all the
// array elements to 0
function 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((a, b) => a - b);

  // Stores the count of operations
  // required
  let countOperations = 0;

  // Iterate loop until N - K times
  for (let i = 0; i < N - K; i++) {
    // Take sum of elements
    countOperations += arr[i];
  }

  // Return countOperations as
  // the required answer
  return countOperations;
}

// Driver Code

let arr = [4, 1, 5];
let N = arr.length;
let K = 1;

document.write(minOperations(arr, K, N));

// This code is contributed by saurabh_jaiswal.
</script>

5

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

hrithikgarg03188

Follow

Improve

Article Tags :

• Misc
• Greedy
• Sorting
• Mathematical
• DSA
• Arrays

+2 More

Practice Tags :

• Arrays
• Greedy
• Mathematical
• Misc
• Sorting

+1 More