Open In App
Related Articles

Minimum number of bins required to place N items ( Using Best Fit algorithm )

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given an array weight[] consisting of weights of N items and a positive integer C representing the capacity of each bin, the task is to find the minimum number of bins required such that all items are assigned to one of the bins.

Examples:

Input: weight[] = {4, 8, 1, 4, 2, 1}, C = 10
Output: 2
Explanation: The minimum number of bins required to accommodate all items is 2.
The first bin contains the items with weights {4, 4, 2}.
The second bin contains the items with weights {8, 1, 1}.

Input: weight[] = {9, 8, 2, 2, 5, 4}, C = 10
Output: 4

Approach: The given problem can be solved by using the best-fit algorithm. The idea is to place the next item in the bin, where the smallest empty space is left. Follow the steps below to solve the problem:

  • Initialize a variable, say count as 0 that stores the minimum number of bins required.
  • Sort the given array weight[] in decreasing order.
  • Initialize a multiset, say M to store the empty spaces left in the occupied bins presently.
  • Traverse the array weight[] and for each element perform the following steps:
    • If there exists the smallest empty space which is at least arr[i] is present in the M, then erase that space from M and insert the remaining free space to M.
    • Otherwise, increment the count by 1 and insert the empty space of the new bin in M.
  • After completing the above steps, print the value of count as the minimum number of bins required.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum number
// of bins required to fill all items
void bestFit(int arr[], int n, int W)
{
    // Stores the required number
    // of bins
    int count = 0;
 
    // Sort the array in decreasing order
    sort(arr, arr + n, greater<int>());
 
    // Stores the empty spaces in
    // existing bins
    multiset<int> M;
 
    // Traverse the given array
    for (int i = 0; i < n; i++) {
 
        // Check if exact space is
        // present in the set M
        auto x = M.find(arr[i]);
 
        // Store the position of the
        // upperbound of arr[i] in M
        auto y = M.upper_bound(arr[i]);
 
        // If arr[i] is present, then
        // use this space and erase it
        // from the map M
        if (x != M.end()) {
            M.erase(x);
        }
 
        // If upper bound of arr[i] is
        // present, use this space and
        // insert the left space
        else if (y != M.end()) {
            M.insert(*y - arr[i]);
            M.erase(y);
        }
 
        // Otherwise, increment the count
        // of bins and insert the
        // empty space in M
        else {
            count++;
            M.insert(W - arr[i]);
        }
    }
 
    // Print the result
    cout << count;
}
 
// Driver Code
int main()
{
    int items[] = { 4, 8, 1, 4, 2, 1 };
    int W = 10;
    int N = sizeof(items) / sizeof(items[0]);
 
    // Function Call
    bestFit(items, N, W);
 
    return 0;
}

                    

Java

import java.util.*;
 
public class Main
{
 
  // Function to find the minimum number
  // of bins required to fill all items
  public static void bestFit(int[] arr, int n, int W)
  {
 
    // Stores the required number
    // of bins
    int count = 0;
 
    // Sort the array in decreasing order
    Arrays.sort(arr);
 
    for(int i=0;i<arr.length/2;i++){
 
      int temp = arr[i];
      arr[i] = arr[arr.length-i-1];
      arr[arr.length-i-1] = temp;
 
    }
 
    // Stores the empty spaces in
    // existing bins
    TreeSet<Integer> M = new TreeSet<>();
 
    // Traverse the given array
    for (int i = 0; i < n; i++) {
      // Check if exact space is
      // present in the set M
      Integer x = M.floor(arr[i]);
 
      // Store the position of the
      // upperbound of arr[i] in M
      Integer y = M.higher(arr[i]);
 
      // If arr[i] is present, then
      // use this space and erase it
      // from the map M
      if (x != null) {
        M.remove(x);
      }
 
      // If upper bound of arr[i] is
      // present, use this space and
      // insert the left space
      else if (y != null) {
        M.add(y - arr[i]);
        M.remove(y);
      }
 
      // Otherwise, increment the count
      // of bins and insert the
      // empty space in M
      else {
        count++;
        M.add(W - arr[i]);
      }
    }
 
    // Print the result
    System.out.println(count);
  }
 
  public static void main(String[] args) {
    int[] items = { 4, 8, 1, 4, 2, 1 };
    int W = 10;
    int N = items.length;
 
    // Function Call
    bestFit(items, N, W);
  }
}
 
// This code is contributed by aadityaburujwale.

                    

Python3

from typing import List
from collections import defaultdict
 
def bestFit(arr: List[int], n: int, W: int) -> None:
    # Stores the required number
    # of bins
    count = 0
 
    # Sort the array in decreasing order
    arr.sort(reverse=True)
 
    # Stores the empty spaces in
    # existing bins
    M = defaultdict(int)
 
    # Traverse the given array
    for i in range(n):
        # Check if exact space is
        # present in the dictionary M
        if arr[i] in M:
            del M[arr[i]]
        # If upper bound of arr[i] is
        # present, use this space and
        # insert the left space
        elif arr[i] + 1 in M:
            M[M[arr[i] + 1] - arr[i]] = M[arr[i] + 1]
            del M[arr[i] + 1]
        # Otherwise, increment the count
        # of bins and insert the
        # empty space in M
        else:
            count += 1
            M[W - arr[i]] = W
 
    # Print the result
    print(count)
 
# Test the function
items = [4, 8, 1, 4, 2, 1]
W = 10
N = len(items)
 
bestFit(items, N, W)

                    

C#

// C# implementation of the approach
using System;
using System.Linq;
using System.Collections.Generic;
 
public class GFG
{
 
  // Function to find the minimum number
  // of bins required to fill all items
  public static void bestFit(int[] arr, int n, int W)
  {
 
    // Stores the required number
    // of bins
    int count = 0;
     
    // Sort the array in decreasing order
    Array.Sort(arr);
    arr = arr.Reverse().ToArray();
 
    // Stores the empty spaces in
    // existing bins
    SortedSet<int> M = new SortedSet<int>();
 
    // Traverse the given array
    for (int i = 0; i < n; i++)
    {
       
      // Check if exact space is
      // present in the set M
      int x = M.GetViewBetween(int.MinValue, arr[i]).LastOrDefault();
 
      // Store the position of the
      // upperbound of arr[i] in M
      int y = M.GetViewBetween(arr[i], int.MaxValue).FirstOrDefault();
 
      // If arr[i] is present, then
      // use this space and erase it
      // from the map M
      if (x != 0)
      {
        M.Remove(x);
      }
 
      // If upper bound of arr[i] is
      // present, use this space and
      // insert the left space
      else if (y != 0)
      {
        M.Add(y - arr[i]);
        M.Remove(y);
      }
 
      // Otherwise, increment the count
      // of bins and insert the
      // empty space in M
      else
      {
        count++;
        M.Add(W - arr[i]);
      }
    }
 
    // Print the result
    Console.WriteLine(count);
  }
 
  public static void Main(string[] args)
  {
    int[] items = { 4, 8, 1, 4, 2, 1 };
    int W = 10;
    int N = items.Length;
 
    // Function Call
    bestFit(items, N, W);
  }
}
 
// This code is contributed by phasing17

                    

Javascript

// JavaScript program for the above approach
function bestFit(arr, n, W) {
  // Stores the required number
  // of bins
  let count = -1;
 
  // Sort the array in decreasing order
  arr.sort((a, b) => b - a);
 
  // Stores the empty spaces in
  // existing bins
  let M = new Set();
 
  // Traverse the given array
  for (let i = 0; i < n; i++) {
    // Check if exact space is
    // present in the set M
    if (M.has(arr[i])) {
      M.delete(arr[i]);
    } else {
      // Find the minimum element
      // greater than arr[i] in M
      let y = Array.from(M).find(x => x > arr[i]);
 
      // If upper bound of arr[i] is
      // present, use this space and
      // insert the left space
      if (y) {
        M.add(y - arr[i]);
        M.delete(y);
      }
      // Otherwise, increment the count
      // of bins and insert the
      // empty space in M
      else {
        count++;
        M.add(W - arr[i]);
      }
    }
  }
 
  // Print the result
  console.log(count);
}
 
// Test
let items = [4, 8, 1, 4, 2, 1];
let W = 10;
let N = items.length;
 
// Function Call
bestFit(items, N, W);
 
// This code is contributed by aadityaburujwale.

                    
Output:
2

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



Last Updated : 20 Jan, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads