Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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[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++




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




<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 then 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>
Output: 
5

 

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :