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>
Output
2
Time Complexity: O(N*log(N))
Auxiliary Space: O(1)
