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:

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 0int minOperations(vector 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 Codeint main(){     vector arr{ 4, 1, 5 };    int N = arr.size();    int K = 1;     cout << minOperations(arr, K, N);     return 0;}

Java

 // Java program for the above approachimport 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 0def 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 Codeif __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 approachusing 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