for algorithm A.23
2.3.3 Scope of Algorithmic Evaluation in this Dissertation
In the remainder of this dissertation algorithms are almost entirely compared by means of computational measures. Comparison tools such as the strip/single bin size bin packing accuracy and efficiency, as well as the multiple bin size bin utilisation, fitness and efficiency, listed in §2.3.2, will be employed to compare heuristics that are reviewed or introduced in this dissertation. The worst-case time complexity of algorithms is the only theoretical evaluation method used to evaluate the heuristics. However, other theoretical evaluation methods performed on known heuristics will be presented if they have appeared in the literature.
2.4 Chapter Summary
The aim of this chapter has been to introduce the notion of cutting and packing problems, and to delimit the scope of this dissertation. After a short introduction, the typologies of Dyckhoff [43],
W¨ascher et al. [157], Lodi et al. [101, 105] and Ntene [125] for such problems were discussed in
some detail, in fulfilment of Dissertation Objective I as stated in §1.3. This made it possible to clarify the scope of cutting and packing problems covered in the remainder of this dissertation. After the discussion on typologies, a brief introduction to methods for solving packing problems highlighted the use of three classes of methods, namely heuristics, metaheuristics and exact methods in fulfilment of Dissertation Objective II. This was followed by a introduction to theoretical and computational methods for the analysis of algorithms designed to solve packing problems, in fulfilment of Dissertation Objective III as stated in §1.3. The theoretical analyses included worst-case algorithmic time complexity and two worst-case measures for the solution quality; the absolute performance bound and the asymptotic performance bound. Thereafter, the methods for the computational analysis of algorithms were presented in some detail.
2If the fitness of solutions is the preferred measure of solution quality, the multiple bin size bin packing score
for algorithm A is given by
ΨMSA (P) = ν A (P) × τP tA P 1` .
This score may be employed as a tool for the comparison of algorithms in terms of both fitness and time, but will not be used in this dissertation.
3In order to measure the solution quality of a single bin size bin packing algorithm, called Algorithm A, the
number of bins required to pack all items (denoted by A(P), where P is an abbreviation of the problem where
the set of itemsI are to be packed into the set of bins B) may be divided by the number of bins required to pack
the items (called packed bins) in an optimal solution (denoted by OPT(P)). This ratio is called the single bin size
bin packing accuracyαSS, and defined as
αSSA (P) =
A(P)
OPT(P).
However, an optimal solution may not be known for all benchmark instances. In order to compare a number of algorithms with respect to benchmark instances for which optimal solutions are not known, the number of bins required to pack the items in a solution found by the algorithms may be divided by a valid lower bound. In order to compare algorithms with respect to solution quality and the speed at which the solution is found, the single
bin size bin packing efficiencyΓSS is defined as
ΓSSA (P) = OPT(P) A(P) × τP tA P 1`
CHAPTER 3
Level Strip Packing Heuristics
Contents
3.1 Introduction . . . 27 3.2 Known Level-Packing Heuristics . . . 28 3.2.1 The Next-Fit Decreasing Height Algorithm . . . 28 3.2.2 The First-Fit Decreasing Height Algorithm . . . 30 3.2.3 The Best-Fit Decreasing Height Algorithm . . . 32 3.2.4 The Knapsack Problem Algorithm . . . 34 3.2.5 The JOIN Algorithm . . . 36 3.3 New Level-Packing Heuristics . . . 39 3.3.1 The Worst-Fit Decreasing Height Algorithm . . . 39 3.3.2 The Best Two Fit Deceasing Height Algorithm . . . 41 3.4 Chapter Summary . . . 44
Various level-packing approaches to the two-dimensional strip packing problem are considered in this chapter. These algorithms partition the strip by means of horizontal lines, thereby creating levels. A new level is initialised above the topmost level if items no longer fit on lower levels. The workings of a number of known heuristics following this approach are described and two new heuristics are introduced. All algorithms in this chapter yield a two-stage cutting pattern. This means that when the items are cut, the pattern will have to be turned by ninety degrees no more than twice in order for the items to be separated by means of a hypothetical set of linear blades. The first cut would be along the lines representing the levels and the second set of cuts would be to separate the items in each level from each other. This method of describing the solution pattern does not include the turn required for the trimming of waste from the items.
3.1 Introduction
An example set I of items is used to illustrate the working of the various algorithms presented in this chapter and the next. The dimensions of the items are listed in Table 3.1 and the items in I are shown in Figure 3.1.
13 1 2 3 4 5 6 7 8 9 10 11 12
Figure 3.1: The item set I used for illustrative purposes.
Item, Ii 1 2 3 4 5 6 7 8 9 10 11 12 13
Height, h(Ii) 11 7 6 1 9 2 3 4 3 7 9 2 5
Width, w(Ii) 4 2 7 7 11 7 5 4 6 9 14 6 16
Table 3.1: Dimensions of the items in I.
It is often useful to sort the items before packing them. Johnson et al. [84, 85] studied the next-
fit decreasing1 (NFD) algorithm [84], the first-fit decreasing (FFD) [85] and best-fit decreasing
(BFD) algorithms [85], as well as the unsorted versions of these algorithms. They concluded that the worst-case result for each algorithm with sorted items is better than the worst-case scenario for the corresponding algorithm with unsorted items. In two dimensions the advantage gained from sorting the items by decreasing height before packing takes place is even more significant. To appreciate this observation, consider a list of items where each item in the list is taller than the item that precedes it in the list and the sum of the widths of the items is equal to or less than the width of the strip. Then the strip height resulting from an unsorted packing equals the sum of the items’ heights, while sorting the items results in a strip height equal to the height of the tallest item in the list. Therefore, most offline algorithms sort the unpacked items before an attempt is made to pack them.