A fill-and-reduce greedy algorithm for the container pre-marshalling problem

Abstract

We address the Container Pre-Marshalling Problem (CPMP). The CPMP consists in ordering containers in stacks such that the retrieval of these containers is carried out without additional movements. The ordering has to be done in a minimum number of steps. Target-guided constructive heuristics report very good results in a short time. At each step, they select one poorly located container and rearrange it to an adequate position by a sequence of movements. The sequence of movements is generally generated by following a set of rules. In this work, we propose a different and more direct approach. Whenever possible, ordered stacks are filled by directly moving badly placed containers into them such that the containers become well placed. If it is not possible, then a stack is emptied or reduced to have more available slots, and the process is repeated. Unlike target-guided algorithms which rigidly adhere to a predefined sequence of movements for each badly placed container, our fill-and-reduce approach maintains the capacity to adapt to the evolving situation making choices based on the current state of the container stacks. The algorithm has shown superior performance compared to traditional target-guided heuristics, particularly in larger instances of classical benchmark sets. Furthermore, when embedded in a beam search algorithm, it reports the best results compared to traditional techniques that do not use machine learning.

Appendix A: Lemmas and proofs

Lemma 1

The method select_destination runs in time O(S).

Proof

In our implementation, stacks are implemented by using arrays and maintaining an auxiliary counter variable for storing the number of ordered items in each stack (i.e., the number of consecutive items with nonincreasing group values from the bottom to the top of the stack). Each time a move involving the stack is done, the related counter is accordingly updated in O(1) execution time. Using this variable, knowing if a stack is ordered is also performed in O(1) time (we only need to compare the counter with the number of items currently in the stack; if it is equal, then the stack is ordered; otherwise, it is unordered). Taking this into account, we note that the method select_destination has a time complexity of O(S) because each set (i.e., V,$X\!G_d$, $X\!B_d^1$, and $X\!B_d^2$) can be generated in linear time in the number of stacks and the calls to the method $\text {arg}\,\text {min}$ can also be performed in linear time in the size of these sets. $\square$

Lemma 2

The method select_BG_move has an execution time of $O(S^2)$.

Proof

The method has an execution time of $O(S^2)$ because it needs to compare group values for each valid BG move (which are at most $S^2$), and identifying BG moves is O(1) for each move because we simply need to verify that $s_o$ is unordered and $s_d$ is ordered (which is O(1) according to the proof of Lemma 1). $\square$

Lemma 3

The method reduction_move is performed in O(S) time.

Proof

Computing the height h(s) of a stack is O(1). Considering that each stack maintains the up-to-date sum of group values of its containers, computing the average group values is also O(1). Then, the selection of the stack is performed in O(S). As the method select_destination performs in O(S) time (according to Lemma 1), then the method reduction_move also has a time complexity of O(S). $\square$

Lemma 4

The method stopping_reduction_criterion runs in time O(S).

Proof

Consider that each container c stores the number $ub_c$ of unblocked bad-placed containers of its corresponding stack without taking into account the containers above c. This number can be updated in O(1) time each time a move is performed.⁵ Then, ub(s), i.e., $ub_c$ of the top container of s, can also be retrieved in O(1). Finally, each condition of the method stopping_reduction_criterion has an execution time of O(S) because they are required to perform O(1) instructions on, at most, each stack in the layout. $\square$

Proof of Theorem 1

The execution time of each iteration of the FRG algorithm is dominated by the procedure select_BG_move, which, according to Lemma 2, is $O(S^2)$. $\square$

Lemma 5

The method genSeq runs in time $O(h \log h)$, with $h=|C|$

Proof

Note that the time complexity of the while-loop of the method is linear in h. The method LDS is $O(h \log h)$, and if we use a classical $O(h \log h)$ sorting algorithm for generating $C'$, then the whole method also runs in $O(h \log h)$ time. $\square$

Lemma 6

The amortized time of assigning (or not) one container by using the method unblocking_assignment is $O(S+H\log H)$.

Proof

The method unblocking_assignment , in the worst case, performs $|C|=h$ calls to the method genSeq (each one resulting in a sequence of size $m=1$), which, according to Lemma 5, is $O(h \log h)$. As $m=1$, the execution time of the if-block in the method unblocking_assignment (Lines 7-15) is dominated by the method select_destination_seq, which, similar to the method select_destination (Lemma 1), runs in time O(S). Thus, the while-loop runs in worst-case time $O(h\cdot (S+h\log h))\le O(h\cdot (S+H\log H))$, with h being the number of elements to be assigned (or not). Finally, the amortized time of assigning (or not) one container is $O(S+H\log H)$. $\square$

Lemma 7

Each reduction move is performed by the method reduction_move_v2 in $O(S+H\log H)$ amortized time.

Proof

The method reduction_move_v2, in the worst case, calls unblocking_assignment first and, in further iterations, places the containers of $s_r$ in other stacks by using the method select_destination. According to Lemma 6, assigning (or not) one container runs in amortized time $O(S+H\log H)$. According to Lemma 1, selecting its destination runs in time O(S). Thus, each reduction move is performed in $O(S+H\log H)$ amortized time. $\square$

Proof of Theorem 2

The execution time of the FRG algorithm is dominated by the methods select_BG_move, which is $O(S^2)$ (Lemma 2), and reduction_move_v2, which is $O(S+H\log H)$ (Lemma 7). $\square$