|
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++
#include <bits/stdc++.h>
using namespace std;
int minOperations(vector<int> arr,
int K, int N)
{
if (K >= N)
return 0;
sort(arr.begin(), arr.end());
int countOperations = 0;
for (int i = 0; i < N - K; i++) {
countOperations += arr[i];
}
return countOperations;
}
int main()
{
vector<int> arr{ 4, 1, 5 };
int N = arr.size();
int K = 1;
cout << minOperations(arr, K, N);
return 0;
}
|
Java
import java.util.Arrays;
public class GFG {
static int minOperations(int []arr,
int K, int N)
{
if (K >= N)
return 0;
Arrays.sort(arr) ;
int countOperations = 0;
for (int i = 0; i < N - K; i++) {
countOperations += arr[i];
}
return countOperations;
}
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));
}
}
|
Python3
def minOperations(arr, K, N) :
if (K >= N) :
return 0;
arr.sort();
countOperations = 0;
for i in range(N - K) :
countOperations += arr[i];
return countOperations;
if __name__ == "__main__" :
arr = [ 4, 1, 5 ];
N = len(arr);
K = 1;
print(minOperations(arr, K, N));
|
C#
using System;
public class GFG
{
static int minOperations(int []arr,
int K, int N)
{
if (K >= N)
return 0;
Array.Sort(arr) ;
int countOperations = 0;
for (int i = 0; i < N - K; i++) {
countOperations += arr[i];
}
return countOperations;
}
public static void Main (string[] args)
{
int[] arr = { 4, 1, 5 };
int N = arr.Length;
int K = 1;
Console.WriteLine(minOperations(arr, K, N));
}
}
|
Javascript
<script>
function minOperations(arr, K, N)
{
if (K >= N) return 0;
arr.sort((a, b) => a - b);
let countOperations = 0;
for (let i = 0; i < N - K; i++) {
countOperations += arr[i];
}
return countOperations;
}
let arr = [4, 1, 5];
let N = arr.length;
let K = 1;
document.write(minOperations(arr, K, N));
</script>
|
Time Complexity: O(N*log N)
Auxiliary Space: O(1)
|
