An on-line algorithm for multidimensional bin packing

Operations Research Letters 13 (1993) 149-158 North-Holland

April 1993

An on-line algorithm for multidimensional bin packing Jfinos Csirik Department of Applied Computer Science, J6zsef Attila University, P. 0. Box 652, H-6701 Szeged, Hungary

Andrd van Vliet * Econometric Institute, Erasmus University Rotterdam, P. 0. Box 1738, 3000 DR Rotterdam, The Netherlands Received May 1991, revised March 1992

In this paper we present an on-line algorithm for the d-dimensional bin packing problem. We use the idea of rounding up the size of an item to a size that can be packed efficiently. Although our algorithm is not a generalization of the 1-dimensional HARMONICM algorithm [6], we can use its worst case analysis to prove that our algorithm yields an asymptotic worst case ratio of (1.691...)a. Further, we show that for uniformly distributed items the algorithm has an expected asymptotic efficiency of (2( ~-~ra _ l))a. bin packing; on-line algorithms; worst-case analysis; average case analysis

I. Introduction T h e d-dimensional bin packing p r o b l e m is as follows. W e arc given a list L = (a 1, a 2 . . . . . a n) of n items, which are d-dimensional (hyper-)rectangles. A n item a/ is of size (sl(a i) ...... sa(ai)) and si(a ~) satisfies 0 < sj(a i) <_ 1, 1 <_j <_d. W e have to pack these items in d-dimensional unit (hyper-)cubes, which we call bins, such that 1. each item is c o n t a i n e d entirely within its bin, with its sides parallel to the sides of the bin; 2. no two items in a bin overlap; 3. the orientation of the item is the same as the orientation of the bin. T h e objective is to minimize the n u m b e r o f bins used to do the packing. T h e d-dimensional bin packing p r o b l e m includes the 1-dimensional bin packing p r o b l e m as a special case. Since the p r o b l e m is N P - h a r d [4], research has focused on finding good approximate solutions. Given a list L, we d e n o t e the m i n i m u m n u m b e r of bins required to pack these items by O P T ( L ) . T h e n u m b e r of bins that an algorithm A uses to pack L will be d e n o t e d by A(L). T h e p e r f o r m a n c e of an algorithm A is m e a s u r e d by the asymptotic worst case ratio RA, which is given by R~ = lim sup | m a x ~

IOPT(L) = k

k ---~ce

A n algorithm is called an on-line algorithm if it packs the items in the o r d e r given by the list, without knowledge o f the subsequent items on the list. A n algorithm that is not on-line will be called off-line. In this p a p e r we will be c o n c e r n e d only with algorithms that are one-line. * T h e author was supported by T E M P U S mobility grant 115-90.

Correspondence to: J. Csirik, D e p a r t m e n t of Applied Computer Science, J6zsef Attila University, P.O. Box 652, H-6701 Szeged, Hungary. 0167-6377/93/$06.00 © 1993 - Elsevier Science Publishers B.V. All rights reserved

149

Volume 13, Number 3

OPERATIONS RESEARCH LETTERS

April 1993

Earlier work on on-line algorithms for the 1-dimensional bin packing problem includes the Next-Fit [5], First-Fit [5] and H A R M O N I C M [6] algorithms, which yield asymptotic worst case ratios of 2, 1.7 and 1.691..., respectively. The best on-line algorithm for the 1-dimensional bin packing problem is due to R a m a n a n et al. [9] and yields 1.612 . . . . Liang [8] showed that no on-line algorithm can have an asymptotic worst case ratio better than 1.536 . . . . Recently, Van Vliet [10] improved this lower bound to 1.540 . . . . In higher dimensions, few results are known. Coppersmith and Raghavan [1] gave an on-line algorithm for two (three) dimensions that yields an asymptotic worst case ratio of 3.25 (6.25). Csirik et al. [2] improved that algorithm to yield an asymptotic worst case ratio of 3 1 in two dimensions. A non-trivial lower bound for on-line algorithms in two dimensions is given by Galambos [3]: 1.802 . . . . So, unlike the 1-dimensional case, there is still a wide gap between the best known algorithm and the lower bound for on-line algorithms in the 2-dimensional case. We expect that on both sides of this gap further improvements can be made. We present an on-line algorithm R O U N D d for the d-dimensional bin packing problem, which yields an asymptotic worst case ratio of (HM)d, where H M is the asymptotic worst case ratio of the 1-dimensional H A R M O N I C M algorithm. W h e n we take the p a r a m e t e r M large enough, H M goes to 1.691 . . . . Like Coppersmith and Raghavan [1], we use the idea of rounding up the size of an item to a size that can be packed more easily. It appears that our rounding scheme is such that we can use the analysis by Lee and Lee [6] of their H A R M O N I C M algorithm for the worst case analysis of R O U N D d. We emphasize that our algorithm is not a generalization of the H A R M O N I C M algorithm. It can be shown that a generalization to higher dimensions of the H A R M O N I C M algorithm may yield the same asymptotic worst case ratio, but that it will use a much larger constant number of bins than our algorithm does.

2. The algorithm R O U N D d The algorithm R O U N D ~ takes an integer p a r a m e t e r M which should be at least 2. We consider M subsets of (0, 1], which are as follows: Z 1 = {1},

Zm=((½)k/mlk~}

for m = 2 and m = 3 , 5, 7 . . . . . ( 2 M -

3).

Further, we let Z = Z 1 U Z 2 U ( u M 3 Zzj_3). For a real number x ~ (0, 1], we define 2 = minz{Z I z Z, z > x}. We say that x is rounded up to ~. We will call a rectangle r a rectangle of type Tj, 1 _ j . Further, a rectangle is of type T o if it is a unit hypercube. The algorithm proceeds as follows. Every item a i will be placed in a rectangle a i of size ( s l ( a i ) . . . . . Sd(ai)). The remaining space in such a rectangle will not be used further and we call this wasted space. These rectangles a i will be packed together into bins, according to rules given later. Because of the special size of these rectangles, this can be done efficiently. The space in a bin that is left over after packing these rectangles a i is called unused space. During the (on-line) packing of the items, we have a set U which contains all unused spaces in already opened bins. At every moment, U contains only rectangles u with sj(u) ~ Z for every j. We partition U into d + 1 disjoint subsets U o . . . . . JUa, where Uj contains the elements u ~ U that are of type Tj. Note that U0 is always empty (U does not contain empty bins). We start with U = ¢ and no items packed. When we need a rectangle a-~ into which to place item ai, we make a request for an element u ~ U of size ( s l ( a i ) . . . . . Sd(ai)). If such an element u ~ U is present, the request is fulfilled immediately. We can place item a i in rectangle u and delete u from U. If such an element is not present and a i is of type. T~, we will either break down an element u ~ Uj into smaller rectangles, or request an element u ~ u ],2bUk which we can break down into smaller rectangles. In both 150

Volume 13, Number 3

OPERATIONS RESEARCH LETTERS

April 1993

cases, this element u should be such that Sk(U)=Sk(ai) for every 1 < k < j and that s/(u) is an appropriate multiple of st(a i). In this way, we create an unused rectangle of size (sl(a i) ..... Sd( a i)) by making at most d + 1 requests. We can place item a i and continue with the next item to be packed. We will now formalize the way we handle a request and explain how rectangles in U are broken down into smaller rectangles. Suppose that we have a request for a rectangle r of size ( S l ( r ) . . . . . Sd(r)). If r is of type T 0, we open a new bin and we have handled the request. Otherwise, suppose that r is of type ~ , 1 < j < d. We look for an element u ~ Uj such that Sk(U) = Sk(r) for every 1 < k < j and st(u) = 2 p * st(r) for minimal p > 0. We consider three possibilities: 1. There is a u ~ Uj satisfying the above condition with p = 0. Our request is fulfilled immediately. 2. Such a u ~ Uj exists and p is greater than 0. We break down this rectangle of size (sl(r) ..... sj_l(r), sj(r)*2 v, 1 . . . . ,1) into rectangles of size ( s l ( r ) . . . . . sj_l(r),

sj(r)*2 v-l,

1,...,1)

(s,(r) ..... si_x(r ),

s~(r)*2 p-z,

1 . . . . . 1)

(sl(r),...,sj_l(r),

sj(r)*2,

1,...,1)

( s l ( r ) . . . . . sj_,(r),

sj(r),

1 .....

(s,(r) ..... s/_,(r),

sj(r),

1,...,1)

1)

and use one rectangle of size (sl(r) . . . . . Sj_l(r), sj(r), 1 . . . . . 1) to fulfil the request. 3. No such u ~ Uj exists. We request a rectangle in U k=0~k j - 1 rr which is of size (sl(r), .. ., s t_ l(r), 1, 1,.. ., 1) and, if sj(r)~ Z m, we break it down into m rectangles of size (sl(r),..., Si_l(r), 1/m, 1 , . . . , 1). If st(r) = 1/m, we can fulfil the request as in 1. Otherwise, st(r) = 2-V/m for some p > 0 and we can proceed as in 2. An example of how the algorithm proceeds is given in Figure 1. The complexity of the algorithm depends on the n u m b e r of unused rectangles in U. If we implement the algorithm according to the above description, then this number can be arbitrarily large for lists containing infinitely small items. Therefore, we have to make the following adjustment to the algorithm. We store the p unused rectangles ( S l ( r ) . . . . . Sj_l(r),sj(r)*2 p-l, 1. . . . . 1 ) . . . ( s l ( r ) . . . . . Sj_l(r), sj (r), 1. . . . . 1) that arise in case 2 as one compound rectangle of size (sl(r) . . . . . Sj_l(r) , s j ( r ) * ( 2 p 1), 1. . . . . 1). Later, we can split this compound rectangle into 2 smaller compound rectangles and an ordinary rectangle that we need to fulfil a request. Let m max = 2 if M = 2 and m max = 2 M - 3 if M > 3. For every item, we can have at most d requests that generate new unused rectangles. As each request can generate at most m max unused (compound) rectangles, it follows that the total number of rectangles in U is bounded by mmaXnd. Further, as we can search for unused rectangles in logarithmic time and since we can work with the compound rectangles without adding extra complexity, the overall complexity of the algorithm R O U N D d will be O(n log n).

3. Worst case analysis of ROUNDer First, we will show how the total unused space due to this packing is bounded. We write the total area of unused space as d

d

J

E FI sk(u) = E E E sk(u)

u~U k=l

j=l u~Uy k=l

151

Volume 13, Number 3

OPERATIONS RESEARCH LETTERS

April 1993

d

= E j=l

j

E .. II~Z

E

E

FI sk(u)

I / _ I ~ Z u~Uj: sl(u)=l 1. . . . . sj_l(u)=l/_l

k=l

d

= E

E 11...

j=l IlEZ

E lj_l~Z

lj-1

E

Sj(U).

uEUuj: Sl(U)=l I . . . . . Sj_l(U)=lj_ 1

W e r e m i n d t h e r e a d e r t h a t w e t a k e p m i n i m a l as we b r e a k d o w n a r e c t a n g l e o f size ( s l ( r ) , . . . , sj_l(r), sj(r)*2 p, 1 , . . . , 1) i n t o s m a l l e r r e c t a n g l e s . T h u s , w h e n we l o o k at r e c t a n g l e s u ~ Uj satisfying Sl(U) = l 1. . . . , sj_l(u) = lj_ 1, w e see t h a t a r e c t a n g l e u w i t h sj(u) = (1)k/m for s o m e m > 2 a n d

1. item of size ( 0.30, 0.20 ): requests ( 1/3, 1/4 ) --+ ( 1/3, 1 ) ~ ( 1, 1 )

*_____.*_____ 2. item of size ( 0.14, 0.14 ): requests ( 1/6, 1/6 ) --* ( 1/6, 1 ) m

m

*__ *______

3. item of size ( 0.70, 0.40 ): requests ( 1, 1/2 ) --+ ( 1, 1 )

m

"i 4. item of size

0.35, 0.40 ): requests ( 1/2, 1/2 ) --~ ( 1/2, 1 ) --~ ( 1, 1 )

I

~

*__ *_____

* : unused rectangle E U1

** : unused rectangle E Uz

Fig. 1. Example of a packing of 2-dimensional items (M = 3) 152

I

Volume 13, N u m b e r 3

OPERATIONS RESEARCH LETTERS

April 1993

some k > 0 can occur at most once if k > 1 and at most m - 1 times if k = 0. This gives us for every m > 2 that

E

sj(u) < 1

u ~ U j : s ~ ( u ) ~ Z and Sl(U)=l I . . . . . Si_l(U)lj_ l

and thus E 5(u)
1.

When we define c M to be equal to M

1

E t = 2 + 2 E 2j-3' j=3

I~Z

we get d

E

d

1--I s k ( u ) < E (CM)J-I( M -

1)

j=l

u~U k=l

d-1

= (M-

l) E (CM) j j=0 (CM) d - 1

=(M-l)

CM - 1

We note that, because of c M < M , this number will be smaller than or equal to M a - 1. Second, we will show how large the total area of the rectangles ~i, denoted by ~ is in proportion to the optimal number of bins. For this, the analysis by Lee and Lee [6] will be used. We consider a partition of the interval (0, 1] into M disjoint sub-intervals: ( Im

=

1 m+l'm

1] -

for 1 < m < M ---

1,

Further, for every number x ~ (0, 1] we define the fraction function gM(X) as 1

gM(X) = -

m

xM - - M-1

ifxeIm,

l
if x ~ I M .

We note that 2 =gM(X) if X e I n , 1 < m < M - 1 and ~_
g d ( r ) = I'-I g M ( s k ( r ) ) • k=l

We define ,2ad to be the set that contains all lists of d-dimensional rectangles that can be packed together in a d-dimensional unit cube. For every L ~-~d, we define G a ( L ) = F,r~LgdM(r) and we let GdM = SUPL~_~GdM(L). It is then easy to verify that for an arbitrary list L ,xT(L) < GdMOPT(L ) . 153

Volume 13, Number 3

OPERATIONS RESEARCH LETTERS

April 1993

We now consider the series t~, which is defined as t 1 = 1 and t i = ti_l(ti_ 1 + 1)

for i > 2.

With this series, Lee and Lee [6] give an expression for ~'d in the 1-dimensional case. Theorem 1 (Lee and Lee). For i > 1, t i < M < t i + l , i

1

E-+ y=l tj

M

t i + l ( m - 1) "

Proof. See Lee and Lee [6]. We will now first prove the following result, which is quite similar to a result of Li and Cheng [7] in their paper on 3-dimensional strip-packing. Lemma 2. Let L = (r 1. . . . . rn) be a list of d-dimensional rectangles, and let Q be a packing which packs these rectangles into a d-dimensional unit cube. Suppose that there is a list L ' = (r~ .... , r') with sy(ri')= gM(sj(ri)), 1 < i < n, 1 < j < d. Then there exists a packing Q' which packs L' into a cube of size fir1. Proof. We will use a d-dimensional coordinate system to indicate where a rectangle is positioned in a bin. The left-lower corner of the bin is indicated by ( 0 , . . . , 0) and the coordinates (ql(ri) . . . . . qd(ri)) give the left-lower corner of r i in packing Q. The region in the bin that is covered by r i is given by

R(ri) = [ql(ri), ql(ri) + sl(ri)] × . . . × [qd(ri), qd(ri) + sd(ri)] and dim(R) denotes the dimension of some region R. Of course, dim(R(ri)) = d. For a packing to be feasible, it must satisfy two conditions. First, the regions R(r i) and R(r k) may not overlap for every i 4= k, which means that

dim(R(ri) N R ( r k ) ) < d - 1. Second, each region R(r i) must be contained within the bin. This means that

qk(ri) > 0 and qk(ri) +Sk(ri)
1, q(j-1)(r~-l))

+ sj(r~ "-1))

=q}J-')(r~iJ-1))}. Without loss of generality, we can assume that either O(r~ ~- 1)) ÷ 0 or q}J-1)(r~J-1)) = 0 (otherwise, we can move r~j - 1) to the left in the j-th dimension until one of these conditions is true). 154

Volume 13, Number 3

O P E R A T I O N S R E S E A R C H LETTERS

April 1993

We now let the left-lower coordinates of the items r[ j) ~ L (j) in packing Q(J) take the value '0

if J2(r[ j - l ) ) = ¢ ,

q}J'(r~J)) =

j j {qj(rm) +sj(r~)}

max t, m: r ~ - l ~ g ~ ( r /

otherwise,

1)

q(kJ)(r~ j)) = q~J-')(r~ j - ' ) ) We note that these calculations can be sets S2(r[J- l)). We have to show that this packing packing Q(J) ensures that the regions only in the j-th dimension, we merely

for k :~j. done easily in a directed graph with n nodes and arcs given by the Q(J) is also feasible. It is easy to see that the construction of the R(r[ j)) will not overlap. Further, because we have made changes need to verify that

q~J)(r[ j)) + sj(r[ j)) < C ~ for all r i(D . Suppose that there is an r i(D' that violates this condition. Then, we can find a chain (:) ()) < r i , . . . . r i , r i()) such that r i(j- 1)(~ Y2(r i(J- 17) , l _ m _ k - GM, and this is in contradiction with the definition of G M, since Em= ~s:(r~,) < 1. With this lemma, we can prove the following theorem. T h e o r e m 3. C a =

(C~) d

Proof: The case d = 1 being trivial, we assume d > 2. First, we will show that C a < ( G 1 ) a. Suppose that we have a list of items L = (r~ . . . . . r,) that can be packed into a unit cube, and we have the list L' = ( r ' , . . . , r ' ) with sj(ri') = gM(s:(ri)), 1 < i < n, 1 < j < d. Then, according to Lemma 2, list L' can be packed into a cube of size C 1. Thus, for every list L that can be packed into a unit cube, we have that d

G~(L)=

--1

]~ I - ' - [ g M ( s j ( r ) ) < _ ( G M )

d

rEL k = 1

This means among others that CaM < ( C ~ ) a. Next, we have to prove that C a > ( G 1 ) a. By the definition of C ~ , we know that for every ~ > 0 there exists a list of 1-dimensional items L = (x~ . . . . . x~) such that Y'.n ,=1 x i <_l and G ~ t ( L ) > G ~ t - ~ p. We construct a list L' which contains n d items of the following sizes

(x, .... ,x,,x,)

(x, .....

(X ......

(X ......

X n Xl)

X n , X2)

""

( x , . . . . . Xl, X.)

"'"

(X .....

,Xn'

Xn)

This list can be packed into a d-dimensional unit cube and G'~ > G ~ ( L ' ) = ( G I ( L ) ) d >

( G ~ t - q~)d_> ( G--1M ) d -- d(Z)d-'q~

because of C~t < 2. As we can take q~ arbitrarily small, G-a M > ( ~ l ) d will hold.

[]

Finally, we can give the main theorem that follows from the discussion above. T h e o r e m 4. L e t c M = 2 + 2F~_31/(2j - 3), a n d CaM = ( M - a)((CM) d -- 1)/(C M -- 1). Then, f o r every list L o f d-dimensional rectangles

ROUND

--1

d

(L) _< (GM) O P T ( L ) +

Values of the asymptotic worst case ratios and the constants for different values of M are given in Table 1. 155

Volume 13, Number 3

OPERATIONS RESEARCH LETTERS

April 1993

4. Worst-case example The bound on the performance of R O U N D d , given in Theorem 4, can be shown to be a tight bound for certain values of M. Theorem 5. If M = tk+ 1 for some k > 1, then the asymptotic worst case ratio of ( ~ l )d is tight. Proof. It is sufficient to show that there is a list of 1-dimensional items Lp = (y~ .... , yp), which satisfies Y~P= 1 Yi = 1 and limp_~= ~'~P=1 Yi = ~ 1 . Then, we can create a list L~ of pd d-dimensional items of the following sizes: (Yl .....

Yl, Yl)

( Y v , " ' , Yp, Y l)

(Yl .....

Yl,

Y2)

( Yp . . . . . Yp, Y z)

Yv)

"'"

(YI,...,Y,,

"'"

( Yp . . . . . Yp, Yv)

Repeating this list L v enough times will then give a bad list for the R O U N D d algorithm. We let p = 2 n + k - 1 and define ~on = 1/(4ntk+l). Suppose that the first k items have size Yi = 1/(ti + 1) + ~on/k and that the remaining 2 n - 1 items have size yy = 1/(2~tk+O + ~ . Then 1 -ti

for l _ < i _ < k ,

~i=

1 2n(tk+l -- 1)

for k + l < i <_p.

This gives p k 1 1 ~_,yi = Y ~ - - + ( E n - - 1 ) - - + E n ~ o n i=1 i = l ti + 1 2ntk+l

k 1 = ~,--+ i=l t i + 1

1 =1

tk+l

and P EY/=

i=1

k 1 2~-1 E M 7 +- 12"() ' i

1 G1

i=1

Taking limits yields limp_~= E~=l Y-~= E l -

2"(M-

1) "

[]

Table 1 Asymptotic worst case ratios and constants for d = 1, 2, 3 M

G'~

G',~

~,3

C~

C2

C3

2 3 4 5 6 7 8 9 10 11 12 42 1806

2.0000 1.7500 1.7222 1.7083 1.7000 1.6944 1.6939 1.6935 1.6931 1.6929 1.6926 1.6911 1.6910

4.0000 3.0625 2.9660 2.9184 2.8900 2.8711 2.8692 2.8678 2.8667 2.8658 2.8650 2.8597 2.8596

8.0000 5.3594 5.1082 4.9856 4.9130 4.8650 4.8601 4.8565 4.8536 4.8513 4.8495 4.8359 4.8356

1.00 2.00 3.00 4.00 5.00 6.00 7.00 8.00 9.00 10.00 11.00 41.00 180.50 * 101

3.00 7.33 12.20 17.41 22.87 28.54 34.37 40.35 46.45 52.67 58.98 273.76 188.84" 102

7.00 21.56 40.41 62.36 86.76 113.20 141.40 171.15 202.30 234.70 268.25 159.52" 101 180.48 * 103

156

Volume 13, Number 3

OPERATIONS RESEARCH LETTERS

April 1993

5. Average case analysis

Let us suppose that the items of list L = ( a t, a 2 , . . . , a n) are independent and uniformly distributed in the interval (0, 1]a. For every z ~ Z, we define I z to be the interval containing all x with ~ = z. Further, we will call an item a i a (z 1.... , za)-type item if sj(a i) E l z j , 1 <_j <_d. Let kz~,z 2...... ~ be the number of ( z I . . . . , z a ) - t y p e items. Then d

E(kz,,z2 .....

= n FI II jl j=l

where Iiz, I is the length of interval I~; Because a (z~ ..... za)-type item will be placed in a rectangle of size (z~ . . . . , z a) and these rectangles can be packed together with a total unused space of at most C~t, for the expected number of bins used by ROUNDer we get that d

E

E nI-IzjIIz I<-E(ROUND (L))<- E

zt~Z

zd~Z j=l

E nrIzjlI l+c ,

zl~Z

ZdEZ j = l

with

E z liz, I

z~Z

=

j=l

J

+E

j+l

E

k=Oj=M-I

=M~2(l_l

1 )

~ (l)k2M-3

J + J-F'---~ + Y O

j=l lJ 2

2k(J +1)

2kJ

"41

(1

1 3 ~j=M-t j2

1 )

1 -~ -- -- + J'{- 1

1 = j=t Y'~ j-:2 - 1 + M- - + 1-

1

2kJ

1 )

M _ ~ + 2-M - 2 "

this yields E(ROUND~(L)) lim n-~Oo

n

(M~21 =

kj=l

4 2~-3 1

J - 2 q - - 3 j - M - I ;2

Since the optimal solution will (on average) take at least asymptotic efficiency of

n/2 a

1

)2.

1+3(M--l) bins, the ROUND d algorithm has an

4 2MM~3 1 1 )a. j=l j~- + 3 1 : -t j ~ - - 1+ 3 ( M - 1)

(M~21 2

AS M --+ 0% this expression goes to (2(Y'.7=1 ] / j 2

_

1))d, which is equal to (2(6'-~-2 - 1))~.

References [1] D. Coppersmith and P. Raghavan, "Multidimensional on-line bin packing: Algorithms and worst-case analysis", Oper. Res. Lett. 8, 17-20 (1989). [2] J. Csirik, J.B.G. Frenk and M. Labbe, "Two dimensional rectangle packing: On-line methods and results", Report 9079/A, Econometric Institute, Erasmus University Rotterdam, Rotterdam, The Netherlands, 1990. [3] G. Galambos, "A lower bound for on-line algorithms for the two dimensional rectangle bin packing problem", unpublished manuscript 1990. [4] M.R. Garey and D.S. Johnson, Computers and Intractability: A Guide to the Theory of NP-completeness, W.H. Freeman & Co, San Francisco, CA, 1979. 157

Volume 13, Number 3 [5] [6] [7] [8] [9] [10]

158

OPERATIONS RESEARCH LETTERS

April 1993

D.S. Johnson, "Fast algorithms for bin packing", Comput. System Sci. 8, 272-314 (1974). C.C. Lee and D.T. Lee, "A simple on-line bin packing algorithm", J. A C M 32, 562-572 (1985). K. Li and K.H. Cheng, "Heuristic algorithms for on-line packing in three dimensions", unpublished manuscript, 1990. F.M. Liang, "A lower bound for on-line bin packing", Inf. Proc. Lett. 10, 76-79 (1980). P. Ramanan, D.J. Brown, C.C. Lee and D.T. Lee, "One-line bin packing in linear time", J. Algorithms 10 305-326 (1989). A. Van Vliet, "An improved lower bound for on-line bin packing algorithms", to appear in Inf. Proc. Lett.