 Open in App
Not now

# Minimize number of Knapsacks with total weigh W required to store Array containing elements greater than W/3

• Last Updated : 17 Jan, 2022

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++

 `// C++ implementation for the above approach``#include ``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);` `    ``// Print the answer``    ``cout << minimumKnapsacks(arr, N, W);``}`

## Java

 `// 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.`

## Python3

 `# 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#

 `// 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.`

## Javascript

 ``

Output

`2`

Time Complexity: O(N*log(N))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up