BIN PACKING PROBLEM: A LINEAR CONSTANTSPACE -APPROXIMATION ALGORITHM

International Journal on Computational Science & Applications (IJCSA) Vol.5,No.6, December 2015
DOI:10.5121/ijcsa.2015.5601 01
BIN PACKING PROBLEM: A LINEAR CONSTANT-
SPACE
૜
૛
-APPROXIMATION ALGORITHM
Abdolahad Noori Zehmakan
Department of Computer Science, ETH University, Zurich, Switzerland,
ABSTRACT
Since the Bin Packing Problem (BPP) is one of the main NP-hard problems, a lot of approximation
algorithms have been suggested for it. It has been proven that the best algorithm for BPP has the
approximation ratio of
ଷ
ଶ
and the time order of ܱ(݊), unless ܲ = ܰܲ. In the current paper, a linear
ଷ
ଶ
-
approximation algorithm is presented. The suggested algorithm not only has the best possible theoretical
factors, approximation ratio, space order, and time order, but also outperforms the other approximation
algorithms according to the experimental results; therefore, we are able to draw the conclusion that the
algorithms is the best approximation algorithm which has been presented for the problem until now.
KEYWORDS: Approximation Algorithm, Bin Packing Problem, Approximation Ratio, NP-hard.
1.INTRODUCTION
Similar to other optimization problems, the BPP is included among NP-hard problems. In recent
years, several attempts have been made to solve this problem with the approximation approaches
[1]. The problem comprises many real-world applications; for instance stock-cutting, loading
trucks, railway carriages, and etc. As this problem is NP-hard, a lot of approximation algorithms
have been presented for it. In this paper, we also present an approximation algorithm which
performs so efficiently, both in practice and in theory.
In the Bin Packing Problem, n items were given with specified weights ܽଵ, ܽଶ, … , ܽ௡ such that:
0 < ܽଵ ≤ ܽଶ ≤ ⋯ ≤ ܽ௡ < 1
With the purpose of packing the objects in the minimum number of bins and ensuring that the
sum of the objects’ weights does not exceed the bin capacity in any bin.
The BPP is similar to a decision problem called the Partition Problem. In the Partition Problem,
we are given n positive integersܾଵ, ܾଶ, …,ܾ௡ whose sum B=∑ ܾ௜
௡
௜ୀଵ is even and the purpose is to
know if the partition of the set of indices {1, 2, …, n} into sets S and T such that∑ ܾ௜௜∈ௌ =
∑ ܾ௜௜∈் , is possible. The partition problem is well-known to be NP-complete.
In recent years, different versions of the problem like two and three-dimensional BPP [2, 3],
fragile objects [4], extendable bins [5], and controllable item sizes [6] have been discussed. On
the other hand, the basic problem consists of two main versions named on-line and off-line. In the

International Journal on Computational Science & Applications (IJCSA) Vol.5, No.6,December 2015
2
former, items are appeared without any knowledge about the sequence of them (neither the size
nor the number of the items). In the latter, all of the items are given at the initial part of problem
solving.
Simchi-Levi [7] proved that FFD(First Fit Decreasing), and BFD(Best Fit Decreasing) algorithms
have an absolute worst-case ratio of
ଷ
ଶ
. These algorithms’ time order isܱ(݊ log ݊). Zhang and
Xiaoqiang [1] provided a linear time constant-space off-line approximation algorithm with
absolute worst-case ratio of
ଷ
ଶ
. Moreover, they presented a linear time constant-space on-line
algorithm and proved that the absolute worst-case ratio is
ଷ
ଶ
. In 2003, Rudolf and Florian [8] also
presented an approximation algorithm for the BPP which has a linear running time and absolute
approximation factor of
ଷ
ଶ
. It has been proven that the best algorithm for BPP has the
approximation ratio of
ଷ
ଶ
and the time order of ܱ(݊), unless ܲ = ܰܲ[7]. Noori Zehmakan [9]
presents two approximation algorithms for this problem. The first one is a
ଷ
ଶ
-approximation
algorithm, and the second one is a modified (linear time) version of the FFD algorithm.
As mentioned, different approximation algorithms [10, 11] have been presented for the BPP
because of its importance. In this paper, anew creative algorithm with the best possible factors,
time order, space order, and approximation ratio is presented. Then, the proposed algorithm is
compared with the approximation algorithms with the best possible approximation factor and
time order (
ଷ
ଶ
, ܱ(݊)).
The reminder of the paper is divided into two sections. In the first section, the suggested
algorithm is presented and in the second one, the computational results are demonstrated and
discussed.
2.THE PROPOSED ALGORITHM
The inputs are separated into two different groups. The first one contains Small items or ܵitems
(the items that are not larger than 0.5) and the Large items or ‫ܮ‬items(the items that are larger
than0.5). The main idea of the algorithm is to put the inputs into ten equal ranges and try to match
the items in complementary ranges.
After classification items into ten equal ranges, the algorithm matches L items with S items and
creates new items and continues this procedure until finishing L items. Finally, it joins remaining
S items to each other.
Function ࡲ૚ ((‫,ݔ‬ ‫;))ݕ‬
Choose an item ܽ in (‫,ݔ‬ ‫;)ݕ‬
If((1 − ‫,ݕ‬ 1 − ‫)ݔ‬ is not empty)
Choose an item ܾ in (1 − ‫,ݕ‬ 1 − ‫)ݔ‬ at random& let ܿ = ܽ + ܾ;
If (ܿ ≤ 1)
Put ܿ in the appropriate range and remove ܽ, ܾ;
Return0;
ElseReturnܽ;

3
Function ࡲ૛ (ܽ, (‫,ݔ‬ ‫))ݕ‬
If((‫,ݔ‬ ‫)ݕ‬ is not empty)
Choose an item ܾ in (x,y) at random& letܿ = ܽ + ܾ;
Put ܿ in the appropriate range and remove ܽ, ܾ;
Return 1;
Functionࡲ૜()
For((‫,ݔ‬ ‫ݕ‬) = (0.5, 0.6); ‫ݔ‬ < 1.0, ; (‫ݔ‬ = ‫ݔ‬ + 0.1, ‫ݕ‬ = ‫ݕ‬ + 0.1))
While((‫,ݔ‬ ‫)ݕ‬ is not empty)
ܽ=( ࡲ૚( (‫,ݔ‬ ‫))ݕ‬
If ( ܽ = 0)
Continue;
Else
f=0 & i=1;
while ( g=0 & 1-y-i*0.1>0.0)
g=F2 (a, (1-y- i*0.1, 1-x-i*0.1))& i++;
If( 1-y-i*0.1<0.0)
bin-counter ++;
remove a;
Algorithm:
Read n inputs &classify them into 10 ranges(0, 0.1), (0.1, 0.2) … (0.9, 1);
F3()
For ((x, y)=(0.4,0.5); x ≥0.0; (x=x-0.1, y=y-0.1))
While((x,y) is not empty)
Choose two items ܽ, ܾ in (x,y) & letܿ = ܽ + ܿ;
Put c in the appropriate range and remove a,b;
F3();
In addition to the mentioned pseudo code, for the ease of comprehension, a different version of
the algorithm is also presented.

4
1-Read n inputs and classify them into 10 equal ranges (0.0, 0.1),…, (0.9, 1.0).
2- If there are no items in (0.5, 0.6) go to line 8.
3- Choose an item ࢇ in (0.5, 0.6). If there is at least anitem in (0.4, 0.5), choose an item ࢈ in it
randomly, and set ࢉ = ࢇ + ࢈. If ࢉ ≤ ૚, put it in the appropriate range as a new item and
remove ࢇ and࢈ and go to line 2.
4- If there is at least an item in (0.3, 0.4), choose an item b in it at random, and set ࢉ = ࢇ + ࢈,
put it in the appropriate range as a new item, removeࢇ and ࢈ and go to line 2.
5- If there is at least one item in (0.2, 0.3), choose an item b in it randomly and setࢉ = ࢇ + ࢈,
and put it in the appropriate range as a new item, removeࢇ and ࢈, and go to line 2.
6- If there is at least one item in (0.1, 0.2), choose an item b in it at random and set ࢉ = ࢇ + ࢈,
put it in the appropriate range as a new item, removeࢇ and ࢈, and go to line 2.
7- If there is at least one item in (0, 0.1), choose an item b in it randomly and set ࢉ = ࢇ + ࢈. If
ࢉ ≤ ૚, put it in the appropriate range as a new item and removeࢇ and ࢈ and go to line 2.
8- If there are not any items in (0.6, 0.7) go to line 9 else do steps 4 to 7 for this range.
9- If there are not any items in (0.7, 0.8) go to line 10 else do steps 5 to 7 for this range.
10- If there are not any item sin (0.8,0.9) go to line 11 else do steps 6 and 7 to the range.
11- If there are not any items in (0.9, 1) go to line 12 else do step 7 for this range.
12- If there are not any items in (0.4, 0.5) go to line 14.
13- Choose two items ࢇ and ࢈ in (0.4, 0.5) at random. Set ࢉ = ࢇ + ࢈. Put it in the appropriate
range as a new item and removeࢇ and࢈ and go to line 2.
15- Choose two itemsࢇ and ࢈ in (0.3, 0.4) randomly. Set ࢉ = ࢇ + ࢈. Put it in the appropriate
range as a new item and remove ࢇ and ࢈ and go to line 2.
17- Choose two items ࢇ and ࢈ in (0.2, 0.3) at random. Set ࢉ = ࢇ + ࢈. Put it in the appropriate
range as a new item and removeࢇ and ࢈ and go to line 2.
19- Choose two items ࢇ and ࢈ in (0.1, 0.2) randomly. Setࢉ = ࢇ + ࢈. Put it in the appropriate
20- If there are not any items in (0, 0.1) go to line 22.
21- Choose two items ࢇ and ࢈ in (0, 0.1) randomly. Set ࢉ = ࢇ + ࢈. Put it in the appropriate

5
22- End.
The state which there is only one S item in the range taken into consideration has been ignored in
steps 13, 15, 17, 19 and 21forthe ease of algorithm's comprehension, but definitely, it cannot be
ignored in the complete form.
The algorithm attempts to match each ‫ܮ‬item with the best possible ܵitem and creates bins with
the least free space. Obviously, the proposed algorithm's time order is ܱ(݊) in that in each step,
the algorithm eliminates two items and creates a new one, and the process of each step is done in
at most k time unit. Thus, its time order equals to ܱ(݇݊), and k isa constant; therefore, the
suggested algorithm is a linear time one.
We have proved that the approximation ratio of the algorithm is
ଷ
ଶ
, and interested reader can find
the exact and complete proof in [12]. Actually, since the proof is so long, we have presented this
proof as a distinct document on arXiv. We present a sketch of the proof in this paper, and the
complete and detailed proof is disregarded here inasmuch as the main purpose of this article is
discussing and comparing the results of the suggested algorithm with other algorithms, both in
theory and in practice.
Definition1: An output bin is named an L pack if it contains one‫ܮ‬ item, and it is called an S pack
if it has no L items.
Definition 2: ܲ is the number of output bins in OPT solution, and ܲ∗
is the number of output bins
in the proposed algorithm.
Two possible kinds of output bins (‫ܮ‬ pack and ܵ pack) are shown in figure 1.
Figure1: The states of the output bins in a OPT solution
Lemma 1: If at least
ଶ
ଷ
size of each output bin is full,
௉∗
௉
≤
ଷ
ଶ
.
Proof: Consider the worst state that all output bins are completely full in OPT solution, and
suppose that ܹ is the sum of size of input items. Then,
ܲ ≥ ܹ &ܲ∗
≤
ܹ
ଶ
ଷ
⇒ ܲ∗
/ܲ ≤
3
2
∎
Lemma 2: If all inputs are ܵ items, the ratio of ܲ∗
to ܲ is not more than
ଷ
ଶ
.

6
Proof: Based on the algorithm, items in(0.4, 0.5) will be matched with each other two by two and
create new items between 0.8 and 1.0.Then, these new items try to be matched with item
in(0, 0.1)or (0.1, 0.2). Afterward, each final created item will be put in one bin. Therefore, at
least 0.8 sizes of each output bin in this step is full.
After finishing the items in(0.4, 0.5), items in (0.3, 0.4) are joined together in binary and triad
groups. This range will be discussed at the end of this proof precisely.
Definitely, after the items in (0.3, 0.4), the items relevant to (0.2, 0.3) will be matched with each
other. Obviously, in this condition, there is no items in(0.3, 1.0). Two items from (0.2, 0.3)
arematched with each other and create a new item between 0.4 and 0.6. After that, the new
created item is matched with an item in(0.2, 0.3)and will make a new item. This process
continues up to a point that the created item becomes larger and larger. Finally, at least 0.7 of
each output bin’s size is full because the largest item of Small set in this step is 0.3.
Certainly, after finishing the items in (0.2, 0.3), no items exist between 0.2 and 1.0. Obviously,
with the mentioned logic for (0.2, 0.3)in this step alsoat least 0.8 size of each output bin is full
because the largest item of Small set is 0.2. In the next step, the remaining items are in (0, 0.1).
Definitely, in this step at least 0.9 of each output bin’s size is full because the largest item of
Small set is 0.1.
According to lemma 1, ranges (0, 0.1), (0.1, 0.2), (0.2, 0.3) and (0.4, 0.5) do not contradict the
claim that
௉∗
௉
is not larger than
ଷ
ଶ
, on the other hand (0.3, 0.4) can cause some problems because
this range is able to create bins that are smaller than
ଶ
ଷ
. In the worst-case, all items are in (0.3, 0.4)
because the total free space in output bins and the number of output bins in the algorithm will be
maximized. Even in this condition, ‫ ݔܽܯ‬ ቀ
௉∗
௉
ቁ =
ଷ
ଶ
because:
‫݊ ݁݉ݑݏݏܣ‬ = 3݉ ⇒ ܲ∗
≤
ଷ௠
ଶ
, ܲ ≥ ݉ ⇒ ‫ ݔܽܯ‬ ቀ
௉∗
௉
ቁ ≤
ଷ
ଶ
Theorem 1:The approximation ratio of the suggested algorithm is
ଷ
ଶ
.
Sketch of proof: First, four types of errors (error here means the deviation from OPT
solution)which are all possible types of the algorithm's errors are introduced,and if noerrors exist,
then the algorithm will result in optimal solution. Next, the algorithm with only error type1is
discussed and it is proved that the approximation ratio in this condition is
ଷ
ଶ
. Afterwards, other
types of errors are added one by one. Finally, it is proved that if all types of the errors exist, the
approximation ratio will be
ଷ
ଶ
, again. Note that in all steps we consider the worst condition.
Obviously, If
௉∗
௉
is never more than
ଷ
ଶ
, the approximation ratio is
ଷ
ଶ
.
The algorithm's possible errors:
1- An L item is matched with an S item which belongs to an S pack.
2- An L item is matched with an S item which belongs to an L pack such that the L item relevant
to the L pack and the first L item belong to the same range.

7
3- An L item is matched with an S item which belongs to an L pack such that the L item in this
pack belongs to a range except the range which the first L item is from.
4- Error in matching S items (both in S packs and L packs): S items are matched in a wrong
manner; it means that they are matched in a different way from the optimal solution.
Based on the algorithm an ‫ܮ‬item begins to pick up an ܵ item. The ‫ܮ‬item can make some possible
errors and pick up an ܵitem which belongs to an ‫ܮ‬ pack such that the ‫ܮ‬item of the ‫ܮ‬ pack and the
mentioned‫ܮ‬item belong to the same range (error type 2) or not (error type 3), It may pick up an
ܵitem from an ܵ pack (error type 1). Finally,ܵitemscan be matched with each other in a wrong
way (error type 4). The attempts will be made to maximize the errors in each step of the proof to
engender the worst condition. And it is observed in all states approximation ratio is
ଷ
ଶ
.
In some condition that depend on errors type 1, 2 and 3, it is shown
ଶ
ଷ
space ofall output bins are
full, and based on the lemma1
௉∗
௉
≤
ଷ
ଶ
. Moreover, in the situations that error type 4 happens based
on lemma2
௉∗
௉
≤
ଷ
ଶ
, again. Finally,by considering all types of errors together, it is proved that the
approximation ratio of the algorithm is
ଷ
ଶ
.
2.COMPUTATIONAL EXPERIMENTS
In this section, the suggested algorithm are compared with three other approximation algorithms
which enjoy the best possible theoretical criteria, approximation ration, time order, and space
order . This comparison has been drawn based on the eight standard data sets from OR-
LIBRARY[13].
For the comparison, we need a parameter which is strongly relevant to approximation ratio. The
Ratio is defined [9]as the proportion of the proposed algorithm's solution to the OPT solution.
Obviously, Ratio has a direct relationship with approximation ratio. Thus, Ratio can be utilized as
a factor for measuring approximation algorithms’ performances.
As mentioned, the standard data sets in OR-LIBRARY are used for simulations. Each data set
contains 20 input instances such that each input instance includes a bunch of items which are a
standard input for the Bin Packing Problem. Basedon the eight instances the suggested algorithm
has been compared with the Guochuan’s [1] and the Berghammer's algorithms [8]. The results of
these comparisons for ܾ‫݌‬௜ 1 ≤ ݅ ≤ 8are shown in figures ݆ 2 ≤ ݆ ≤ 9, respectively.

International Journal on Computational Science & Applications (IJCSA) Vol.5, No.
Figure2:The comparison ofR
Figure3:The comparison ofRatio of the algorithms for 20 input instances in data set bp2
International Journal on Computational Science & Applications (IJCSA) Vol.5, No.6,December
comparison ofRatio of the algorithms for 20 input instances in data set
The comparison ofRatio of the algorithms for 20 input instances in data set bp2
December 2015
8
s in data set bp1
The comparison ofRatio of the algorithms for 20 input instances in data set bp2

Figure4: The comparison of
Figure5: The comparison of
The comparison of Ratio of the algorithms for 20 input instances in data set b
: The comparison of Ratio of the algorithms for 20 input instances in data set bp4
December 2015
9
Ratio of the algorithms for 20 input instances in data set bp3
Ratio of the algorithms for 20 input instances in data set bp4

10
Figure6: The comparison of Ratio of the algorithms for 20 input instances in data set bp5

11
It is obvious that the performance of the proposed algorithm is much more acceptable than the
two other ones. Note that the mentioned approximation algorithms are only ones which have the

best possible approximation factor and ru
20 input instances relevant to the
relevant to each algorithm are joined by a line
The averages of the results for
figure 10.Obviously, the suggested algorithm performs much better than other ones in average.
Figure 10 shows that the proposed algorithm except in
Furthermore, it also shows that the performance of
the performance of Berghammer
Figure 10: The average of the algorithms' ratios
Figure 11 shows the results of comparing the suggested algorithm with
suggested algorithm has similar
input instances whose number of items are much more than others)
worse than FFD algorithm in bp1
ܱ(݈݊‫)݊݃݋‬in average andܱ(݊ଶ
algorithm. Furthermore, FFD is an online
constant-space one. It means that FFD
space order is much greater than the suggested algorithm.
performs much better than FFD
order is considerably better than FF
best possible approximation factor and running time. In each figure, the results are computed
the corresponding ܾ‫݌‬௜, but for the ease of understanding
algorithm are joined by a line in each figure.
The averages of the results for the eight data sets by the approximation algorithms
Obviously, the suggested algorithm performs much better than other ones in average.
Figure 10 shows that the proposed algorithm except in data setbp5 holds smaller ratios
shows that the performance of Guochuan's algorithm is more acceptable than
Berghammer's algorithm.
average of the algorithms' ratios for the eight data sets.
the results of comparing the suggested algorithm with FFD algorithm.
similar performances with FFD in instances bp4, bp6, bp7
input instances whose number of items are much more than others), but its performance is
bp1, bp2, bp3, and bp4. Note that FFD algorithm's time order is
ଶ
) in worst-case, but the proposed algorithm is
. Furthermore, FFD is an online-space algorithm, but the proposed algorithm is a
space one. It means that FFD saves all bins until the last step. Then, its time order and
space order is much greater than the suggested algorithm. Therefore, the suggested algorithm
performs much better than FFD, especially in big data-sets inasmuch as its time order and space
order is considerably better than FFD and enjoys more acceptable Ratios in big data
December 2015
12
In each figure, the results are computed for
understanding the points
the approximation algorithms are shown in
Obviously, the suggested algorithm performs much better than other ones in average.
holds smaller ratios.
more acceptable than
FFD algorithm.The
bp6, bp7, and bp8 (The
, but its performance is a little
that FFD algorithm's time order is
, but the proposed algorithm is a linear time
but the proposed algorithm is a
, its time order and
Therefore, the suggested algorithm
sets inasmuch as its time order and space
re acceptable Ratios in big data-sets.

Figure 11: The average of the suggested algorithm' ratios
Furthermore, this algorithm is also much considerably better than our previous algorithm [9]
inasmuch as this algorithm not only is linear time, but also performs much better in practice based
on the comparison of the experimental results.
In recapitulation, we can claim that the presented algorithm is the best approxima
for the BPP up to now in theory
4.THE ENHANCEMENT OF
In this section two ideas which can help
4.1.Creating more ranges
In the suggested algorithm, we consider ten ranges, but obviously, we can increase them in
number. For instance, see the ranges in figure 12.
Figure 11:Another possible ranging (using 20 equal ranges)
The algorithm can be executed with the new ranging, and i
be more efficient. For example, if the inputs are
algorithm utilizes 3 or 4 bins to pack all items in both state
3 bins for the algorithm in state of
the suggested algorithm' ratios and FFD algorithm's ratios for the
on the comparison of the experimental results.
recapitulation, we can claim that the presented algorithm is the best approxima
in theory and also in practice.
NHANCEMENT OF THE ALGORITHM
In this section two ideas which can help the algorithm to be enhanced are discussed.
ore ranges
number. For instance, see the ranges in figure 12.
Another possible ranging (using 20 equal ranges)
e executed with the new ranging, and it seems that this new algorithm must
more efficient. For example, if the inputs are 0.41, 0.47, 0.48, 0.59, 0.53
algorithm utilizes 3 or 4 bins to pack all items in both states, but the probability of exploiting just
orithm in state of new ranging is higher.
December 2015
13
the eight data sets.
recapitulation, we can claim that the presented algorithm is the best approximation algorithm
are discussed.
seems that this new algorithm must
and 0.52, the
probability of exploiting just

14
This procedure can be continued, and each range can be divided into two new equal ranges,
which will subsequently lead to 20, 40, 80, … ranges. The authors claim that by using the new
ranging the approximation ratio of the algorithm is still also 3/2, and its time order is linear too.
Obviously, the time order of the algorithm remainsܱ(݊) in this state. Moreover, the proof
relevant to approximation ratio can be generalized for the state of new ranging in that the ranging
does not impose any special restrictions on the proof.
Certainly, if the number of ranges is increased, the efficiency of the algorithm will be improved
because input items will be sorted more accurately. On the other hand, it is noticeable that the
number of ranges cannot depend on the number of inputs because in such case the time order of
the algorithm would not be linear anymore. Some constant numbers can be considered, and one
of them can be selected based on the number of inputs. For example, consider four possible
ranging (10 equal ranges, 80 equal ranges, 640 equal ranges, and 5120 equal ranges). Definitely,
two good choices for 20 and 390000 inputs can be 10 and 5120 equal ranges, respectively.
Therefore, it seems the algorithm by using this ranging method (for example, 20 ranges) usually
performs much better than the primary version. It is known that its performance is not worse than
the original one because it is a special state of the main algorithm. On the other hand, input items
are more sorted, and definitely, the new algorithm will perform more efficiently. For example,
consider three inputs‫,ݔ‬ ‫ݕ‬and ‫ݖ‬ that are in (0.4, 0.6).
0.5-0.55 (x) 0.55-0.6
0.45-0.5 (y) 0.4-0.45 (z)
The algorithm with 20 ranges will match ‫ݔ‬ and ‫ݕ‬with each other. Now, if‫ݔ‬ and ‫ݕ‬ are matched
with each other in OPT solution too, this method performs efficiently. If ‫ݔ‬ and ‫ݖ‬ are matched in
OPT solution, this method performs efficiently again because ‫ݖ‬ can be replaced by ‫ݕ‬ (‫ ݖ‬ ≤ ‫.)ݕ‬
On the other hand, the main algorithm will match ‫ݔ‬ with ‫ݕ‬ or ‫.ݖ‬ If ‫ݔ‬ and ‫ݕ‬ are matched with each
other in OPT solution and‫ݖ&ݔ‬ are matched in the main algorithm, the algorithm will not perform
optimally. In conclusion, the algorithm which uses the suggested ranging method usually acts
more efficiently than the main algorithm.
4.2.SCALING METHOD
Another idea that might make the algorithm more efficient is scaling. Based on the algorithm,
after finishing L items, S items are matched with each until finishing all input items. After
finishing L items, remaining items are between 0.0 and 0.5, but these ranges can be scaled to the
primary ranges (0.0 to 1.0). After that, some new L items will be created (We call them virtual L
items). These new items are matched with each other based on the suggested algorithm. This
procedure continues until all items are processed, meaning the scaling can be repeated several
times. These virtual bins (bins that are created through scaling) must be divided by 2୧
to create
main items (݅ is the number of times which we have done scaling until that step). Finally, after
dividing, the output bins will be matched2௜
by2௜
with each other and create final output bins.
Note, it is necessary to specify a boundary for the level of scaling unless this procedure can
continue lots of times.

15
For instance, suppose that we are given the following inputs.
Primary configuration: 0.4, 0.3, 0.3, 0.2, 0.2, 0.1
Based on the scaling method, these items will be scaled, and we have the following virtual
configuration.
Virtual configuration: 0.8, 0.6, 0.6, 0.4, 0.4, 0.2
According to the scaling method there will be the following virtual bins. Note ݅ = 1 in this step
because we have just done scaling once.
Virtual Output Bins: (0.6, 0.4), (0.6, 0.4), (0.8, 0.2)
Now, it is enough to divide all virtual bins by 2 (actually 2௜
such that ݅ = 1) to create new items.
After dividing, we will have the following items:
Output items after dividing: 0.5, 0.5, 0.5
Now, these item are matched 2 by 2 (actually 2௜
such that ݅ = 1), and then we have:
Bin 1 = (0.5, 0.5) = (0.4, 0.1, 0.3, 0.2)
Bin 2 = (0.5) = (0.3, 0.2)
Therefore, we need two bins to pack the items.
5.CONCLUSION
As we mentioned, BPP is a significant problem which is exploited in various fields and different
applications. Because of its NP-hard nature, lots of approximation algorithms have been
presented for it. In this paper, an approximation algorithm with the best possible theoretical
factors, linear time order, constant-space, and approximation ratio of 3/2, was presented. The
algorithm works based on dividing input items into ten equal ranges, and matching them with
each other in a special way.
Furthermore, the proposed algorithm, based on a standard library, were compared with three other
approximation algorithms which are the only algorithms which enjoy the best possible theoretical
factors. The results showed that the suggested algorithms considerably outperforms other
approximation algorithms previously presented for this problem in practice too.
Finally, we suggested two constructive ideas which could enhance the algorithm.

BIN PACKING PROBLEM: A LINEAR CONSTANTSPACE -APPROXIMATION ALGORITHM

More Related Content

What's hot (20)

Viewers also liked (17)

Similar to BIN PACKING PROBLEM: A LINEAR CONSTANTSPACE -APPROXIMATION ALGORITHM (20)

Recently uploaded (20)

BIN PACKING PROBLEM: A LINEAR CONSTANTSPACE -APPROXIMATION ALGORITHM