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++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to count minimum steps int countMinSteps( int arr[], int target,
int n)
{ // Function to sort the array
sort(arr, arr + n);
int minimumSteps = 0;
int i = 0, j = n - 1;
// Run while loop
while (i <= j) {
// Condition to check whether
// sum exceed the target or not
if (arr[i] + arr[j] <= target) {
i++;
j--;
}
else {
j--;
}
// Increment the step
// by 1
minimumSteps++;
}
// Return minimum steps
return minimumSteps;
} // Driver Code int main()
{ // Given array arr[]
int arr[] = { 4, 6, 2, 9, 6, 5, 8, 10 };
// Given target value
int target = 11;
int size = sizeof (arr) / sizeof (arr[0]);
// Function call
cout << countMinSteps(arr, target, size);
return 0;
} |
// Java program implementation // of the above approach import java.util.*;
import java.io.*;
class GFG{
// Function to count minimum steps static int countMinSteps( int arr[],
int target,
int n)
{ // Function to sort the array
Arrays.sort(arr);
int minimumSteps = 0 ;
int i = 0 ;
int j = n - 1 ;
// Run while loop
while (i <= j)
{
// Condition to check whether
// sum exceed the target or not
if (arr[i] + arr[j] <= target)
{
i += 1 ;
j -= 1 ;
}
else
{
j -= 1 ;
}
// Increment the step by 1
minimumSteps += 1 ;
}
// Return minimum steps
return minimumSteps;
} // Driver code public static void main(String[] args)
{ int arr[] = { 4 , 6 , 2 , 9 , 6 , 5 , 8 , 10 };
// Given target value
int target = 11 ;
int size = arr.length;
// Print the minimum flip
System.out.print(countMinSteps(arr, target,
size));
} } // This code is contributed by code_hunt |
# Python3 program for the above approach # Function to count minimum steps def countMinSteps(arr, target, n):
# Function to sort the array
arr.sort()
minimumSteps = 0
i, j = 0 , n - 1
# Run while loop
while i < = j:
# Condition to check whether
# sum exceed the target or not
if arr[i] + arr[j] < = target:
i + = 1
j - = 1
else :
j - = 1
# Increment the step
# by 1
minimumSteps + = 1
# Return minimum steps
return minimumSteps
# Driver code # Given array arr[] arr = [ 4 , 6 , 2 , 9 , 6 , 5 , 8 , 10 ]
# Given target value target = 11
size = len (arr)
# Function call print (countMinSteps(arr, target, size))
# This code is contributed by Stuti Pathak |
// C# program implementation // of the above approach using System;
class GFG{
// Function to count minimum steps static int countMinSteps( int [] arr,
int target,
int n)
{ // Function to sort the array
Array.Sort(arr);
int minimumSteps = 0;
int i = 0;
int j = n - 1;
// Run while loop
while (i <= j)
{
// Condition to check whether
// sum exceed the target or not
if (arr[i] + arr[j] <= target)
{
i += 1;
j -= 1;
}
else
{
j -= 1;
}
// Increment the step by 1
minimumSteps += 1;
}
// Return minimum steps
return minimumSteps;
} // Driver code public static void Main()
{ int [] arr = new int []{ 4, 6, 2, 9,
6, 5, 8, 10 };
// Given target value
int target = 11;
int size = arr.Length;
// Print the minimum flip
Console.Write(countMinSteps(
arr, target, size));
} } // This code is contributed by sanjoy_62 |
<script> // javascript program for the above approach // Function to count minimum steps function countMinSteps(arr, target, n)
{ // Function to sort the array
arr = arr.sort( function (a, b) {
return a - b;
}); var minimumSteps = 0;
var i = 0, j = n - 1;
// Run while loop
while (i <= j) {
// Condition to check whether
// sum exceed the target or not
if (arr[i] + arr[j] <= target) {
i++;
j--;
}
else {
j--;
}
// Increment the step
// by 1
minimumSteps++;
}
// Return minimum steps
return minimumSteps;
} // Driver Code // Given array arr[]
var arr = [4, 6, 2, 9, 6, 5, 8, 10];
// Given target value
var target = 11;
var size = arr.length;
// Function call
document.write(countMinSteps(arr, target, size));
// This code is contributed by ipg2016107. </script> |
Output:
5
Time Complexity: O(N*log N)
Auxiliary Space: O(1)