The six elements to block-building approaches for the single container loading problem

Abstract

In the Single Container Loading Problem, the aim is to pack three-dimensional boxes into a three-dimensional container so as to maximize the volume utilization of the container. Many recently successful techniques for this problem share a similar structure involving the use of blocks of boxes. However, each technique comprises several seemingly disparate parts, which makes it difficult to analyze these techniques in a systematic manner. By dissecting block building approaches into 6 common elements, we found that existing techniques only differ in the strategies used for each element. This allows us to better understand these algorithms and identify their effective strategies. We then combine those effective strategies into a greedy heuristic for the SCLP problem. Computational experiments on 1,600 commonly used test cases show that our approach outperforms all other existing single-threaded approaches, and is comparable to the best parallel approach to the SCLP. It demonstrates the usefulness of our component-based analysis in the design of block building algorithms.

Appendix: Partition-controlled tree search

In this section, we provide an outline of the partition-controlled tree search, which is used by the CLTRS algorithm. Precise details of this approach can be found in [10].

Assuming at least b successors are generated at each node of the search tree, and the total number of nodes in the search is limited by a value search_effort, then the maximal depth of search td is given by:

(1)

The authors set b=3. For example, when search_effort =32, then td=3 based on (1). The set of all ordered partitions of the integer td is given by π={(3),(2,1),(1,2),(1,1,1)}; for every partition, a separate search is carried out (see Fig. 9(a)).

Fig. 9

An example of PCTRS

The search corresponding to the partition (2, 1) is shown in Fig. 9(b). It is divided into two stages, where the first stage can be thought of as a search tree of depth 2, and the second stage is of depth 1. At each stage, w successors are generated for each node. Let d be the depth of the stage; then w is established by:

(2)

For every node, the w blocks with maximal loaded volume are selected to generate the w successors; the values of w ₁ and w ₂ corresponding to the two stages are calculated to be 5 and 32 respectively. The leaf nodes of the search tree in the first stage are expanded using a greedy heuristic that repeatedly chooses the block with maximum volume that can fit into the top free space cuboid in the stack. Hence in the first stage, 5 successors are generated, and for each of these states a further 5 successors are tried. All of these 25 partial solutions are expanded into complete solutions using the greedy heuristic.

The node leading to the best complete solution is retained as the root node for the second stage; this process is repeated for all the remaining stages. Assume that the partial solution S _3,12 leads to the best complete solution $S'_{3,12}$. The second stage then starts with S _3,12 as the root; this search tree has only 1 level, with w ₂=32 branches. Each of these branches are also expanded into complete solutions using the greedy heuristic. The move leading to the best solution (for instance $S'_{4,4}$) is selected as the choice for the branch corresponding to partition (2, 1) (in this case, it is S _2,3).

The move leading to the best solution out of all of the partitions in π is finally selected, and the block corresponding to that move is loaded into the container. This repeats until no further blocks can be loaded into the container, or until the allotted time runs out. If there is time remaining, then the algorithm restarts with the value of search_effort doubled from the previous run. Whenever a complete solution is generated, it is compared to the best solution found so far, and the best solution is updated if the new solution is better.