ELSEVIER European Joumal of Operational Research 97 (1997) 41-52

EUROPEAN JOURNAL

OF OPERATIONAL RESEARCH

Theory and Methodology

The DH/KD algorithm: a hybrid approach for unconstrained two-dimensional cutting problems

Mhand Hifi * CERMSEM, Vniuersité de Paris 1 Panthéon-Sorbonne, 90 me de Tolbiac 75634, Paris Cedex 13, France

Received 8 June 199.5; accepted 24 February 1996

Abstract

We study both weighted and unweighted unconstrained two-dimensional guillotine cutting problems. We develop a hybrid approach which combines two heuristics from the literature. The first one (DH) uses a tree-search procedure introducing two strategies: Depth-jïrsr search and Hill-cfimbing. The second one (KD) is based on a series of one-dimen- sional Knupsuck problems using Dynumic programming techniques. The DH/KD algorithm starts with a good initial lower bound obtained by using the KD algorithm. At each leve1 of the tree-search, the proposed algorithm uses also the KD algorithm for constructing new lower bounds and uses another one-dimensional knapsack for constructing refinement upper bounds. The resulting algorithm can be seen as a generalization of the two heuristics and solves large problem instances very wel1 within smal1 computational time. Our algorithm is compared to Morabito et al.‘s algorithm (the unweighted case), and to Beasley’s [2] approach (the weighted case) on some examples taken from the literature as wel1 as randomly generated instances.

Keywords: Cutting problem; Depth-fïrst search; One-dimensional knapsack; Dynamic programming; Optimization; Heuristics

1. Introduction

The problem of cutting a given finite set of smal1 rectangular pieces from a large stock rectangle of fixed dimensions with minimum wastage or maximum profit is a generalization of the famous one-dimensional knapsack problem. This problem is called in the literature as the two-dimensional guillotine cutting (TDGC) problem. A set of smaller pieces defines a cutring paftem if these pieces can be produced by a sequence of possible cuts on the stock rectangle. Generally, we distinguish two versions of the TDGC problem. The unweighted uersion considers that the prol2 of each piece is exactly its area and the objective is to land a cutting pattern which minimizes the waste or the unused area inside the stock rectangle. The weighted uersion considers that each prol3 is independent of the piece’s area, which is a natura1 generalization of the preceding version but we look for a cutting pattem which maximizes the total profit. When the number of repetitions of each type of order piece in the cutting pattern is not limited, the problem is called the unconstrained TDGC and denoted UTDGC. If the number of occurrences of each type of pieces is limited by the demand value (an upper boundl,

* Correponding author. E-mail: hitï @univ-paris 1 .fr.

0377-2217/97/$17.00 Copyright 0 1997 Elsevier Science B.V. Al1 rights reserved. PI1 SO377-22 17(96)00060-4

42 M. Hifi/European Journal of Operational Research 97 (1997) 4I-52

then the problem is referred to as the constrained two-dimensional guillotine cutting stock problem and denoted (CTDGC).

Cutting problems have been studied first by Kantorovich [ 1 l] and later by Gilmore and Gomory [6,7] for commercial or industrial uses. Among obvious examples of apphcations [ 1,2,6,9,15] are the flexible workshops, the production of glass, metal sheets, textiles, multiprogrammed computer and multiprocessor systems. In such kind of applications, the objective is either to minimize the waste or to maximize the total utility of the used available material in stock by realizing required quantities of rectangular pieces.

For the weighted UTDGC problem, Gilmore and Gomory [7] have proposed an exact algorithm based on dynamic programming methods which was later improved by Beasley [2]. Obviously, the algorithm is also applicable to the unweighted case (i.e. ci = I,w;, where 1; and wi denote respectively the length and the width of the piece i, and ci its profit), but in this case Herz’s [8] algorithm is more efficient. Among the best known heuristics, we find the first one proposed by Morabito et al. [12], which uses the Depth-first search and Hill-climbing strategies (we denote the algorithm by DH), for solving approximately the unweighted case. The second one was proposed by Fayard and Zissimopoulos [5] based on solving a series of one-dimensional Knapsack problems by using a Dynamic programming method (denoted by KD), for the weighted and unweighted cases. These heuristics are classed as the better known in practice, because each of them is able to solve large problem instances within reasonable computational time.

The CTDGC problem was first studied by Christofides and Whitlock [4] which have proposed a depth-first search method. Viswanathan and Bagchi [ 181 have proposed another approach based on a best-first search method. One of the better known heuristics for the CTDGC problem, proposed by Wang [19], can give an optimal solution under some hypothesis. This heuristic was improved by Vasko [17] and later by Oliveira and Ferreira [ 131.

Generally, in order to reduce the possible cutting patterns, we consider two restrictions: 1. Al1 applied cuts are of guillotine type, i.e. a horizontal or a vertical cut on a (sub)rectangle being a cut from

one edge of the (sub)rectangle to the opposite edge which is parallel to the two remaining edges (see Fig. la).

2. All pieces have fired orientution, i.e. a piece of length 1 and width w is different from a piece of length w and width 1 (when 1 # w).

These restrictions, however, do not considerably limit the scope of the applications since a large number of real applications naturally appear with such restrictions. A solution to the nonguillotine problem (Fig. lb), can be found in Beasley [l], and a restricted case of nonorthogonal cutting has been studied by Rinnoy and al. [14].

This paper is organized as follows: in the next section, we present formally both weighted and unweighted UTDGC problems. In Section 3, we describe the most important methods used in the literature for solving exactly and approximately the two versions of the problem. In Section 4, we present the hybrid approach which is based upon dynamic programming, depth-first search and hill-climbing strategies. Finally, in Section 5 we give an experimental justification of the hybrid approach compared to the better actually known heuristics due to Morabito et al. [12] (for the unweighted case) and Beasley [2] (for the weighted case).

2. The formulation of the problem

An instance of the (un)weighted UTDGC problem is detïned by the triplet (9,5@, c). 5%’ = (L, W) is the initial rectangular plate, with length L and width W. The smal1 rectangular pieces are represented by the set

1 ca, cw

Fig. 1. (a) Guillotine and (b) nonguillotine cutting.

M. Hifi/European Joumal of Operational Research 97 (1997) 41-52 43

Y = {pi, . . , p,} such that each piece pi has dimensions (1,, w,> < (L, W>. c is the profit (weight) vector such that c = (c, , . . . , c,). Let 9 be a finite set which represents the different cutting patterns of the problem. Each vector 5 ~9 is composed of n components such that 5 = (t,, . . . , Sn), where 5, denotes the number of occurrences of the ith piece on 5. Let F be a function defined as follows:

F:g-+-tsuchthatF([)= ccjtj, tiENandc,Ef+J,fori=l,...,n, i= 1

where l,, wi, L and W are nonnegative integers, c, = liwi for the unweighted case, and ci # l,w, for the weighted case. (We denote by N the set of nonnegative integers.) An optimal solution of the problem is a coupje (5 * , F * ) such that the cutting pattern 5 * gives the best solution value denoted by F * = cTt *

3. Heuristic methods

Generally, the search process can be considered as the developed tree such that each leve1 of the tree represents a set of subproblems and the set of edges which link two successor ievels represent a relationship between the nodes. Herz [8] and Christofides and Whitlock [4] have used this representation and called it the graph structure. In [8], a powerful recursive tree search algorithm was given for solving exactly the unweighted UTDGC problem. It uses some easily calculated lower and upper bounds related to the area. The used bounds make the algorithm particularly efficient for solving the smal1 size problem instances.

Morabito et al. [ 121 have developed a heuristic (DH) based upon this search procedure presented as a tree using the depth-first search and hill-climbing strategies. The two strategies are commonly used in artificial intelligente methods (for more details, see [ 12,9]). An approximation algorithm (KD) was presented in [51 for solving the same problem based on one-dimensional knapsack problems and it becomes effcient for large size problem instances. This algorithm also uses the graph structure, but it considers only the first leve1 of the tree, by contrast with the DH algorithm (the authors have called it an and-or-graph upproach) which consists in developing a tree limited by the depth parameter [4,8,12].

Next, we present a hybrid approach, combining the DH and KD algorithms, which permits to develop a genera1 algorithm for the weighted and unconstruined UTDGC problem. This algorithm constitutes a general- ization of the two algorithms presented in [5,12]. As we have remarked, the KD algorithm is based on dynamic programming for providing a good suboptimal solution, but it does not exploit the inner subrectangles. However, the DH algorithm uses an exploration using the depth parameter but at the beginning and at inner nodes it introduces simple heuristics for obtaining lower and upper bounds (treating only the unweighted case). In the next section, we shall see how to combine these two techniques and provide a new efficient heuristic principally for soiving large problem instances (for the weighted and unweighted cases>.

4. The DH/KD algorithm: the hybrid approach

The algorithm is based on the depth-first search strategy characterizing the UTDGC problem. As we said above, the search process can be considered as a search in a directed graph; where each node represents a subproblem and each arc represents a relationship between some nodes. Generally, we can define a problem as a search in a graph by specifying the initial node, the final nodes and the rules that define the allowed moves.

For the UTDGC problem (see also [12]), the initial plate can be represented by the initial node and the smal1 rectangular pieces are represented by the final nodes. The allowed moves are the possible cuts on a (sub)rectangle. However, the different cuts can be applied to the initial rectangular plate (A in Fig. 2), which corresponds to the branching degree of this node. After each cut, two intermediary nodes are generated which correspond to two succeeding (sub)rectangles (B and C in Fig. 2 are generated by applying a horizontal cut on

44 M. Hiji / European Journal of Operational Research 97 11997) 41-52

Fig. 2. The search process used on the directed graph.

A, or D and E obtained by using a vertical cut on A). Other cuts can be applied to the resulting intermediary (sub)rectangles and so on, until the given rectangular pieces are found as the final nodes. Fig. 2 gives more details about the search process.

In order to deal with a tïnite number of dissections we discretize the length and the width of each rectangle or subrectangle without losing the optimality. Herz [81 showed such a discretization can be obtained by combining al1 dimensions of the pieces of the set 5’ (sec also [4]). In the sequel, the set of points on the horizontal, respectively vertical axis, for a (sub)rectangle ( (Y, p > is given by

P,’ x x= ClitiIa,tiEN,W,Ip (1 i= 1

), resp.~~=(ylj=~w.lraP,~iEW1,iáo}.

4.1. Initial and intemal lower bounds

A lower bound of the initial plate can be obtained by using the 0-cut phase of the KD algorithm proposed in [5] and generalized later in [9,10]. This algorithm uses the one-dimensional knapsack problems for developing a number of horizontal and vertical strips, and then combines them for giving a good feasible cutting pattern. The initial solution for the UTDGC problem is obtained by solving four one-dimensional knapsack problems within pseudopolynomial time complexity (using a dynamic programming procedure [16]). Moreover, as wil1 be discussed later, they supply lower bounds at inner nodes of the developed tree. Now, we recall briefly the procedure which creates vertical and horizontal strips.

4.1.1. The initial vertical cutting pattern Suppose that the elements of 5’ are reordered in increasing order of lengths (i.e. 1, I 1, I . . . I 1,). Let r

(5 n) be the number of different lengths of the set P’ and (a, p) be a (sub)rectangle.

L,.( P > = max C cjxj

jsR,p l Pc(a,P) =max k fi,( P)Yi, i, = 1

(K$.3)

i

subject to c wixi’pV cKap) subjectto .i~R,~

xjEN(,jERapf

i

i, = 1

Yi, E ‘*

The one-dimensional knapsack problem is defined by (K$), for i, = 1, . . . , r, where R,, is the set of rectangular pieces entering in (o, /3 >, x (resp. cj) is the number of occurrences (resp. the weight) of the jth piece in the i,th vertical strip and fi! BS th e solution value for the ith vertical strip.

The r one-dimensional knapsack problems (( K$ >, for i, = 1, . . . , r) generate r optimal strips and we distinguish each of them by its solution value fi,! /3> and its length (ii,,, wi) ~3’. We construct the first feasible solution denoted by the vertical cutting pattern for the subrectangle ( (Y, p) by solving another one-dimensional knapsack denoted by (K&), where (Y represents the length of the subrectangle and yi, is the number of

M. Hifi / European Journal of Operutional Research 97 (1997) 41-52 45

occurrences of the i,.th strip. Zc( CX, p ) denotes a lower bound for the vertical cutting pattern on ((Y, p 1. For the initial vertical cutting pattern on the initial rectangle (L, W), it is sufficient to solve (KLp), by setting a = L and p= w.

4.1.2. The initial horizontal cutting pattern By the same process, we can generate the set of the horizontal strips which is obtained by reversing the role

of widths and lengths in the previous procedure. Notice that we reorganize the elements of the set 9 in increasing order of widths (i.e. w, 5 w2 < . . . I w,). Now, we denote r’ the number of different generated strips such that each strip is characterized by its solution value fi$a> and its width wlh (which is equal to some widths of the elements of 9). By solving the one-dimensional knapsack problem denoted by (K,h,) (this knapsack is obtained by replacing the different lengths by the widths and the different widths by the lengths in ( KOj, )), we generate the second feasible solution called the initial horizontaf cutting pattern, with its solution value Yh(L, W).

The initial solution value of the algorithm is considered as the better solution between the oertical and horizontal cutting patterns (for more details see [9,10,20]). We have already mentioned that four one-dimen- sional knapsacks provide a lower bound for the initial rectangular plate. If we use dynamic programming techniques [ 161 for solving the (K$) for (Y = L, p = W and i,. = r (resp. (Ka%) for (Y = L, p = W and i, = r’), we create the longest vertical (resp. the highest horizontal) strip. However, the one-dimensional knapsack problems, for i,. = 1, . . . , r - 1 (resp. for i, = 1, . . , r’ - 1) are solved and al1 optimal solutions value of the strips are available. So, we create two cutting patterns by solving four one-dimensional knapsack problems. So, we remark that the initial lower bound is obtained by using four one-dimensional knapsacks: two one-dimen- sional knpsacks for proving the initial horizontal cutting pattern and two other knapsacks for giving the initial vertical cutting pattern.

4.1.3. The lower bound at inner nodes Concerning the intermediary nodes of the developed tree, when we deal with a subrectangle ( LY, p ), its lower

bound should be obtained by solving only two one-dimensional knapsacks (K$) and ( KDj,), since, as shown above by using the dynamic programming, the solution values of ah substrips of intermediate widths and lengths are available. At the inner nodes (for the unweighted version), the DH algorithm uses the homogenous cutting pattern obtained by the particular cutting pattem which is represented by the repetition of the homogenous strip (composed by only one type of pieces). We propose to replace this solution value by the genera1 cutting pattern given by

P(o,P) =max{~.((Y,B),~~(a!,p)},

where PP( LY, /3> (resp. L?,,((Y, /3)> is obtained by using the greedy algorithm for solving the two one-dimen- sional knapsack problems ( KOj,) and ( KLp >.

4.2. Upper bounds and the main steps of the DH / KD approach

4.2.1. Upper bounds at nodes The DH algorithm uses an upper bound concerning the area of each node of the tree search. This bound has

been introduced in similar tree-search [1,9,20] and calculated by solving another one-dimensional knapsack problem. In the following, we shall present a generalization of this problem given as fellows:

‘V(a,P)=max C CjZ, jERmp

( K,,) ( subject to C (ljwj)zjs(aP)* jER,p

\ ZjI [a/lj] X [P/Wj], Z,kO, jERop,

46 M. Htfi / European Journal of Operurional Research 97 (1997) 41-52

where R,, is the set of pieces entering in ((Y, p), zj is the number of occurrences of the piece j E R,,. We remark that (K,) is a large one-dimensional knapsack. We reorder initially (at the beginning of the algorithm) the elements of the set 9 in nonincreasing order such that (c,/l,w,) 2 (cJ/~w~) 2 . . . 2 (c,/l,w,,). Notice that if we have two terms which reahze the same coefficient, then we take in first the term with a greater profit. Now, we apply the greedy algorithm for solving (K,,) and we take as an upper bound for the subrectangle ((Y, p ) the valid value ]Z( (Y, /3 )].

4.2.2. Main steps of the hybrid algorithm (the DH/ KD algorithm) Suppose that a certain node is generated. To expand this node, al1 possible paths must be generated from it,

following the rules defining the branchings. We consider a generated and not expanded node as an open node. A generated and completely expanded node is a closed node. The search process is finished when al1 the nodes are completely expanded, i.e. when the initial node of the problem is closed. The depth-search strategy is equipped with a parameter Depth which represents the maximum leve1 permitted in the developed tree. Below, we describe the main steps of the DH/KD algorithm for solving approximately the weighted and unweighted UTDGC problem. We start the algorithm by setting the initial rectangle as the initial node and by generating the two initial cutting patterns by using the dynamic programming methods.

The DH / KD algorithm Input: an instance of the (un)weighted UTDGC problem. Output: a suboptimal cutting pattern.

Initial step: Let init = ((Y, /3) be the initial open node (cr = L and /3 = W ). Compute _Z?(CX, p) = max{q,(o, /3X _5Yh(cy, p)] and set nod = init. Generate the reduced sets of points P, and Q,.

Main step: While init is not closed, do: 1. Generate the successors from nod until the Depth leve1 using a depth-first strategy. For each generated

node ((Y, p), compute its lower and upper bounds to avoid unnecessary branchings and update the lower bound (_Y( CX, /3)) until the ancestor nodes init is reached.

2. Use a hill-climbing strategy for choosing the best path and close the nodes which have no successors or whose successors are closed.

3. Select one node to update nod (if this node is an open one and if it is in the chosen path).

Suppose that we have a new path generated by a cut on a (subXectangle A, giving two new subrectangles B and C. Consider the unweighted case and let S(A), U(A) and L( A) be respectively the area, the upper bound and the lower bound of the (sub)rectangle A. We consider that the lower and upper bounds are related respectively to the area occupied by the pieces and the area of the given (sub)rectangle A.

- In [8], the author has used a strategy in the tree search process that discards unnecessaty cuts. It consists in rejecting al1 cuts in such a way that a given percentage of U(B) + u(C) is less than L(A).

- Morabito et al. [12] have transformed the Herz’s strategy and suggest two strategies: In the fïrst one, if y,(LI(B) + V(C)) 2 L(A) then we discard the cuts on the resulting subrectangles B and C, where y, is a previously given percentage. The second strategy concentrates only on lower bounds. We discard the cuts such that yZ( L( B) + L(C)) I L(A), where y2 is a previously given percentage.

* In the DH/KD algorithm, we consider both weighted and unweighted cases, and now the lower and upper bound of a given (sub)rectangle A are represented by _.Y( A) (Section 4.1.1 or Section 4.1.2) and Y/(A) (Section 4.2.1). We introduce the following strategies: 1. We use the first strategy [8,12] with y, = 0.999, i.e. y,(‘%(B) + Z(C)) <L?(A). 2. If we suppose that the node B terminates by the best lower bound denoted P(B) (i.e. al1 cuts are examined

on this path), then we discard the node C such that _5?( B) + yi Z!(C) <_Y( A).

M. Hifi / Europan Journal of Operational Research 97 (1997) 41-X 47

The procedure which creates lower bounds, as was confirmed in [9,10] for the (un)weighted UTDGC problem, is efficient on large size instances. Therefore, the cuts made on each ((Y, p> are examined from the middle to the left if we use the vertical cuts and from the middle to the bottom if we use the horizontal cuts. Indeed, this strategy consists in examining the largest subrectangles. A normalized cutting pattern has been used by Herz [8] and Christofides and Whitlock [4] for generating the set of cuts on the horizontal (resp. vertical) axis which are linear combinations of lengths of pieces entering a subrectangle to cut. In [2,12] the authors have used a heuristic based upon the previous one for generating a smal1 number of

points. Our algorithm applies the same principle, but we construct the sets of points by using a new transformation described as fellows: let S/ (resp. 6,*>, for i = 1, . . , n, be the nonnegative integers and the modified function of Christofides and Whitlock given as follows:

‘0 if i = 0 and x = 0,

;-!(x)

if i = 0 and x # 0, if i # 0 and

f!(x) = ( ((x<l,) or(x> S/1,)),

, i min &,( x),max

1 wi, min otherwise,

1 ~k~min~lx//,l.S/)

f,_ ,( x - ki,)))

where 1 I S!l[L/I,], for i= 1, . . . . n. For the subrectangle (cy, p), we claim that IY represents a combination of some lengths of the set Y if f,(a) I p (we use the same function for constructing the set of the horizontal points in which we replace S/ by &“‘, Li by wi and w, by l,, where 1 I 6;” i [(W/w,)], for i = 1, . , n).

5. Experimental study

In this section, we present the performance of the DH/KD algorithm and effects of the modification introduced in Christofides and Whitlock’s function. We compare this algorithm to the results given by Morabito et al.‘s algorithm on Herz’s and Beasley’s instances, for the unweighted case. Another comparison is between the DH/KD and Beasley’s algorithms, on Christofides and Whitlock’s instances. Finally, we performed tests on some instances which were randomly generated. Our experiments were performed on a Data Genera1 AV8000 (Quadri-Processor Motorola 88 100).

In the tables, Depth denotes the limit of the leve1 introduced in the tree-search and 6, = 6: = . . = S,! (resp. 6, = Sy = . .. = S,,“‘) is the parameter used in the modified Christofides and Whitlock function, chosen uniformly. Notations lP,l and iQ,i indicate the number of points generated on the horizontal and vertical axis, LB and Solution represent repsectively the value of the initial lower bound and the solution value given by our algorithm. Finally, we present the computational power of al1 algorithms measured in seconds. For al1 instances, the optimal solution values are found by applying the exact algorithms of Herz [I] or Beasley [2].

Table 1 Performance of the DH/KD algorithm on Herz’s example

Optimal Depth lQ,.l IP,I # nodes LB Solution Time k.)

12348 2 1 1 5 max, ’ max, ’ 33

a maxl=[(L/I,)landmax,=l(W/wi)J,for i=l,_,,, TZ.

5 69 12132 12348 0.01 60 643 12132 12348 0.06

48 M. Hifi/ European Journal of Operational Research 97 (1997) 41-52

Table 2 Execution of the DH algorithm on Monbito et al’s [l2] instances

Instance Optimal Depth IP,I lQ,l Solution Time CsI

Ml 15024 2 73 47 15024 0.25 M2 73 176 2 86 153 72 172 0.33

3 73 176 0.40 M3 142817 2 155 70 141810 0.47

3 142817 0.83 M4 265 768 2 138 116 265 768 0.77 M5 577 882 2 145 122 577 882 1.21

5.1. The unweighted case

At first, we treat some instances which represent the unweighted case. As we remark here, the comparison between the DH and DH/KD algorithms are executed under some difficulties. The first one uses two parameters y, and y2, and a heuristic for generating the two sets P, and Q,. On the other hand, our algorithm uses only the moditïed version for generating the previous sets and fixed yi to 0.999.

The DH algorithm, on Herz’s instance (as shown in Table l), has been executed with yi = 0.95, yz = 1, Depth = 2 or/and 3, 1 P,l = 60 and iQ,l = 33. These values have been suggested by Morabito et al. [12]. For Depth = 2, the solution value given by the DH algorithm is equal to 12 132 and required 0.09 s. For Depth = 3, the solution value is optimal (12348) and the required calculation time is 0.22s generating 2115 nodes. As Table 1 shows, the DH/KD algorithm gives a better solution value at Depth = 2 and uses the shortest computational time (0.01 s). Also, when we use al1 different points ([PI1 = 60 and lQ,,l = 33), our algorithm gives the optimal solution in 0.06s and generates only 643 nodes.

In Tables 2 and 3, we consider five instances (Ml, M2, M3, M4 and M5) taken from [12]. They are described by (L, H, n) equal to (100,156, lO), (253,294, lO), (318,473, lO), (501,556,lO) and (750,806,lO) respectively. The two tables show details about results given by the DH (sec Table 2) and the DH/KD (sec Table 3) algorithms. It is worth noticing the good quality of lower bounds. For three instances (Ml, M4 and M5 of Table 3) the lower bound is equal to the optimal solution value. Remark that the DH/KD algorithm provides, generally, the optimal solution value with Depth = 2 and uses a smal1 number of points (S, = 6, = 1) within smal1 computational time.

The quality of lower bounds and suboptimal ones are also shown in Table 4. Consider here Beasley’s instance. We execute the algorithm on the constructed subinstances described by (L, H, n> equal to (3000,3000,10), (3000,3000,20) and (3000,3000,32) respectively. We take a variation on parameters 8, and 8, for evaluating solution values and the required time. The solution value published by Beasley [2], for n = 32, is 8 868 950. The best solution value actually found by the Morabito et al. algorithm 1121, for n = 32, is equal to 8 944026. Furthermore, the initial lower bound and the solution value provided by the DH/KD algorithm using parameters n = 10, Si = 6, = 1 and Depth = 2, are better than their solution value. Remark that the initial lower

Table 3 Performance- of the DH/KD algorithm on Morabito et al’s 1121 examples

Instance Depth 8, 62 IQWI IPJ # nodes LB Solution Time (s)

Ml 2 1 1 9 9 107 15024 15024 0.10 M2 2 1 1 9 10 131 72 172 73 176 0.18 M3 2 1 1 10 10 159 141810 142817 0.28 M4 2 1 1 10 10 221 265 768 265 768 0.35 M5 2 1 1 10 10 397 577 882 577 882 0.47

M. Hifi / European Journal of Operational Research 97 (1997) 41-52 49

Table 4 Performance of the DH/KD algorithm on Beasley’s 121 example

n Depth

10 2

20 2

32 2

6, 8, lQ,l lP,l # nodes

1 1 10 8 211 2 1 10 4.4 1431 1 2 177 8 1703 2 2 177 44 4485

1 1 19 13 177 2 1 19 98 2435 1 1.5 188 13 1059

1 1 31 18 873 2 1.3 170 250 98033

LB

8966100 _

8997780 _

8997780

Solution

8974 100 8982050 8974 100 8982050

8997780 _ _

8997780

Time (s)

3.37 3.81 4.32 7.63

4.3 1 6.04 4.49

10.01 33.23

bound is equal to 8 966 100 and the final solution value is 8974 100. The better solution of this subinstance (8 982 050) is obtained at the leve1 2 and by using parameters 6, = 2 and 6, = 1. When n = 20 or 32, the initial lower bound and the solution value are considerably increased, now being 8 997 780, which is much better than the solution published by Morabito et al. [12]. Notice that the solution obtained by the DH/KD algorithm represents the optimal solution value, obtained also by running the exact Beasley algorithm using 3 1.27 hours.

It is easily to see that parameters introduced in Christofides and Whitlock’s function can be considered as a nonnegative real for generating a smal1 number of points of P, and Q,. Actually, if we have for example 6, = 2 and for this value the cardinality of the set Q, is large, then we can reduce this value by setting s, = 1.1,1.2, . ..> 1.9, and we replace 1 I k I min{l(x/li)l, S/) by 1 I k I min(l(x/lj)l, 1 6i”l) in the previous function. (We also used this evaluation if the cardinality of the set P, increases when for example 6, increases.)

Table 5 Performance of the DH/KD algorithm on the randomly generated instances

Instance IQJ IP,I # nodes LB Solution Ratio Time (s)

The unweighted case UI 101 u2 86 u3 164

164

The weighted case Wl 67 w2 145 w3 245

139 32031 22 167051 22370 130 0.994 27.05 104 50 125 2003 1845 20168944 0.982 29.31

19 71239 47 966 680 48 074 745 0.994 63.41 109 123397 163.37

68 19747 34 520 35728 0.903 21.80 135 181071 161424 171816 0.997 257.5 1 311 87 599 234 108 234 108 0.953 657.43

Table 6 Performance of the DH/KD on Christotïdes and Whitlock’s [4] instances

Instaace Optimal

Cl 249

c2 3076 c3 2240

DH/KD algorithm: a hybtid approach

6, 62 lQ,l IP,I # nodes LB

1 1 5 3 17 248 2 1 5 ll 39 248 1 1 7 9 71 3076 1 1 19 17 107 2240

Solution Time (s)

248 < 0.01 249 < 0.01

3076 0.06 2240 0.09

Beasley’s algotithm

Solution Time (s)

249 0.17

3076 0.5 1 2240 0.63

50 kl. Hip/ European Joumal of Operational Research 97 (1997) 41-52

Table 7 The randomly generated instances

#Inst. u3 Wl w2

CL, W) ;50;4070) (7350.6579) (5000,5000) (3427.2769)

(1.. w,) (437.1490, .) (731,1830,.) (1527.1447, .) (437.73 1,2223) (451.647.1232) (1232.1932.1764) i= I,...,n

3 4

5

6

7

8

9

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

(232.1320, .) (822,1740, .) (237,932, .) (932,l 107, .) (822,639, .) (598,732, .) (1004,1093,.) (569, 132 1, .) (269,1221,.) (1791,1007,.) (632,893, .) (1248,747, .) (1110,347,.) (931,891,.) (598,532, .) (562,1031,.) (659,921,.) (721,1721,.)

(1859,2647,.) (732.822.143 1) (723,1267,1214) (1723,467, .) (637,932,3876) (92 1>673,876) (928.1673, .) (822,598,1154) (823.632.986) (2029,932, .) ( 1004,569,1675) (724,939,1765) (1029,1639,.) (469.79 1,1342) (754.449.1234) (757,749, .) (932,648,2998) (921.316.398) (927,916.J (2110,931,2125) (2007,563,4351) (2007,563, .) (598,562,1564) (1022,893,845) (1029,1893,.) (659,721,1786) (579,1932,2986) (1376,1932,.) (921,3721,3002) (727,1750,1004) (727.1750, .) (1490,1830,1761) (1975.947.1732) (2098,947, .) (1320,1740,931) (1239,1207,1214) (1238,1207,.) (932,2100,2239) (1221,769,876) (1026,769, .) (639,732,89 1) (1737,932,1886) (1737,932, .) (1093,1321,1453) (991,2532,585) (997,2532, .) ( 122 1>2407,932) (561,2421,1034) (1967,2421,.) (893,747,1209) (721,1945,1498) (2828,1945, .) (547,891,671) (1537,789,1751) (1537,1789,.) (532.2131.1763) (647,123 1.1345)

(3214,2014,1294) (2876,1876,2756) (986,2986,1186) (1765,1765,1866) (1234.934.1296) (3398,1008,1008) (4351,2351,1357) (2345,1345,1365) (2986,2099,1007) (3004,1007,2434) (1276,845,1933) (1732,1032,880) (22 14,2004,2874) (2876,1879,1579) (1886,1786,997) (585,995,2787) (1034,1034,1706) (3498,3498,1938) (5751,1051,2051) (1345,1545,845) (3086,2086,1092) (1983,1583,2121) (3214,1214,1214) (2071,1071,1904) (4886,1806,1006) (785,885,1088) (2870,1877,3608) (1198,2100,999) (2781,2757,1351) (981,3781,1581) (2532.2434.1116) (1917,880,2455) (1599,2874,888) (1116,1579,1702) (2455.997.2151) (888,3787,995) (3702,1706,1276) (3151,1938,1431) (995,205 1.1763)

In Table 5, we present six randomly generated instances (Table 7 gives details of these instances). For the first three instances (Ul, U2 and U3), we consider the unweighted case, and for the other instances (Wl, W2 and W3), we consider the weighted case. Each solution given by the DH/KD algorithm is compared to the upper bound of the instance. The approximation ratio for each instance 1 is evaluated by A(I)/Upper(Z), where A(I) is the solution value given by our algorithm and Upper is the upper bound obtained by solving the relaxed one-dimensional knapsack (K,) (Section 4.2.1). For all instances, we set Depth = 2, 1 < 8, I 2 and 1 I 6, I 2. In this case, we remark that lower bounds represent an approximation ratio equal to 0.985, 0.975 and 0.992 for the first three instances (UI, U2 and U3). However, the approximation ratio of suboptimal ones

h4. H(fi/Europeun Journal of Operutional Research 97 (1997) 41-52 51

(given by the DH/KD algorithm) are equal respectively to 0.994, 0.982 and 0.994. Notice that the average approximation ratio of these instances is equal to 0.990.

5.2. The weighted cuse

We now treat the weighted case and we present in Table 6 the solution values given by Beasley’s heuristic and the DH/KD algorithm on three instances (C 1, C2 and C3) taken from [4]. They are described by (L, H, n) equal to (15,10,7), (70,40,10) and (70,40,20). We execute Beasley’s algorithm without reducing the set of points P, and Q,. On the other hand, we execute the DH/KD algorithm by setting Depth = 2 and setting a variation on 6, and 6,. For the second and the third instances (C2 and C3), the lower bounds are equal to the optimal ones. For the instance Cl, we remark that the initial solution value is nearoptimal one with an approximation ratio equal to 0.996. For S, = 2 and 6, = 1, the DH/KD algorithm provides the optimal solution.

Return now to the Table 5 and consider only the instances Wl, W2 and W3, which represent the weighted case. We can show the performance of lower bounds and suboptimal solution values given by the DH/KD algorithm. For the three instances (detailed in Table 71, the average approximation ratio of lower bounds is equal to 0.921 and equal to 0.951 for the suboptimal values produced by our algorithm.

Finally, we can state that the hybrid approach performs welk especially for large UTDGC problems. Furthermore, we propose here a method which consists in setting 1 2 6, I 2, 1 I 6, 4 2 and Depth = 2 or Depth = 3. The goal is to find satisfactory solution qualities without too much computational effort. Eventually, the reduction of the number of points of the two sets P, and Q, reduces the search space, which may reduce the quality of the obtained solution. Notice that we have proposed this way because the quality of the solution is recompensated in first by the initial lower bound and essentially by the intermediary lower bounds. On the other hand, we can extend the search space by using a variation on the domain of 6, and the domain of 6,. In this case an improved solution can be obtained but sometimes a considerable computation time is needed.

6. Conclusion

In this paper, we have considered both weighted and unweighted unconstrained two-dimensional guillotine cutting problems. We have developed a hybrid approach combining dynamic programming and artificial intelligente methods. We have exploited two techniques for constructing a new algorithm which limits the depth of the developed tree, and using good lower and upper bounds for each subproblem. We also showed how the normal pattems could lead to reducing cuts, and indicate that the DH/KD algorithm is able to deal very wel1 with large problem instances. The empirical results of the algorithm are given and compared to the results given by Morabito et al.‘s [ 121 algorithm for the unweighted case, and to Beasley’s [2] algorithm for the weighted case. Finally, we can state that the DH/KD approach performs very wel1 especially for large instances for the two versions. There is an interesting problem linked to the topics of this paper. Since, the one-dimensional knapsack problem can be solved by using the parallel implementation [3], how can this method be exploited for solving exactly or approximately the genera1 fnonkuged CTDGC? Finally, nothing is known up to now about the interval between an optimal guillotine type solution, an optimal nonguillotine type solution and a genera1 nonguillotine or nonorthogonal type optimal one.

Acknowledgements

Many thanks to anonymous referees for helpful comments and suggestions contributing to improving the legibility of this paper.

52

References

M. Hijì / European Jaurnal of Operational Research 97 (1997) 41-52

[l] Beasley J.E., “An exact two-dimensional nonguillotine cutting tree search procedure”, Operations Research 33/1 (1985) 49-64. [Z] Beasley J.E., “Algorithms for unconstrained two-dimensional guillotine cutting”. Jaurnal of the Operational Research Society 36

(1985) 297-306.

[3] Chen, G., Chem. M., and Jang, J., ” Pipeline architectures for dynamic programming algorithms”, Parallel Camputing 13 (1990) 111-117.

[4] Christofides, N., and Whitlock, C., ” An algorithm for two-dimensional cutting problems" , Operations Research 25 (1977) 3 1-44. [5] Fayard, D., and Zissimopoulos. V., ” An approximation algorithm for solving unconstrained two-dimensional knapsack problems”,

bl [71 k31

[91

[lol

[ff1 [121

LI31

(141

t151 [161 1171

LI81

1191 [ZO1

European Journal of Operational Research 84/3 (1995) 618-632.

Gilmore, P., and Gomory, R., “Multistage cutting problems of two and more dimensions”, Operations Research 13 (1965) 94-119. Gilmore, P., and Gomory, R., “The theory and computation of knapsack functions”, Operations Research 14 (1966) 1045-1074. Herz, J.C., “A recursive computing procedure for two-dimensional stock cutting”, IBM Journal of Research and Deoelapment 16 (1972) 462-469. Hifi, M., “Study of some combinatorial optimization problems: Cutting stock, rectangular packing and set covering problems”, PhD Thesis, University Paris 1 Pantheon-Sorbonne, 1994 (in French). Hifí, M., and Zissimopoulos, V., ” Une amélioration de l’algorithme récursif de Herz pour la résolution du problème de découpe a deux dimensions “, RAIRO, Operations Research 29/4 (1995) 1-15.

Kantorovich, L.V., “Mathematica1 methods of organizing and planning production”, Management Science 6 (1960) 363-422. Monbito, R., Arenales, M., and Arcaro, V., “An and-or-graph approach for two-dimensional cutting problems”, European Jaurnal of Operational Research 58/2 (1992) 263-271. Oliveira, J.F., and Ferreira, J.S., “An improved version of Wang’s algorithm for two-dimensional cutting problems”, Eurapean Journal of Operational Research 44 (1990) 256-266.

Rinnooy Kan, A.H.G, De Wit, J.R., and Wijmenga, R.T., “Nonorthogonal two-dimensional cutting pattems”. Management Science 33 ( 1987) 670-684. Sysio, M., Deo, N., and Kowalik, J., Discrete Optimizatiun Algorithms, Prentice-Hall, Englewood Cliffs, NJ, 1983. Toth, P., Dynamic programming algorithms for zero-one knapsack problem”, Camputing 25 (1980) 29-45. Vasko, F.J., ” A computational improvement to Wang’s two-dimensional cutting stock algorithm”, Computers and Industrial Engineering 16 (1989) 109-115. Viswanathan, K.V., and Bagchi, A., ” Best-fírst search methods for constrained two-dimensional cutting stock problems”, Operations Research 41/4 (1993) 768-776. Wang, P.Y., “Two algorithms for constrained two-dimensional cutting stock problems”, Operations Research 31/3 (1983) 573-586. Zissimopoulos, V., ” Heuristic methods for solving (un)constrained two-dimensional cutting stock problems”, Methods of Operations Research 49 (1984) 345-357.