Min steps to empty an Array by removing a pair each time with sum at most K
Last Updated :
17 Jun, 2021
Given an array arr[] and a target value K. The task is to find the minimum number of steps required to take all elements from the array. In each step, at most two elements can be selected from array such that their sum must not exceed target value K.
Note: All the elements of the array are less than or equals to K.
Input: arr[] = [5, 1, 5, 4], K = 8
Output: 3
Explanation:
We can pick {1, 4}, {5}, {5} in 3 steps:
Other possible arrangement can be {1, 5}, {4}, {5} in three steps.
So, the minimum number of steps are required is 3
Input: [1, 2, 1, 1, 3], n = 9
Output: 3
Explanation:
We can pick {1, 1}, {2, 3} and {1} in three steps.
Other possible choices {1, 3}, {1, 2}, {1} or {1, 1}, {1, 3}, {2}
So, the minimum number of steps are required is 3
Approach: The above problem can be solved using Greedy Approach along with Two Pointers Technique. The idea is to pick the smallest and the largest element from the array and check if the sum doesn’t exceeds N then remove these elements and count this step else remove the largest element and then repeat the above steps until all elements are removed. Below are the steps:
- Sort the given array arr[].
- Initialize two index i = 0 and j = N – 1.
- If the sum of elements arr[i] and arr[j] doesn’t exceed N then increment i and decrement j.
- Else decrement j.
- Repeat the above steps till i <= j and count each step.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int countMinSteps( int arr[], int target,
int n)
{
sort(arr, arr + n);
int minimumSteps = 0;
int i = 0, j = n - 1;
while (i <= j) {
if (arr[i] + arr[j] <= target) {
i++;
j--;
}
else {
j--;
}
minimumSteps++;
}
return minimumSteps;
}
int main()
{
int arr[] = { 4, 6, 2, 9, 6, 5, 8, 10 };
int target = 11;
int size = sizeof (arr) / sizeof (arr[0]);
cout << countMinSteps(arr, target, size);
return 0;
}
|
Java
import java.util.*;
import java.io.*;
class GFG{
static int countMinSteps( int arr[],
int target,
int n)
{
Arrays.sort(arr);
int minimumSteps = 0 ;
int i = 0 ;
int j = n - 1 ;
while (i <= j)
{
if (arr[i] + arr[j] <= target)
{
i += 1 ;
j -= 1 ;
}
else
{
j -= 1 ;
}
minimumSteps += 1 ;
}
return minimumSteps;
}
public static void main(String[] args)
{
int arr[] = { 4 , 6 , 2 , 9 , 6 , 5 , 8 , 10 };
int target = 11 ;
int size = arr.length;
System.out.print(countMinSteps(arr, target,
size));
}
}
|
Python3
def countMinSteps(arr, target, n):
arr.sort()
minimumSteps = 0
i, j = 0 , n - 1
while i < = j:
if arr[i] + arr[j] < = target:
i + = 1
j - = 1
else :
j - = 1
minimumSteps + = 1
return minimumSteps
arr = [ 4 , 6 , 2 , 9 , 6 , 5 , 8 , 10 ]
target = 11
size = len (arr)
print (countMinSteps(arr, target, size))
|
C#
using System;
class GFG{
static int countMinSteps( int [] arr,
int target,
int n)
{
Array.Sort(arr);
int minimumSteps = 0;
int i = 0;
int j = n - 1;
while (i <= j)
{
if (arr[i] + arr[j] <= target)
{
i += 1;
j -= 1;
}
else
{
j -= 1;
}
minimumSteps += 1;
}
return minimumSteps;
}
public static void Main()
{
int [] arr = new int []{ 4, 6, 2, 9,
6, 5, 8, 10 };
int target = 11;
int size = arr.Length;
Console.Write(countMinSteps(
arr, target, size));
}
}
|
Javascript
<script>
function countMinSteps(arr, target, n)
{
arr = arr.sort( function (a, b) {
return a - b;
});
var minimumSteps = 0;
var i = 0, j = n - 1;
while (i <= j) {
if (arr[i] + arr[j] <= target) {
i++;
j--;
}
else {
j--;
}
minimumSteps++;
}
return minimumSteps;
}
var arr = [4, 6, 2, 9, 6, 5, 8, 10];
var target = 11;
var size = arr.length;
document.write(countMinSteps(arr, target, size));
</script>
|
Output:
5
Time Complexity: O(N*log N)
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...