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)