Guntram Scheithauer. Dresden University of Technology. Abstract: In this paper we consider the three-dimensional problem of optimal

Transcription

1 Operations Research Proceedings 1991, Springer-Verlag Berlin Heidelberg (1992) 445{452 Algorithms for the container loading problem Guntram Scheithauer Dresden University of Technology Abstract: In this paper we consider the three-dimensional problem of optimal packing of a container with rectangular pieces. We propose an approximation algorithm based on the "forward state strategy" of dynamic programming. A suitable description of packings is developed for the implementation of the approximation algorithm, and some computational experience is reported. Zusammenfassung: Zur naherungsweisen Losung von Containerbeladungsproblemen wird ein allgemeiner Algorithmus, der auf der "Forward State Strategy" der Dynamischen Optimierung basiert, vorgestellt. Eine fur die Implementierung passende Darstellung von teilweisen Packungen wird entwickelt und Ergebnisse einiger Testrechnungen werden angegeben. 1 Introduction and Problem Formulation The eective employment of capacity gets a more and more increasing importance in many problems of production and transportation planning. The reasons in transportation are e.g. the enlarging trade and growing transportation costs. In many cases the eective loading of cars, trails, trucks or ships can be modeled as a three-dimensional packing or container loading problem, i.e. as a problem of optimal allocation of rectangular pieces (boxes) within a container. There are to distinguish two kinds of problems. The rst problem has the objective to nd an allocation of boxes having maximal valuation sum of the allocated boxes or, equivalently, minimal waste. The second problem contains the calculation of the minimal number of identical containers or a minimal (in a given sense) subset of dierent containers required to pack all given pieces. For both problems the terms "packing" and "loading problem" are used in the literature. The aim of this paper is to propose an approximation algorithm for the socalled Container Loading Problem (CLP), i.e. the three-dimensional problem 1

2 of the rst kind. Further on, remarks are given on an implementation of the approximation algorithm on a PC computer. At rst we briey review some of the work connected with the CLP. In the one-dimensional case the CLP reduces to the well-known Knapsack Problem. The Knapsack Problem is one of the most investigated problems because of its simple structure and the fact that the main diculties of discrete optimization problems are contained in the Knapsack Problem. A review of literature and algorithms is given by Dudzinski and Walukiewicz (1987). The second kind of the one-dimensional problem is called Loading (Eilon and Christofides (1971)) or 0/1 Loading Problem (Ingargiola and Korsh (1975)). In both papers exact solution algorithms are described and a heuristic procedure is given. For the two-dimensional case of the CLP there exists a large number of publications. Most of them are related to the Cutting Stock Problem. Dyckhoff (1988) investigates relations between Cutting, Packing and other problems and introduces a typology of such problems. Here we only state some of the fundamental papers. In the beginning of the sixties Gilmore and Gomory (1961, 1963, 1965) considered the problem of computing optimal guillotine cutting patterns. The proposed algorithms are based on recursion formulas of dynamic programming. Beasley (1985) gave a 0/1 model for the general two-dimensional (nonguillotine) problem. But his exact solution algorithm does not seem to be usable for problems of medium size because of the rapidly growing number of variables and constraints. A further problem under investigation is the so-called Pallet Loading Problem, e.g. due to K.Dowsland (1984, 1987). But here only identical pieces are to be packed on a pallet. A translation of Beasley's 0/1-model of computing optimal patterns to the three-dimensional case is possible in a straightforward way. Indeed, the number of 0/1-variables and constraints increases much more faster as in the twodimensional case. Therefore, a practical application does not seem likely. As stated by W.Dowsland (1985) there is only a small number of published work with respect to the three-dimensional case. One reason for it may be the commercial aspects. The three-dimensional problem considered by Sculli and Hui (1988) is more oriented on testing of several strategies of packing and unloading of a container with identical boxes. Haessler and Talbot (1989) reduce the three-dimensional problem considered to a two-dimensional one by dening stocks of pieces which use the height of the container in a sucient good manner. Moreover, questions of meeting demand quantities are discussed there. Schneider (1988) proposes an algorithm for a special three-dimensional guillotine cutting problem which is not usable for the general CLP. 2

3 Some references related to three-dimensional problems and many for the cutting stock problem can be found in Terno, Lindemann and Scheithauer (1987). It is well known that the Knapsack Problem belongs to the NP-hard problems, hence the CLP also does. Therefore, it is necessary to look for good approximation algorithms. As a measure of quality we would like to have performance bounds on the ratio of the values obtained by the approximation algorithm and an optimal algorithm (as for the bin packing algorithms). But the three-dimensional bin packing algorithm considered by Scheithauer (1991) does not correspond in a good manner to a practical allocation of pieces and has no good performance bound. Summarizing, there do not exist known algorithms for the general CLP. In this paper we propose an approximation algorithm for the CLP. This algorithm can be used as a basis algorithm for problems related to the CLP and which occur when dealing with additional restrictions. In the paper we use the following notation. Let be given a container having length L, width W and height H. The small pieces (boxes) T i have length l i, width w i, height h i, supply s i and valuation v i, i = 1; : : : ; n. We assume that the sum of the piece volumes is larger than the container volume. The goal is to nd an allocation of given pieces within the container such that the sum of valuations is maximal. Obviously, if the valuation equals the volume for each piece then the objective is to nd an allocation with minimal waste. We restrict our investigations on orthogonal packings and assume that the length axis of the pieces in the allocation must be parallel to the length axis of the container; and the same must hold for the width and height directions. We identify the length direction with the x-direction, the width direction with the y-direction and the height direction with the z-direction in spatial space. Further on, the lower left front corner of the container is located at the origin, and the lower left front corner of a piece is called reference point of the piece. 2 The approximation algorithm Let be given any allocation (packing) of a subset of pieces within the container. How can it be described? If the piece T i takes the space between the two points (x; y; z) and (x + l i ; y + w i ; z + h i ) within the container then we call (x; y; z) the location point of the piece T i (i.e. the reference point is moved to the location point). A sequence of 4-tuples (x j ; y j ; z j ; j ); j = 1; : : : ; p; describes a packing of p pieces in an unique manner (where x j ; y j and z j are the coordinates of the location point of the j-th piece T j; j 2 f1; : : : ; ng) if there are not any conicting situation such that two pieces take the same space and all p pieces are packed within the container. Such a sequence is called packing pattern. 3

4 If there exists a space in the packing left over, large enough to pack one more piece, we can get a new packing. The corresponding pattern consists of one more 4-tuple. Thus, we have the basic principle of our algorithm. Starting with the empty container we pack one piece, obtain a pattern, look for a suciently large empty space, pack a new piece, and so on. Considering all possibilities of choosing a piece and the allocation space we follow the well-known "forward state strategy" of dynamic programming (as e.g. used by Hu (1969) for the Shortest Path Problem or by Ozden (1988) for the Linear Integer Programming Problem). A packing of p pieces represents a state of stage (level) p in the sense of dynamic programming. The number of such states is innite but only a nite number of states is necessary to compute an optimal packing. Of course, a location strategy must be used like the "bottom up - left justied strategy" of several bin packing algorithms. A more detailed description is given in the next section in connection with another representation of packings. Nevertheless, this nite number of admissible states is in general too large to handle (e.g. to store all states in a computer). One possibility to overcome this diculty and to get an approximation algorithm is to create a "measure" of "goodness or quality" of a state. Using this measure we can reject all states s which violate a threshold bound from further computations or, as we have used, we take only a nite number, say k, of the best states with respect to and use only these k states to compute the states of the next stage. (The corresponding properties of are discussed in section 3.) In the algorithm we use the following notations: B = set of basic states (in stage j? 1) N = set of new states computed (in stage j) k = a given parameter (with card(b) k) N k = set of the k best new states with respect to v = value of the best known state s Approximation Algorithm CL (Container Loading) Initialize: B contains the empty container s 0, v(s 0 ) := 0; N is set to be empty, v := 0; j := 0; Main part: repeat j := j + 1, for each s 2 B for each available piece T i for all admissible location points 4

5 compute the corresponding new state s 0, if s 0 62 N then N := N [ fs 0 g; v(s 0 ) := v(s) + v i else if v(s) + v i > v(s 0 ) then v(s 0 ) := v(s) + v i, if v(s 0 ) > v then v := v(s 0 ); s := s 0 ; if card(n) > k then reduce N to N k ; set B := N and N := ;; until B = ;; Solution: s is the approximate solution of the CLP. We give some remarks to the CL algorithm. 1. Within the CL algorithm a local optimization takes place in each stage j. Among all new states the k best with respect to are chosen, i.e. patterns with j pieces and large -value. 2. Because of the upper bound s i on the packing for piece T i Bellman's optimality criterion on dynamic programming is in general not valid, i.e. an optimal packing of the container does not require optimal packings with j pieces. 3. The given general CL algorithm allows a lot of modications with respect to application oriented restrictions. E.g., to reduce the computational eort only a subset of available pieces should be chosen for calculating new states, or only a part of location points may be investigated to get a special packing structure. 3 The concept of contours Using the pattern description of a packing we get some diculties connected with computational aspects. E.g., the search of not used empty space in a packing is very expensive and also the question of admissible location points is not easy to answer. For that reason we use another representation of a packing or pattern in an implementation of the CL algorithm. Let be given a feasible packing of a subset of pieces within the container. The projection of the packed pieces into the x; y-plane denes a dissection of the bottom area of the container which can be made to a rectangular dissection by lengthening some or all of the lines up to the next cross line or the border line of the container. We assign to each rectangle of the dissection a value of used height and allow in the following only the packing of pieces above these height values. More formally we dene: A rectangular dissection of the bottom area of the container together with corresponding height values is called contour. A contour can be represented by a set f(x i ; y i ; l i ; w i ; z i ) : i = 1; : : : ; rg of 5-tuples where (x i ; y i ) gives the lower left corner of a rectangle with length l i and width w i and z i denotes the used height. (It is to remark that exactly one height value is assigned to each interior point of all rectangles. The points belonging to the border lines of the rectangles may 5

6 have formally more than one height values, but these points are not of importance for the following investigations.) The allocation of one new piece above a given contour yields a new contour. Hence, each packing can be represented by a sequence of contours where the successor contour results from the predecessor by packing one piece. For the rectangles R i = (x i ; y i ; l i ; w i ); i = 1; : : : ; r; of a rectangular dissection we dene the following relation "< R ": R i < R R j () x i < x j + l j and y i < y j + w j : ((x; y) denotes the bottom left and (x + l; y + w) the upper right corner of a rectangle.) We say that a contour C = f(r i ; z i ) : i = 1; : : : ; rg is monotonous if z i z j for all R i ; R j with R i < R R j (i; j = 1; : : : ; r). Further on, the contour C is said to be above the contour C 0 = f(r 0 i; zi) 0 : i = 1; : : : ; r 0 g if for all (x; y) with (x; y) 2 int(r i ) \ int(r 0 j) z i z 0 j is valid (shortly: C 0 c C). The use of the relations < R and < c corresponds directly with the investigations of Lipovetskij (1988) about so-called z-sequences in the two-dimensional case. Let be given a packing pattern f(x j ; y j ; z j ; j ) : j = 1; : : : ; pg. Now our aim is to construct a sequence C 0 ; C 1 ; : : : ; C p of monotonous contours with C 0 < c C 1 < c : : : < c C p where C j results from C j?1 by packing one piece above C j?1 ; j = 1; : : : ; p: For that reason, each piece T i with location point (x i ; y i ; z i ) has to be packed before the piece T j if x i < x j + l j ; y i < y j + w j and z i < z j + h j. This relation can be extended to a partial order relation by applying the transitive closure. Hence, there exists a sequence T 1 ; : : : ; T p which does not violate this relation. Although the packing of one piece on a monotonous contour yields in general a contour which is not monotonous, the above relation ensures the existence of a sequence of monotonous contours. Summarizing, we have: For any packing (or packing pattern) of p pieces there exists a sequence C 0 ; C 1 ; : : : ; C p of monotonous contours and a sequence 1 ; : : : ; p of piece indices such that C j results from C j?1 by packing T j on top of C j?1. The representation of the monotonous contour for a given packing is in general not unique since there may exist dierent rectangular dissections. One question is, how many rectangles are at most required for a monotonous contour of p pieces? From the practical point of view the following question is of more importance : which location points are admissible to obtain good packings? To answer these questions we will consider in the following only so-called "normalized" packing patterns. A packing pattern is said to be normalized if each packed piece touches with their bottom, left and front side at least one other packed piece or the "walls" of the container. This denition corresponds to these of Herz (1972) and Beasley (1985) for normalizing two-dimensional cutting patterns. With other words, a normalized packing pattern is a "bottomleft-front justied" pattern. Obviously, to each packing pattern there exists a 6

7 normalized one. Hence, we may restrict in the following our investigations to normalized packings. Let us consider the contour C = f(r i ; z i ) : i = 1; : : : ; rg. We dene two indices of neighboring rectangles for a given rectangle R i : l(r i ) := ( 0; if xi = 0 j; with x j + l j = x i and y j y i < y j + w j ; (left neighbor of R i ); b(r i ) := ( 0; if yi = 0 j; with y j + w j = y i and x j x i < x j + l j ; (bottom neighbor of R i ): (For convenience we use z 0 = H.) For a normalized packing pattern with the contour C we dene the set P (C) := n (x i ; y i ; z i ) : i 2 f1; : : : ; rg; z i < z l(r i); z i < z h(r i)o : This set contains all admissible location points for the construction of optimal packings, i.e. to each possible location point there exists one element of P (C) which yields to a packing of the same or a better valuation. Moreover, we can state: Two contours C and C 0 describe the same monotonous contour if P (C) = P (C 0 ). Further on, for each contour C with card(p (C)) admissible location points there exists a representation with at most 2 card(p (C))? 1 rectangles. But the cardinality of P (C) can increase linearly in p. To avoid storage problems we use an input parameter r to bound the number of rectangles within a contour. If the algorithm produces a contour with more than r rectangles then we try to nd an equivalent contour with at most r rectangles and, if this it not possible, we look for a "neighboring" contour with at most r rectangles. Returning to the CL algorithm, now a state can be described by a contour and the corresponding packed pieces. Let v(s) denote the valuation of state s and f(s) the volume enclosed by the contour s. Then the measure should fulll the following conditions: 1. If f(s) = f(s 0 ) and v(s) > v(s 0 ) then (s) > (s 0 ). 2. If f(s) > f(s 0 ) and v(s)=f(s) = v(s 0 )=f(s 0 ) then (s) > (s 0 ). In the implementation of the CL algorithm we have used (s) := (v(s)+)=(f(s)+ ) with > 0 and 0. 4 Remarks to computational experiments The CL algorithm was coded in TURBO PASCAL, version 5.0, and was tested on a PC. The time required to obtain a packing depends in a straightforward manner 7

8 on the parameter k, i.e. on the number of states used to generate successor states. But this eort can be reduced by help of a dominance test to decide whether a new (still to generate) state possibly belongs to the k best new states or not. For instances with up to 100 packed pieces the computer time is in the range of some seconds (for k = 1, 2) and a few minutes (for k 5). As to expect, the value of the obtained packing does not correlate in a strong sense to the parameter k. But it is to observe, on average, a larger k yields a better solution. 5 Variants of the CL algorithm As discussed in section 2 some modications of the CL algorithm are possible. We have implemented three variants. Variant 1: This variant is the basic algorithm as given in section 2 (all possibilities of allocation are investigated). Variant 2: At rst a layer parallel to the bottom side is packed. Then a second layer follows, and so on, until the container is lled. Variant 3: Here the layers are parallel to the y; z-plane. 6 Conclusional remarks In the paper an approximation algorithm is proposed for the three-dimensional container loading problem. The well-known "forward state strategy" of dynamic programming is also applicable to this three-dimensional problem. The proposed CL algorithm can be used as a basis for developing algorithms which handle additional and application oriented restrictions. The concept of contours described is very suitable for an implementation of the CL algorithm. Some computational experiments made show that problems of medium size can be handled on PC computers in acceptable time. The necessity of further theoretical investigations results from induviduell practical restrictions given by the users. 7 References Beasley, J.E., An exact two-dimensional non-guillotine cutting tree search procedure. Oper. Res. 33, (1985) Beasley, J.E., Algorithms for unconstraint two-dimensional guillotine cutting. J. Oper. Res. Soc. 36, (1985) Dowsland, K.A., The three-dimensional pallet chart; an analysis of the factors aecting the set of feasible layouts for a class of two-dimensional packing problems. J. Oper. Res. Soc. 35 (1984) 8

9 Dowsland, K.A., An exact algorithm for the pallet loading problem. European J. Oper. Res. 31, (1987) Dowsland, W.B., Two and three dimensional packing problems and solution methods. New Zealand Oper. Res. 13, 1-18 (1985) Dudzinski, K.; Walukiewicz, S., Exact methods for the knapsack problem and its generalizations. European J. Oper. Res. 28, 3-21 (1987) Dyckho, H., A typology of cutting and packing problems. European J. Oper. Res. (1990) Eilon, S.; Christodes, N., The loading problem. Management Sci. 17, (1971) Gilmore, P.C.; Gomory, R.E., A linear programming approach to the cutting stock problem, part I. Oper. Res. 9, (1961) Gilmore, P.C.; Gomory, R.E., A linear programming approach to the cutting stock problem, part II. Oper. Res. 11, (1963) Gilmore, P.C.; Gomory, R.E., Multistage cutting stock problems of two or more dimensions. Oper. Res. 13, (1965) Haessler, R.W.; Talbot, F.B., Load planning for shipments of low density products. European J. Oper. Res. (1990) Herz, J., Recursive computational procedure for two-dimensional cutting. IBM J. Res. Develop (1972) Hu, T.C., Integer programming and network ows. Addison-Wesley, New York (1969) Ingargiola, G.; Korsh, J., An algorithm for the solution of 0-1 loading problems. Oper. Res. 23, (1975) Lipovetskij, A.J., Algorithms for non-guillotine rectangular cutting. Reports of the Ufa Aviation Institute (in Russian) (1988) Ozden, M., A solution procedure for general knapsack problems with a few constraints. Comput. Oper. Res. 15, (1988) Scheithauer, G., A three-dimensional bin-packing algorithm. J. Inform. Process. Cybernet. EIK 27, (1991) Schneider, W., Trim-loss minimization in a crepe-rubber mill; optimal solution versus heuristic in the 2(3)-dimensional case. European J. Oper. Res. 34, (1988) Sculli, D.; Hui, C.F., Three dimensional stacking of containers. Omega 16, (1988) Terno, J.; Lindemann, R.; Scheithauer, G., Zuschnittprobleme und ihre praktische Losung. Fachbuch Verlag Leipzig (1987) 9