Question

In the bin packing problem, items of different weights (or sizes) must be packed into a finite number of bins each with the capacity C in a way that minimizes the number of bins used. The decision version of the bin packing problem (deciding if objects will fit into <= k bins) is NP-complete. There is no known polynomial time algorithm to solve the optimization version of the bin packing problem. In this homework you will be examining three greedy approximation algorithms to solve the bin packing problem.

                First-Fit: Put each item as you come to it into the first (earliest opened) bin into which it fits. If there is no available bin then open a new bin.

                First-Fit-Decreasing: First sort the items in decreasing order by size, then use First-Fit on the resulting list.

                Best Fit: Place the items in the order in which they arrive. Place the next item into the bin which will leave the least room left over after the item is placed in the bin. If it does not fit in any bin, start a new bin.

a) Randomly generate at least 20 bin packing instances. Summarize the results for each algorithm. Which algorithm performs better? How often? Note: Submit a description of how the inputs were generated not the code used to produce the random inputs.

Answer 1

Given that,

In the bin packing problem, items of different weights must be packed into a finite number of bins each with the capacity C in a way that minimizes the number of bins used. There is no known polynomial time algorithmo to solve the optimization version of the bin packing problem.

Program:

#include<iostream>
using namespace std;
void swapping(int &a,int &b){
int t=a;
a=b;
b=t;
}
int partitioned(int arr[],int l,int h){
int p=h,i=l,j=l-1;
while(i<p){
if(arr[i]>arr[p]){
j++;
swapping(arr[i],arr[j]);
i++;
}
else{
i++;
}
}
j++;
swapping(arr[p],arr[j]);
return j;
}
void quicksort(int *a,int low,int high){
int pivot;
if(low<high){
pivot=partitioned(a,low,high);
quicksort(a,low,pivot-1);
quicksort(a,pivot+1,high);
}
}
int firstfit(int arr[] ,int size ,int capacity){
int bin[size];
for(int i=0;i<size;i++)bin[i]=capacity;
bin[0]-=arr[0];
int j=0,k;
for(int i=1;i<size;i++){
for( k=0;k<=j;k++){
if(bin[k]>=arr[i]){
bin[k]-=arr[i];
break;
}
}
if(k==j+1){
j++;
if(bin[j]>=arr[i]) bin[j]-=arr[i];
}
}
return j+1;
}
int main(){
int t,n,c;
cin>>t;
int j=1;
while(j<=t){
cin>>c>>n;
int arr[n];
for(int i=0;i<n;i++)
cin>>arr[i];
cout<<"testcase "<< j <<" : ";
cout<<"FirstFit : "<<firstfit(arr,n,c)<<" ";
quicksort(arr,0,n-1);
cout<<"FirstFitDecreasing : "<<firstfit(arr,n,c)<<"\n";
j++;
}
return 0;
}