Given an array, arr[] and weight W. The task is to minimize the number of Knapsacks required to store all elements of the array. A single knapsack can store a maximum total weight of W.
NOTE: Each integer of the array is greater than (W/3).
Examples:
Input: arr[] = {150, 150, 150, 150, 150}, W = 300
Output: 3
Explanation: Minimum of 3 Knapsacks are required to store all elements
Knapsack 1 – {150, 150}, Knapsack 2 – {150, 150}, Knapsack 3 – {150}. The weight of each knapsack is <= W.Input: arr[] = {130, 140, 150, 160}, W = 300
Output: 2
Explanation: The knapsacks can be filled as {130, 150}, {140, 160}.
Approach: This problem can be solved by using the Two-Pointer approach and Sorting. Follow the steps below to solve the given problem.
- Sort the array in non-decreasing order.
- As the array contains elements with values greater than W/3 so no knapsack can contain more than two elements.
- Maintain two pointers L and R. Initially L = 0, R = N-1.
- Maintain a while loop for values L <= R.
- For each L and R check the value arr[L] + A[R] <= W. If this is true then it is possible to put these blocks in the same knapsack. Increment L by 1 and decrease R by 1.
- Otherwise, the knapsack will have a single element of value arr[i]. Decrease R by 1.
- Increment answer for each valid step.
Below is the implementation of the above approach:
// C++ implementation for the above approach #include <bits/stdc++.h> using namespace std;
// Function to calculate // minimum knapsacks required to int minimumKnapsacks( int A[], int N, int W)
{ // Variable to store
// the knapsacks required
int ans = 0;
// Maintain two pointers L and R
int L = 0, R = N - 1;
// Sort the array in
// non-decreasing order
sort(A, A + N);
// Maintain a while loop
while (L <= R) {
// Check if there two elements
// can be stored in a
// single knapsack
if (A[L] + A[R] <= W) {
// Increment the answer
ans++;
// Decrease the right pointer
R--;
// Increase the left pointer
L++;
}
else {
// A single knapsack will be required
// to store the Right element
R--;
ans++;
}
}
return ans;
} // Driver Code int main()
{ int W = 300;
int arr[] = { 130, 140, 150, 160 };
// To store the size of arr[]
int N = sizeof (arr) / sizeof (arr[0]);
// Print the answer
cout << minimumKnapsacks(arr, N, W);
} |
// Java program for the above approach import java.util.*;
public class GFG
{ // Function to calculate // minimum knapsacks required to static int minimumKnapsacks( int A[], int N, int W)
{ // Variable to store
// the knapsacks required
int ans = 0 ;
// Maintain two pointers L and R
int L = 0 , R = N - 1 ;
// Sort the array in
// non-decreasing order
Arrays.sort(A);
// Maintain a while loop
while (L <= R) {
// Check if there two elements
// can be stored in a
// single knapsack
if (A[L] + A[R] <= W) {
// Increment the answer
ans++;
// Decrease the right pointer
R--;
// Increase the left pointer
L++;
}
else {
// A single knapsack will be required
// to store the Right element
R--;
ans++;
}
}
return ans;
} // Driver code public static void main (String args[])
{ int W = 300 ;
int arr[] = { 130 , 140 , 150 , 160 };
// To store the size of arr[]
int N = arr.length;
// Print the answer
System.out.println(minimumKnapsacks(arr, N, W));
} } // This code is contributed by Samim Hossain Mondal. |
# Python implementation for the above approach # Function to calculate # minimum knapsacks required to def minimumKnapsacks(A, N, W):
# Variable to store
# the knapsacks required
ans = 0 ;
# Maintain two pointers L and R
L = 0
R = N - 1 ;
# Sort the array in
# non-decreasing order
A.sort();
# Maintain a while loop
while (L < = R):
# Check if there two elements
# can be stored in a
# single knapsack
if (A[L] + A[R] < = W):
# Increment the answer
ans + = 1
# Decrease the right pointer
R - = 1
# Increase the left pointer
L + = 1
else :
# A single knapsack will be required
# to store the Right element
R - = 1
ans + = 1
return ans;
# Driver Code W = 300 ;
arr = [ 130 , 140 , 150 , 160 ]
# To store the size of arr[] N = len (arr);
# Print the answer print (minimumKnapsacks(arr, N, W))
# This code is contributed by saurabh_jaiswal. |
// C# program for the above approach using System;
public class GFG
{ // Function to calculate // minimum knapsacks required to static int minimumKnapsacks( int []A, int N, int W)
{ // Variable to store
// the knapsacks required
int ans = 0;
// Maintain two pointers L and R
int L = 0, R = N - 1;
// Sort the array in
// non-decreasing order
Array.Sort(A);
// Maintain a while loop
while (L <= R) {
// Check if there two elements
// can be stored in a
// single knapsack
if (A[L] + A[R] <= W) {
// Increment the answer
ans++;
// Decrease the right pointer
R--;
// Increase the left pointer
L++;
}
else {
// A single knapsack will be required
// to store the Right element
R--;
ans++;
}
}
return ans;
} // Driver code public static void Main ()
{ int W = 300;
int []arr = { 130, 140, 150, 160 };
// To store the size of arr[]
int N = arr.Length;
// Print the answer
Console.Write(minimumKnapsacks(arr, N, W));
} } // This code is contributed by Samim Hossain Mondal. |
<script> // JavaScript implementation for the above approach
// Function to calculate
// minimum knapsacks required to
const minimumKnapsacks = (A, N, W) => {
// Variable to store
// the knapsacks required
let ans = 0;
// Maintain two pointers L and R
let L = 0, R = N - 1;
// Sort the array in
// non-decreasing order
A.sort();
// Maintain a while loop
while (L <= R) {
// Check if there two elements
// can be stored in a
// single knapsack
if (A[L] + A[R] <= W) {
// Increment the answer
ans++;
// Decrease the right pointer
R--;
// Increase the left pointer
L++;
}
else
{
// A single knapsack will be required
// to store the Right element
R--;
ans++;
}
}
return ans;
}
// Driver Code
let W = 300;
let arr = [130, 140, 150, 160];
// To store the size of arr[]
let N = arr.length;
// Print the answer
document.write(minimumKnapsacks(arr, N, W));
// This code is contributed by rakeshsahni
</script> |
2
Time Complexity: O(N*log(N))
Auxiliary Space: O(1)