The Optimization of Container Relocation in Terminal Yards: A Computational Study Using Strategy-Iterative Deepening Branch-and-Bound Algorithm

Abstract

Container relocation operations at terminal yards represent a fundamental pillar in the optimization of stowage scheduling during vessel loading, serving as a critical component of port operational efficiency. This paper focuses on the restricted container relocation problem (RCRP), in which the objective is to minimize the number of relocations for retrieving all containers from a bay under a predetermined retrieval sequence. A strategy-oriented algorithm (SOA) was proposed to address this issue, and a strategy-iterative deepening branch-and-bound algorithm (S-IDB&B) was constructed based on this algorithm. Among them, the SOA can quickly find feasible solutions to the problem, while the S-IDB&B algorithm can find the optimal solution to the problem and can also set an early stopping mechanism to obtain high-quality solutions in a shorter period of time. Comparative computational experiments demonstrate that the strategy-iterative deepening branch-and-bound algorithm finds optimal solutions for all small-scale instances within 0.01 s and achieves optimal solutions for over 80% of medium-to-large-scale instances, and it outperforms existing exact algorithms (solve larger scale instances with shorter computation time); moreover, when equipped with the early stopping mechanism, it yields higher solution quality than existing heuristic algorithms (the maximum accuracy deviation is around 20%) while maintaining comparable computation times.

1. Introduction

With the gradual increase in global maritime trade, port operators are increasingly prioritizing operational optimization in container terminals. The container yard, being a critical component, directly impacts terminal profitability through its operational efficiency. Given the scarcity of yard space, containers are temporarily stored in vertical stacks after being transported via vessels, rail, automated guided vehicles (AGVs), or trucks. A standard yard configuration consists of multiple container zones, each containing several bays. These bays are further subdivided into stacks where containers are physically stored. Figure 1 illustrates a typical container yard block layout.

Given the uncertainty in vessel arrival schedules during container stacking operations, terminal operators cannot fully predict container departure sequences [1]. This unpredictability often leads to misalignment between initial stacking orders and actual retrieval sequences—for instance, containers requiring early departure may be stacked beneath those with later schedules. Such scenarios necessitate relocation operations where upper containers (with later schedules) must be moved to adjacent stacks to access priority containers below [2], as illustrated in Figure 2 depicting intra-bay relocation processes.

Container prioritization follows numerical identification, with lower-numbered units receiving higher retrieval priority. In Figure 2, retrieving Container 1 requires the preliminary relocation of Containers 8 and 5. The strategic selection of relocation positions proves critical [3], as improper choices may trigger cascading relocation demands.

In response to national strategies for developing advanced productive capacities, global container terminals have accelerated intelligent transformation while expanding yard capacities. However, these advancements paradoxically intensify the computational complexity of container relocation problems, which now exhibit exponential growth patterns with increasing terminal intelligence and yard scale. This emerging challenge has become a critical bottleneck in terminal operations. Reducing the number of container relocations directly translates into crucial operational advantages for terminals, including lower fuel consumption for handling equipment, decreased operational costs, and faster vessel turnaround times. Therefore, developing efficient algorithms for container relocation optimization is imperative to enhance operational efficiency through minimized relocation frequency and optimized decision-making processes.

The remaining part of this paper is arranged as follows: Section 2 reviews the relevant literature on dealing with the container relocation problem. Section 3 briefly describes the restricted container relocation problem and mathematical model studied in this paper. Section 4 introduces a heuristic algorithm for quickly solving the RCRP, which is used for the upper-bound calculation of the algorithm in Section 5. Section 5 introduces the strategy-iterative deepening branch-and-bound algorithm for solving the RCRP. Section 6 presents the computational experimental results and analysis of the algorithm proposed in this paper on both random and benchmark datasets. Section 7 summarizes this paper and provides some future research directions.

2. Literature Review

For decades, scholars have maintained unwavering enthusiasm in researching the Container Relocation Problem (CRP). Lersteau and Shen [4] systematically categorized existing research into the Unrestricted Container Relocation Problem (UCRP) and restricted container relocation problem (RCRP) based on container movement constraints. They further classified the CRP into duplicate priorities and unique priorities according to container numbering (priority) uniqueness. This section reviews existing CRP resolution methodologies, which are broadly categorized into heuristic algorithms and exact algorithms.

We first introduce heuristic algorithms for solving the Container Relocation Problem (CRP), as König and Lübbecke [5], Felsner and Pergel [6], and Caserta et al. [7] have demonstrated through their research that this problem belongs to the NP-Hard class. Consequently, researchers have actively explored and developed heuristic algorithms aimed at substantially reducing computational time without significantly compromising solution quality, thereby effectively addressing large-scale and complex CRP instances. Expósito-Izquierdo et al. [8] proposed a domain-specific knowledge-based heuristic algorithm for restricted container relocation problems. This algorithm iteratively attempts to construct an improved feasible solution within predefined iteration limits, while its heuristic search direction prioritizes nodes where target containers have been retrieved and subsequent relocation operations are minimized during the solution construction process. Caserta et al. [9] pioneered the successful application of the Corridor Method to the CRP by integrating dynamic programming as a sub-algorithm, where exogenous constraints strategically reduced solution space dimensionality while maintaining efficacy in large-scale instances. Jovanovic et al. [10] developed a generalized Ant Colony Optimization (ACO) algorithm applicable to both constrained and unconstrained CRP variants, employing greedy strategies with localized bay-state information storage and a novel Pheromone Matrix formulation to minimize yard crane operational duration. He et al. [11] proposed a hybrid algorithm that combines heuristic rules with parallel genetic algorithm and conducted simulation experiments. If each bay configuration is considered as a node, and each feasible container relocation operation between two bay configurations is regarded as an edge, then the container relocation problem is transformed into a shortest path problem on a graph [12]. Given the prohibitively large vertex count in the obtained undirected graph, Yi et al. [13] introduced a Pulse-Coupled Neural Network (PCNN) to circumvent limitations of conventional shortest-path algorithms. Zhu et al. [14] formulated an optimization model targeting minimal relocation operations while incorporating yard crane movement costs, proposing three search evaluation strategies solved via a Beam Search algorithm. Caserta et al. [7] developed the Min–Max algorithm by prioritizing target relocation stacks through comparative analysis of candidate placement stack priorities and pending relocation urgencies. Forster and Bortfeldt [15] designed a tree search-based algorithm that evaluates branching options through greedy principles to identify optimal search pathways. Jin et al. [16] devised an enhanced greedy look-ahead heuristic for the Unrestricted CRP, featuring a tri-layer architecture, a greedy-driven top layer, a tree search-based middle layer generating relocation strategies, and a heuristic rule-embedded bottom layer evaluating leaf nodes, demonstrating superior scalability in large-scale scenarios. Feillet et al. [17] developed a refined local search heuristic that strategically defines state spaces and employs dynamic programming to identify locally optimal container relocation sequences. Yang et al. [18] established a rule-based system for container relocation, where decision-making strictly adheres to predefined priority criteria, with benchmark dataset evaluations demonstrating robust algorithmic performance. Tricoire et al. [19] introduced the SM-2 rapid heuristic for the unconstrained CRP, capable of processing large-scale instances within seconds, with empirical validation showing superior efficacy on standardized test cases. Chen et al. [20] designed a directed search algorithm utilizing rule-scoring prioritization, exhibiting exceptional scalability in constrained CRP scenarios. Furthermore, metaheuristic frameworks including Tabu Search [21,22,23], Beam Search [24,25,26], Genetic Algorithms [27,28], and Simulated Annealing [29,30] have been adapted to address the CRP and related combinatorial challenges. In summary, existing methodologies can be categorized into domain-specific knowledge-driven heuristics and metaheuristic architecture-based approaches.

Next, we will introduce the exact algorithm for solving the CRP, with mathematical programming approaches that formalize the problem into precise mathematical formulations serving as foundational frameworks for subsequent methodologies. Research in this domain primarily involves constructing mathematical programming models (e.g., Mixed-Integer Programming (MIP) and Constraint Programming (CP)) through a rigorous analysis of optimization objectives and constraints, with solver-based implementations or numerical experiments employed to validate model fidelity and computational complexity. For instance, Caserta et al. [7] formulated BRP-I and BRP-II models; they are both binary integer programming models, with the former indicating that free relocating is allowed and possessing a complete feasible region, while the latter reduces the feasible region by adding the assumption of reality that free relocating is not allowed, so they represent the Unrestricted CRP (UCRP) and Restricted CRP (RCRP) variants, respectively. Zehendner and Feillet [31] advanced this paradigm by decomposing the BRP-II model into master and pricing subproblems via column generation, proposing a branch-and-price algorithm for the RCRP that achieves tighter dual bounds and resolves small-scale instances with reduced column counts and iteration cycles. Zehendner et al. [32] streamlined the BRP-II model by eliminating redundant variables and parameters while refining and tightening operational constraints to develop the enhanced BRP-II-A variant capable of resolving instances exceeding 25 containers. Boysen and Emde [33] formalized the parallel stack storage problem with fundamental complexity proofs, subsequently deriving Mixed-Integer Programming (MIP) formulations aligned with distinct optimization objectives. Le and Knust [34] addressed the stack storage problem under height constraints by establishing an MIP framework that minimizes stack utilization under uncertain stacking constraints.

While mathematical programming approaches enable exact solutions for the CRP and related problems, their applicability is constrained by instance size limitations and exponentially increasing computational demands [35,36]. Consequently, scholars have developed branch-and-bound frameworks integrating heuristic-derived upper bounds and problem-specific relaxation lower bounds to establish tree-search-based exact algorithms. Kim and Hong [37] proposed depth-first branch and bound with backtracking for the restricted CRP with duplicate priorities, incorporating practical constraints of destination-based container grouping by attributes like size and weight. Expósito-Izquierdo et al. [38] devised a best-first branch-and-bound algorithm employing intelligent node selection strategies to balance solution quality and optimality guarantees for multi-priority restricted CRP scenarios. Zhu et al. [39] pioneered the application of iterative deepening A* (IDA*) to CRP, leveraging its low memory footprint and computational efficiency to address large-scale instances. Tanaka and Takii [40] enhanced IDA* through tighter lower-bound formulations, significantly accelerating exact solutions for restricted CRP variants. These branch-and-bound-based exact algorithms provide theoretically optimal solutions, establishing critical benchmarks for advancing CRP research.

In addition, some researchers have attempted to apply machine learning and reinforcement learning methods to solve the Container Relocation Problem (CRP). Ye et al. [41] identified 22 key features influencing the number of relocation moves and employed various machine learning methods to validate the relationships between critical relocation features and the number of relocations using unrestricted Block Relocation Problem (BRP) and restricted BRP models. Tang et al. [42] further addressed the challenges posed by the stochastic nature of container dwell times in three-dimensional stacking yards. They proposed a two-stage approach integrating historical data-driven predictions of container extraction dates and deep reinforcement learning (DRL) to optimize relocation strategies.

In summary, the main challenge in solving the CRP lies in how to balance the quality and speed of the solution in large-scale cases. Exact methods based on mathematical programming rely heavily on the accuracy of the model and often require a long solving time, while existing heuristic methods, although fast, struggle to guarantee the quality of the solution. To address the scarcity of simultaneously rapid and exact algorithms in prior literature, this paper proposes a strategy-iterative deepening branch-and-bound (S-IDB&B) algorithm with three key innovations:

(1)

A refined lower-bound estimation method was developed to enhance node potential evaluation, enabling the earlier identification of unpromising branches through amplified lower-bound differentiation, coupled with two dominance rules to facilitate the pruning of unpromising branches, thereby reducing search space and improving algorithmic efficiency.

(2)

The algorithm incorporates a proactive probe mechanism, and the proposed strategy-oriented algorithm can quickly calculate a more powerful (tighter) upper bound. At the same time, the algorithm optimized the node search order (considering both the current node state and future container relocate conditions) to accelerate convergence.

(3)

Algorithms can set truncation conditions to achieve early stopping, breaking the binary opposition pattern where precise algorithms are equal to “slow but accurate” and heuristics are equal to “fast but secondary”. This allows precise algorithms to be adjusted to “accurate but fast”, providing a new paradigm for the practical application of precise algorithms in industrial scenarios.

The first two innovative points mentioned above make the proposed strategy-iterative deepening branch-and-bound algorithm more capable of accurately solving the CRP compared to traditional branch-and-bound algorithms, while the last point makes the proposed exact algorithm still competitive compared to existing heuristic algorithms and even more efficient in solving performance.

3. Problem Description and Optimization Model

3.1. Problem Description

This paper focuses on the Container Relocation Problem (CRP) within a single bay configuration. As depicted in Figure 3 (cross-sectional visualization), the bay structure organizes containers spatially through horizontal stacks and vertical tiers, and “slot” represents the coordinates of the container in bay.

The retrieval sequence follows an ascending numerical priority system where lower-numbered containers need to leave the bay earlier. A critical operational challenge arises when target containers (e.g., Container #1) are obstructed by blocking containers (e.g., #8 and #5 in Stack 4), necessitating their strategic relocation to alternate stacks. When the target container is not obstructed, it can be directly transferred (this operation is called “retrieve”) to a horizontal transport vehicle (such as a container truck) to participate in the next operational stage of the terminal. The CRP optimization objective centers on determining the minimal sequence of relocation operations required to systematically retrieve all containers from their initial stacked configuration while adhering to strict priority constraints.

Obviously, the container relocation operation is performed for the containers located at the top of the bay. Here, it should be noted that this paper studies the restricted container relocation problem (RCRP), where the containers to be relocated are not freely selected from the top of the berth, but only the obstacle container located at the top of the stack where the current target container is located can be selected until the current target container has been retrieved, and then the obstacle container of the stack where the next target container is located will be selected accordingly for relocation.

3.2. Optimization Model

Section 3.1 establishes that this paper researches the fundamental classical RCRP, with a primary focus on algorithmic innovations. The proposed methodology fundamentally differs from mathematical programming-based approaches that rely on precise mathematical modeling (using commercial solvers to solve established mathematical programming models), thus adopting the classical mathematical model from reference [20]. As a classic model in the field of the RCRP, it can characterize the application scenario of restricted relocation in single bay.

3.2.1. Model Assumption

The following assumptions are made for the model:

(1)

There are unique container identifiers within the bay, eliminating duplicate numbering.

(2)

There is strict adherence to predefined retrieval sequences without deviation.

(3)

There is stack height compliance with maximum tier capacity constraints.

(4)

Only topmost blocking containers above the current target are eligible for relocation until target container has been retrieved, after which subsequent target stacks become active.

(5)

All operations of container relocation and retrieve occur within the same bay.

(6)

There are standardized container dimensions ensuring spatial uniformity.

3.2.2. Notations

The notations of the model are shown in

Table 1. RCRP model symbol definition.

Notation	Description of Notation
$S$	set of stack s, indexed from 1 to S
$H$	set of tier h, indexed from 1 to H
$N$	set of container number n, indexed from 1 to N
$T$	set of container’s retrieve stage t, each stage containing one or more container relocation operation (nonessential) and one retrieve operation (essential), indexed from 1 to T

and

Table 2. Decision variables.

Notation	Description of Notation
$e_{sh}^{n,t}$	If container n is located in a slot in stage t, it is 1; otherwise, it is 0
$r_{sh, s^{\prime } h^{\prime }}^{n,t}$	If container n is relocated from slot (s, h) to (s′, h′) in stage t, it is 1; otherwise, it is 0
$l_{s,h}^{n,t}$	If the container n is retrieved from slot (s, h) in stage t, it is 1; otherwise, it is 0
$f_{n,t}$	If container n has been retrieved in stage t, it is 1; otherwise, it is 0

.

3.2.3. Model Establishment

Objective function:

$$\mathit{min} Z={\displaystyle \sum _{s=1}^S{\displaystyle \sum _{h=1}^H{\displaystyle \sum _{ s^{\prime }=1}^S{\displaystyle \sum _{ h^{\prime }=1}^H{\displaystyle \sum _{n=1}^N{\displaystyle \sum _{t=1}^T{r}_{\mathit{sh}, s^{\prime }{h}^{\prime }}^{n,t}}}}}}}$$

(1)

Constraints:

$${\displaystyle \sum _{s=1}^S{\displaystyle \sum _{h=1}^H{e}_{\mathit{sh}}^{n,t}+f_{n,t}=1,\forall n\in N,t\in T}}$$

(2)

$$f_{n,t}={\displaystyle \sum _{s=1}^S{\displaystyle \sum _{h=1}^H{\displaystyle \sum _{ t^{\prime }=1}^{t-1}{l}_{\mathit{sh}}^{n, t^{\prime }}}}},\forall n\in N,t\in T$$

(3)

$${\displaystyle \sum _{n=1}^N{e}_{\mathit{sh}}^{n,t}}\le 1,\forall s\in S,h\in H,t\in T$$

(4)

$${\displaystyle \sum _{n=1}^N{e}_{s\left(h+1\right)}^{n,t}}\le {\displaystyle \sum _{n=1}^N{e}_{\mathit{sh}}^{n,t}},\forall s\in S,h\in \{1\dots ,H-1\},t\in T$$

(5)

$$e_{\mathit{sh}}^{n,t}=e_{\mathit{sh}}^{n,t-1}-{\displaystyle \sum _{ s^{\prime }=1}^S{\displaystyle \sum _{ h^{\prime }=1}^H{r}_{\mathit{sh} s^{\prime }{h}^{\prime }}^{n,t-1}}}+{\displaystyle \sum _{ s^{\prime }=1}^S{\displaystyle \sum _{ h^{\prime }=1}^H{r}_{ s^{\prime }{h}^{\prime }\mathit{sh}}^{n,t-1}-l_{\mathit{sh}}^{n,t-1},\forall s\in S,h\in H,n\in N,t\in T}}$$

(6)

$$M(1-{\displaystyle \sum _{n=1}^N{r}_{\mathit{sh}, s^{\prime }{h}^{\prime }}^{n,t}})\ge {\displaystyle \sum _{n=1}^N{\displaystyle \sum _{x=h+1}^H{\displaystyle \sum _{y=h^{\prime }+1}^H{r}_{\mathrm{sx}, s^{\prime }y}^{n,t}}}},\forall s, s^{\prime }\in S,h, h^{\prime }\in H,t\in T,M\to \infty$$

(7)

$$M(1-{\displaystyle \sum _{h=1}^H{e}_{\mathit{sh}}^{t,t}})\ge {\displaystyle \sum _{n=1}^N{\displaystyle \sum _{h=1}^H{\displaystyle \sum _{ s^{\prime }=1}^S{\displaystyle \sum _{ h^{\prime }=1}^H{r}_{ s^{″}h, s^{\prime }{h}^{\prime }}^{n,t}}}}},\forall s\in S,t\in T, s^{″}\in S\backslash \left\{s\right\},M\to \infty$$

(8)

$$r_{\mathit{sh},s{h}^{\prime }}^{n,t}=0,\forall s\in S,h, h^{\prime }\in H,n\in N,t\in T$$

(9)

Equation (1) is the objective function with the optimization goal of minimizing the total number of relocation. Constraint (2) ensures that at any stage, any container is either stored in a bay or has been retrieved. Constraint (3) ensures that if there is a retrieve operation on container n before stage t, container n will no longer be stored in the bay during stage t. Constraint (4) ensures that at any stage, a maximum of one container can be stored in any container slot. Constraint (5) ensures that no container is allowed to be suspended in any position at any stage. Constraint (6) indicates that whether container n is stored in container slot (s, h) at the beginning of stage t is determined by the initial position of the container in the previous stage, as well as the subsequent relocation and retrieve situations. This ensures that each container follows the logic of relocating and retrieving during the transition from stage t − 1 to stage t. Constraint (7) ensures that containers undergoing prior relocation operations within the same stage cannot be positioned directly above subsequently relocated containers. Constraint (8) ensures that only when all the blocking containers above the target container n have been relocated in the current stage t can the blocking container above the next target container be relocated. Constraint (9) ensures that a blocking container can only be relocated to other stacks.

This paper naturally encoded the stacking state, operations (relocate and retrieve), and related constraints using a tree search-based method. Among the tree, the root node corresponds to the initial stacking state of containers in the bay, the leaf nodes correspond to the bay clearance state, and the edges between nodes correspond to feasible container relocate actions. The goal is equivalent to finding the shortest path from the root node to the leaf node.

4. Strategy-Oriented Algorithm

The strategy-oriented algorithm can quickly find a reasonable and feasible solution through a set of container relocation strategies, which can serve as an upper bound for the strategy-iterative deepening branch-and-bound algorithm. For the convenience of describing the container relocation strategy, it is first necessary to define some related concepts.

Let $n^r$ denote the blocking container above the target container that is waiting to be relocated. Let $s^{\mathit{can}}$ represents the stack with stacking vacancies in the bay, except for the stack where blocking container $n^r$ is located. Let $s^{\mathit{dst}}$ denote the final destination of container $n^r$. Let $q^s$ denote the support capability of stack s, which is numerically equal to the smallest container number among all the containers stacked on the stack, and $q^s$ of an empty stack is infinite. Let $n^g$ denote the containers with higher priority than all the containers under it, and the container at the bottom of the bay is also considered $n^g$. Let $n^b$ denote the containers other than $n^g$. Let $s^g$ denote $s^{\mathit{can}}$ with $q^s$ greater than the number of $n^r$, and let $s^b$ denote the stack other than $s^g$.

Based on the above definition, the container relocation strategy is described as follows.

Strategy 1: If the current $n^r$ can be converted into $n^g$ through the relocation operation, that is, there is $s^g$ in $s^{\mathit{can}}$, then choose to relocate it to $s^g$ with $q^s$ just greater than the number of $n^r$, without occupying other $s^g$ with larger $q^s$.

Strategy 2: If $n^r$ cannot be converted into $n^g$, that is, there is no $s^g$ in $s^{\mathit{can}}$, further determination of the current configuration of the bay is required, which can be divided into Situation A and Situation B. Situation A refers to the existence of two or more unfilled $s^b$, and $s^b$ with the highest $q^s$ is only one container away from being filled. Situation B refers to all situations except for Situation A. If the current configuration of the bay meets Situation A, choose $s^b$ with the second largest $q^s$ as $s^{\mathit{dst}}$; otherwise, choose $s^b$ with the largest $q^s$ as $s^{\mathit{dst}}$.

Algorithm 1 gives the pseudocode for the strategy-oriented algorithm, and Figure 4 gives the flow chart for the strategy-oriented algorithm.

Algorithm 1. Strategy-Oriented Algorithm (SOA)

$1: \mathrm{function} \mathit{SOA}: \mathit{num}\leftarrow 0$; $2: \mathit{target},n^r,n^b,q^s\leftarrow \mathit{checkconf}\left(\right)$ $3: \mathrm{while} \left(\right|n^b|>0)$: $4: \mathrm{if} \left(\right|n^r|>0)$: $5: \hspace{1em} \mathrm{if} \mathit{configuration} \mathit{satisfy} \mathit{strategy}1$$:n^b$$- -, \mathit{num}$$+ +,\mathit{relo}1\_\mathit{upd}\left(\right)$; 6:      else: $7: \hspace{1em}\hspace{1em} \mathrm{if} \mathit{configuration} \mathit{satisfy} \mathit{situationA}$$:\mathit{num}$$+ +,\mathit{reloa}\_\mathit{upd}\left(\right)$; $8: \hspace{1em}\hspace{1em} \mathrm{else}: \mathit{num}$$+ +, \mathit{relob}\_\mathit{upd}\left(\right)$; $9: \mathrm{else}: \mathit{retri}\_\mathit{upd}\left(\right)$; $10: \mathrm{return} \mathit{num}$;

The strategy-oriented algorithm implementation process is as follows. After inputting the CRP instance, the first step is to initialize the number of relocation to 0 (line 1). Then determine the target container, $n^b$, $n^r$, $q^s$ and other information by function “checkconf()”, and enter a loop with the goal of retrieving all the containers in the bay. As long as the number of $n^b$ is greater than 0, it means that the goal has not been completed. The internal loop is the relocation strategy, and the algorithm will execute the corresponding relocate actions through functions “relo1_upd()”, “reloa_upd()”, and “relob_upd()”, which represent executing the process according to strategy 1, executing it according to strategy 2 Situation A, and executing it according to strategy 2 Situation B, respectively. And “retri_upd()” represents retrieving the target container. The algorithm keeps running until the goal is achieved and finally returns the number of relocation.

5. Strategy-Iterative Deepening Branch-and-Bound Algorithm

With the increasing scale of automated container terminals, the solution space of the CRP is growing exponentially, making it difficult for traditional branch-and-bound algorithms to efficiently solve large-scale problems in a short period of time. Therefore, this paper proposes a strategy-iterative deepening branch-and-bound algorithm, which integrates the idea of branch-and-bound with an iterative deepening search. Compared with traditional branch-and-bound algorithms, it has the following significant characteristics: Firstly, it sets a search depth threshold, limits the tree depth, avoids the excessive exploration of invalid nodes, and significantly reduces the search space. Secondly, the algorithm introduces dominance rules to identify equivalent nodes and non-optimal branches, thereby reducing redundant calculations. Finally, the node search order is prioritized according to predetermined rules, focusing on high potential nodes to improve optimization efficiency.

5.1. Upper and Lower Bound

In the strategy-iterative deepening branch-and-bound algorithm, each branch node corresponds to a container stacking situation, and each branch corresponds to a feasible container relocation. This paper uses a triplet (c, s, d) to represent it, such as (5, 5, 6), which represents the movement of container 5 from stack 5 to stack 6. As shown in Figure 5, the blocking container (container 5) above the target container (container 1) has five feasible relocations, forming five branches and corresponding branch states.

The upper bound of the branch node represents the feasible number of relocations for retrieving all containers at that node. When solving the upper bound of the root node and probing the node (see Section 5.3), the SOA proposed in this paper is used for the solution.

The lower bound of a branch node represents the minimum number of relocations for retrieving all containers at that node, which is composed of the number of $n^b$ and the estimated value of the blocking container caused again during the relocation. As shown in Figure 6, each blocking container (highlighted in yellow) at this node obstructs the container with higher priority. Due to the need to retrieve the containers in order, these blocking containers must be relocated first, so this type of relocation is referred to as forced relocation.

If $n^b$ cannot be converted to $n^g$ after relocation, it means that it has caused obstacles again and needs to be relocated again. As shown in Figure 7, no matter which stack container 16 is relocated to, it is still $n^b$ and must be relocated again.

It is worth noting that when container 9 is relocated to stack 3, it may seem like it can be converted to $n^g$, but the prerequisite is that the support capacity of stack 3 in the previous stage has not deteriorated and container 8 in the previous stage has destroyed the original support capacity of stack 3, resulting in container 9 actually needing to be relocated again, and this type of relocation is referred to as additional relocation.

To establish a tight lower bound, estimating additional relocation counts necessitates accounting for the dynamic variation in $q^s$ across stacks during container relocation operations. While an exhaustive enumeration of minimal additional relocation scenarios is theoretically possible, this approach inevitably compromises computational efficiency. To balance lower bound estimation tightness with computational efficiency, this paper applies a relaxation approach when calculating the lower bound of a node; if the node has a stack that is not fully stacked, it is assumed that the stack height of the stack is unlimited. Algorithm 2 gives the pseudocode for the lower-bound algorithm, and Figure 8 gives the flow chart for the lower-bound algorithm.

Algorithm 2. Lower-Bound Algorithm

1: function LowerBound: $\mathit{LB}\leftarrow 0$, $\mathit{forcedrelo}\leftarrow 0$, $\mathit{addirelo}\leftarrow 0$; 2:   function $\mathit{countfr}\left(\mathit{node}\right)$ 3:     for: each stack in bay 4:     for:  each tier in stack 5:       if find $n^b$: $\mathit{forcedrelo}$++; 6:     end for 7:    end for 8:    function $\mathit{countar}\left(\mathit{node}\right)$ 9:     for: each $n^r$ above target container 10:     if ($n^r>q^s\_\mathit{max}$): $\mathit{addirelo}$++; 11:     else: $s^{\mathit{dst}}=\mathit{argmi}{n}_{s\in s^g}\left\{\right|q^s-n^r\left|\right\}$,update($\mathit{node}$); 12:     if current target container has been retrieved:        determine the next target container, $\Rightarrow$ line 9; 13:   end for 14:   return $\mathit{LB}=\mathit{forcedrelo}+\mathit{addirelo}$;

The lower-bound algorithm implementation process is as follows. After inputting the CRP instance, the first step is to calculate the count of forced relocation, and the function “countfr” in the pseudocode is used to traverse all containers in the bay to determine the count of $n^b$, denoted as “forcedrelo”. The second step is to calculate the count of additional relocation. The function “countar” is used to traverse all $n^r$. If $n^r$ can be converted to $n^g$, it means that there must be $s^g$ in $s^{\mathit{can}}$. It is then relocated to the stack with the smallest $q^s$ and the $q^s$ of the stack is updated. If $n^r$ cannot be converted to $n^g$, it means that any relocation will not change the $q^s$ of the stack, the count of additional relocation is incremented by 1 and $n^r$ is marked as processed. When all $n^r$ are marked as processed, the algorithm ends and finally returns the sum of forced relocation and additional relocation as the lower bound of the node.

5.2. Iterative Deepening Framework

The iterative deepening framework is described as follows. After inputting the CRP instance, check if the node is the simplest (a stacking state where there is no target container located at the top level, which means that there is no target container that can be directly retrieved). If not, retrieve the containers that can be directly retrieved from the bay. Subsequently, invoke the SOA and lower-bound algorithm to compute the current optimal solution, $s^{\mathit{best}}$, and search threshold, $\mu$, respectively. If the two are equal (indicating the convergence of the upper and lower bounds), the optimal solution is confirmed and returned. Otherwise, initiate the depth-limited tree search (DLTS) constrained by the search threshold to explore the solution space for the optimal solution. If it cannot be found under this threshold, increment the search threshold and repeat the process until termination conditions are satisfied. Algorithm 3 provides the pseudocode of the iterative deepening framework.

Algorithm 3. Iterative deepening framework

$1:\mathrm{function} \mathit{crpmain}({\mathit{bay}}^{input})$; $2: \hspace{1em}{\mathit{bay}}^0\leftarrow \langle {\mathit{bay}}^{\mathit{input}}\rangle$; $3: \hspace{1em}\mu \leftarrow \mathit{LowerBound}({\mathit{bay}}^0)$; $4: \hspace{1em}{s}^{\mathit{best}}\leftarrow \mathit{SOA}({\mathit{bay}}^0)$; 5:      loop $6: \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\mathrm{if}(\mu =|s^{\mathit{best}}|$$): \mathrm{return} s^{\mathit{best}}$; $7: \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\mathrm{else}: (\mathit{sign},s^{\mathit{best}})\leftarrow \mathit{DLTS}(p,\mathit{bay},\mu ,s^{\mathit{best}})$; $8: \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\mathrm{if}(\mathit{sign}$$): \mathrm{return} s^{\mathit{best}}$; $9: \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\mathrm{else}: \mu$++;

And the pseudocode can be represented as the algorithm flow chart shown in Figure 9.

5.3. Depth-Limited Tree Search

As aforementioned (Section 5.2), when the computed upper bound fails to converge with the lower bound, the algorithm initiates a depth-limited tree search that aims to identify a solution whose objective function value precisely matches the lower bound, thereby proving its optimality. Even if no optimal solution is found within the search threshold, DLTS continues to iteratively refine the incumbent optimal solution. The depth-limited tree search is implemented via the recursive search function DLTS, as show in Algorithm 4. The function accepts four input parameters: parameter $p^{\prime }$ stores the container relocation path from the root node to the current node, formatted as [(c, s, d), …]; parameter ${\mathit{bay}}^{\mathit{lay}}$ denotes the current node state (container distribution configuration); parameter $\mu$ represents the search threshold for the current iteration, which corresponds to the global lower bound of the problem; and parameter $s^{\mathit{best}}$ denotes the incumbent optimal solution.

Algorithm 4. Depth-Limited Tree Search

$1: \mathrm{function} \mathit{DLTS}(p,{\mathit{bay}}^{\mathit{lay}},\mu ,s^{\mathit{best}})$ $2: \mathit{Branches}\leftarrow Ø$; $3: \mathrm{for} \mathrm{each} (\mathrm{c}, \mathrm{s}, \mathrm{d}) \mathrm{to} {\mathit{bay}}^{\mathit{lay}}$ do $4: \hspace{1em}\hspace{1em}{p}^{\prime }\leftarrow p\cup [(c,s,d)]$; $5: \hspace{1em}\hspace{1em}\mathrm{if}(\mathit{bedomin}\left(p^{\prime }\right)$): continue $6: \hspace{1em}\hspace{1em}\mathrm{else}: {\mathit{bay}}^{{\mathit{lay}}^{\prime }}\leftarrow 〈{\mathit{bay}}^{\mathit{lay}}\cup (c,s,d)〉$; $7: \hspace{1em}\hspace{1em}\mathrm{if}(\mathit{isleaf}({\mathit{bay}}^{{\mathit{lay}}^{\prime }})$$): \mathrm{return} (\mathrm{True},s^{\mathit{best}}$); $8: \hspace{1em}\hspace{1em}{\mathit{lb}}^{\prime }\leftarrow \mathit{LowerBound}({\mathit{bay}}^{{\mathit{lay}}^{\prime }})$; $9: \hspace{1em}\hspace{1em}{f}^{\mathrm{est}}({\mathit{bay}}^{{\mathit{lay}}^{\prime }})\leftarrow {\mathit{lb}}^{\prime }+\left|p^{\prime }\right|$; $10: \hspace{1em}\hspace{1em}\mathrm{if} (f^{\mathrm{est}}({\mathit{bay}}^{{\mathit{lay}}^{\prime }})>\mu$): continue; $11: \hspace{1em}\hspace{1em}\mathrm{if}(\mathit{probecond}({\mathit{bay}}^{{\mathit{lay}}^{\prime }})$$): s^{\mathit{cpl}}\leftarrow p^{\prime }\cup \mathit{SOA}({\mathit{bay}}^{{\mathit{lay}}^{\prime }})$; $12: \hspace{1em}\hspace{1em}\hspace{1em}\mathrm{if}\left(\right|s^{\mathit{cpl}}|<|s^{\mathit{best}}|$$):s^{\mathit{best}}\leftarrow s^{\mathit{cpl}}$; $13: \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\mathrm{if}\left(\right|s^{\mathit{best}}|=\mu$$): \mathrm{return} s^{\mathit{best}}$; $14: \hspace{1em}\hspace{1em}\mathit{Branches}\leftarrow \mathit{Branches}\cup \left\{\right(c,s,d,{\mathit{lb}}^{\prime }\left)\right\}$; 15:     end for $16: \mathit{Branches}\leftarrow \mathit{reorder}(\mathit{Branches},{\mathit{lb}}^{\prime },q^d)$ $17: \hspace{1em}\hspace{1em}\mathrm{for}: \mathrm{each} \mathrm{branches} \mathrm{in} \mathit{Branches}$ $18: \hspace{1em}\hspace{1em}\hspace{1em}{p}^{\prime }\leftarrow p\cup [(c,s,d)]$; $19: \hspace{1em}\hspace{1em}\hspace{1em}{\mathit{bay}}^{{\mathit{lay}}^{\prime }}\leftarrow 〈{\mathit{bay}}^{\mathit{lay}}\cup (c,s,d)〉$; $20: \hspace{1em}\hspace{1em}\hspace{1em}(\mathit{sign},s^{\mathit{best}})\leftarrow \mathit{DLTS}(p^{\prime },{\mathit{bay}}^{{\mathit{lay}}^{\prime }},\mu ,s^{\mathit{best}})$; $21: \hspace{1em}\hspace{1em}\hspace{1em}\mathrm{if}(\mathit{sign}$$): \mathrm{return} (\mathit{true},s^{\mathit{best}}$); $22: \hspace{1em}\hspace{1em}\hspace{1em}\mathrm{else}: \Rightarrow$ line 17; 23:          end for $24: \mathrm{return} (\mathit{false},s^{\mathit{best}}$);

Lines 2–15 implement a dual-pruning mechanism: eliminating dominated branches (relocation path) through dominance rules (the function “bedomin” will check whether the relocation path will be dominated) and discarding nodes with evaluation values exceeding the threshold within the current search iteration. This two-stage filtration process preserves only the most promising branches with potential to reach optimal solutions. Initially, a branch set, $\mathit{Branches}$, is created for the current node, ${\mathit{bay}}^{\mathit{lay}}$, followed by an enumeration of feasible container relocation (c, s, d) to generate child nodes. If the relocation path, $p^{\prime }$, corresponding to the child node is not dominated and the evaluation value, $f^{\mathrm{est}}$, of the child node does not exceed the search threshold, $\mu$, then the branch will be retained and stored in the branch set. The node evaluation value set in this paper consists of its lower bound and the number of relocation from the root node to it. The algorithm divides the branch tree into layers of different “depths” based on the node evaluation value, and each search iteration exclusively explores nodes whose evaluation values fall within the current search threshold; this approach effectively implements a depth-limited search through evaluation-based constraints.

In addition, the algorithm continuously verifies during child node generation whether a leaf node is reached, indicating the discovery of the optimal solution and triggering immediate termination. At the same time, if the child node satisfies the probing conditions (the function “probecond” will check whether the node meets the probing conditions), it will call the SOA to combine with the historical relocation path to obtain the complete solution, $s^{\mathit{cpl}}$. And if its objective function value can meet the search threshold, the algorithm can be immediately terminated. This is the original intention of setting an proactive probing mechanism in this paper. The probing conditions are set as follows.

Probing condition 1:

$$f^{est} =\mu -1$$

(10)

This condition ensures that each node is only probed once (when and only when it is visited for the second time), avoiding the time consumption caused by repeated calls.

Probing condition 2:

$$g^{\mathit{est}}\mathit{ }=\mathit{\gamma }\times {\displaystyle \frac{n_{n\_\mathit{cur}}^b}{n_{n\_\mathit{ini}}^b}}+(1-\mathit{\gamma })\times {\displaystyle \frac{n_{n\_\mathit{cur}}}{n_{n\_\mathit{ini}}}}<\mathit{\delta }-\mathit{\epsilon }\times {\displaystyle \frac{{\mu }^{\mathit{cur}}-{\mu }^0}{\mathit{SOA}({\mathit{bay}}^0)-{\mu }^0}}$$

(11)

It should be noted that probing condition 2 is a condition set on the basis of condition 1, and it implements secondary evaluation for nodes within the same depth layer. Metric $g^{\mathit{est}}$ is composed of the ratio of $n^b$ count and the ratio of container count, both between the current node and the root node, and parameter $\mathit{\gamma }$ is a weight used to balance the relative importance of these two ratios. We believe that the smaller the value of $g^{\mathit{est}}$, the higher the probability of discovering the optimal solution for that node. We only probe nodes with $g^{\mathit{est}}$ not greater than the probing threshold. Considering that the deeper the node, the more concise the corresponding distribution of the bay, we also reduce the probing threshold accordingly. We set it in the form of the right-hand equation in Equation (11), where parameter $\mathit{\delta }$ represents the upper limit of the probing threshold and parameter $\mathit{\epsilon }$ controls the speed at which the probing threshold decreases. These parameters will be defined and analyzed later (Section 6.3).

The advantage of setting probing condition 2 is that calling the SOA for probing itself can be time-consuming, while setting probing condition 2 can minimize unnecessary calls and reduce algorithm runtime as much as possible.

And the schematic diagram of the DLTS process is shown in Figure 10.

Line 16 sorts the previously selected branches. We hope that the exploration order of the nodes is not arbitrary but rather prioritizes the exploration of nodes that may lead to the optimal solution faster in high order to reduce the algorithm’s running time. Therefore, we reorder the branches according to the rules of ascending ${\mathit{lb}}^{\prime }$ and descending $q^d$.

The above process can also be represented as the algorithm flow chart shown in Figure 11.

In the process of the depth-limited tree search, once a leaf node is found below a certain threshold or the optimal solution is found through probing, the algorithm ends immediately. If it is not found, it indicates that the objective function value corresponding to the optimal solution must be greater than the current search threshold. The DLTS returns false and incumbers the optimal solution.

5.4. Dominance Rules

As mentioned in the previous section (Section 5.3), in the process of the DLTS, the generated branches and child nodes undergo verification to see if they will be dominated.

Due to the possibility of some symmetric or duplicated node states during the branching process, which have the same subtree, they are equivalent for the algorithm to find the optimal solution, so only one needs to be retained for subsequent analysis. Therefore, this paper designs dominance rule 1 to eliminate redundant equivalent nodes and improve search efficiency.

Dominance rule 1 consists of the following conditions:

(1)

$h_{d_n^1}({\mathit{Bay}}_{n-1}^{\mathit{lay}})=0$

(2)

$h_{d_n^2}({\mathit{Bay}}_{n-1}^{\mathit{lay}})=0$

(3)

$\mathit{min}\left\{\right|s_n-d_n^1|,|s_n-d_n^2\left|\right\}$

If a node is verified to meet conditions (1) and (2) during the branching process, it indicates that there will be two empty stacks (denoted as $d_n^1$ and $d_n^2$) in the candidate stack for the next relocation of the node.

As shown in Figure 12, after the completion of the ${(n-1)}_{\mathit{th}}$ relocation, there are two empty stacks (stack 1 and stack 2) in the bay, and equivalent nodes will definitely appear during the process of relocating container 10. In this case, cut out the redundant node (${\mathit{bay}}_n^{\mathit{lay}}$) according to condition (3); that is, select the node (${\mathit{bay}}_n^{{\mathit{lay}}^{\prime }}$) that retains the minimum lateral movement distance of the lifting device within the bay.

During the branching process, there may be some nonoptimal relocation paths that need to be eliminated as early as possible. Therefore, this paper designs dominance rule 2 to prune non-optimal paths. We consider the scenario where the relocation path $p[(c_1,s_1,d_1),\dots ,(c_n,s_n,d_n)]$ formed during the node branching process is verified to have integer k that satisfies the following conditions:

(1)

$c_k=c_n\notin \{c_{k+1},\dots ,c_{n-1}\}$

(2)

$d_n\notin \{s_k,d_k,\dots ,s_{n-1},d_{n-1}\}$

(3)

$h_{d_n}({\mathit{Bay}}_{k-1}^{\mathit{lay}})=h_{d_n}({\mathit{Bay}}_{n-1}^{\mathit{lay}})$

It will definitely be dominated by the shorter path$p^{\prime }[(c_1,s_1,d_1),\dots ,(c_k,s_k,d_n),\dots ,(c_{n-1},s_{n-1},d_{n-1})]$. Condition (1) requires the same container to be relocated at both $k_{\mathit{th}}$ and $n_{\mathit{th}}$ relocation in path $p$, with zero displacement occurring between these steps. Conditions (2) and (3) enforce that no containers have been relocated into or out of stack $d_n$ between $k_{\mathit{th}}$ and $n_{\mathit{th}}$ relocation. The stacking height of stack $d_n$ must remain identical prior to both $k_{\mathit{th}}$ and $n_{\mathit{th}}$ relocation.

As shown in Figure 13, $k_{\mathit{th}}$ and $n_{\mathit{th}}$ relocation are both for container 7, and there is no movement of container 7 in between. The height of stack 3 remains identical prior to both $k_{\mathit{th}}$ and $n_{\mathit{th}}$ relocation. Therefore, relocations (7, 2, 4) and (7, 4, 3) can be merged into (7, 2, 3), path $p[(7,2,4),(4,1,4),(7,4,3)]$ is dominated by $p^{\prime }[(7,2,3),(4,1,4)]$, and during the branching process, path $p$ will be directly pruned.

6. Computational Experiments and Analysis

In this section, we evaluated the performance of the proposed strategy-iterative deepening branch-and-bound algorithm on datasets of different scales. Firstly, a comparative computational experiment with the exact algorithm was set up (to evaluate the ability of the algorithm to find the optimal solution); a comparative analysis was conducted with the algorithm in reference [20] on randomly generated small-scale and medium-to-large-scale cases. Secondly, a comparative computational experiment with the heuristic algorithm was carried out using partial instances from the public dataset ZQLZ (generated by Zhu et al. [39]). The performance of the proposed SOA was compared and analyzed against the algorithms in reference [18] and reference [7]. Additionally, the performance of the proposed S-IDB&B algorithm was examined under various truncation conditions and compared with the algorithms from references [9,18]. Finally, the impact of different probing conditions on the algorithm performance was also explored. All computational experiments were developed in C programming language and conducted on a system equipped with an Intel Core i7-14650HX processor (boost clock up to 5.8 GHz) and 32 GB RAM.

6.1. Comparison with Exact Algorithm

6.1.1. Comparative Analysis in Small-Scale Instance

For the small-scale instances, the bay configurations range from 3 to 4 tiers (H) and 3 to 6 stacks (S), with the number of containers per bay varying between 7 and 23 (N). For each bay configuration, 100 container distribution instances were randomly generated. This paper selects the S-B&B algorithm [20] as the basic comparison of the S-IDB&B algorithm designed in this paper.

Table 3. Computational results of the experiments for exact solving of small-scale instances.

H	S	N	INST	SOA		S-IDB&B			S-B&B [20]
				Time (s)	Opt	Time (s)	Opt	Node	Time (s)	Opt	Node
3	3	7	100	0.000	100	0.000	100	0	0.001	100	5.2
	4	10	100	0.000	100	0.001	100	0	0.001	100	11.7
	5	13	100	0.000	100	0.001	100	0	0.006	100	18.5
	6	15	100	0.000	100	0.004	100	0.25	0.007	100	22.3
	6	16	100	0.000	100	0.004	100	1.1	0.007	100	31.8
	6	17	100	0.000	100	0.004	100	0.05	0.008	100	35.2
4	4	14	100	0.000	100	0.004	100	1.3	0.006	100	27.5
	5	17	100	0.000	98	0.004	100	0.8	0.011	100	50.6
	6	21	100	0.000	95	0.005	100	3.04	0.015	100	76.2
	6	22	100	0.000	95	0.006	100	34.7	0.018	100	129.0
	6	23	100	0.000	95	0.006	100	80.4	0.023	100	180.2

presents the mean values for each experimental group, in which “opt” refers to the number that the algorithm can accurately solve for these 100 instances, “time” refers to the average CPU calculation time in seconds, and “node” represents the average number of nodes traversed during the search process, determined by the total number of DLTS function calls.

For the convenience of display, the main data in Table 3 are organized as shown in Figure 14 and Figure 15.

From Table 3 and Figure 14 and Figure 15, it can be seen that in the performance of the small-scale instance, the SOA can solve very quickly, and the average CPU computation time is less than 1 millisecond (for the convenience of statistics, we uniformly use seconds as the unit and only retain three significant digits, so the results in the table show 0.000). For the scale with four tiers and four stacks and below, it can find the optimal solution, and for the scale of four tiers and four stacks and above, it can also accurately solve more than 95% of the instances.

The S-IDB&B algorithm utilizes the SOA to compute upper bounds, consequently enabling it to find optimal solutions for all small-scale instances, with computation times consistently under 0.01 s. Although the S-B&B algorithm also finds optimal solutions on all small-scale instances, it requires the exploration of a marginally higher number of nodes compared to S-IDB&B, resulting in a computation time of 0.023 s.

6.1.2. Comparative Analysis in Medium-to-Large-Scale Instance

For the medium-to-large-scale instances, the bay configurations range from four to six tiers (H) and seven to ten stacks (S), with the number of containers per bay varying between 26 and 56 (N). For each bay configuration, 100 container distribution instances were randomly generated.

Table 4. Computational results of the experiments for exact solving of medium-to-large-scale instances.

H	S	N	INST	SOA		S-IDB&B			S-B&B [20]
				Time (s)	Opt	Time (s)	Opt	Node	Time (s)	Opt	Node
4	7	26	100	0.001	92	0.007	100	6.7 × 102	0.061	100	4.8 × 103
	8	30	100	0.002	98	0.007	100	1.2 × 103	0.495	100	6.1 × 104
	9	34	100	0.002	96	0.012	100	8.5 × 103	4.72	100	9.2 × 105
	10	37	100	0.004	94	0.023	100	2.2 × 104	52.6	100	1.2 × 107
5	7	32	100	0.001	77	0.042	100	6.3 × 105	9.28	100	8.2 × 106
	8	37	100	0.002	66	0.054	100	7.9 × 106	26.3	100	5.3 × 107
	9	42	100	0.047	54	7.13	99	1.7 × 107	208.3	100	1.6 × 108
	10	47	100	0.052	#	18.1	97	4.5 × 107	/	#	#
6	7	38	100	0.031	#	75.6	95	1.2× 108	/	#	#
	8	44	100	0.048	#	286.3	92	2.5 × 108	/	#	#
	9	50	100	0.062	#	472.6	86	3.8 × 108	/	#	#
	10	56	100	0.061	#	608.8	80	4.3 × 108	/	#	#

presents the mean values for each experimental group. Note: The symbol “/” indicates that the solving time was excessively long (significantly exceeding 600 s), while “#” denotes that data were not collected (we were unable to find the optimal solution or unable to find the optimal solution within the specified time).

For the convenience of display, the main data in Table 4 are organized as shown in Figure 16 and Figure 17.

As evidenced in Table 4 and Figure 16 and Figure 17, the SOA algorithm can rapidly obtain feasible solutions for medium-to-large-scale instances. However, the number of instances for which it can find optimal solutions decreases significantly with increasing bay dimensions. When bay configurations reach or exceed four tiers and ten stacks, its capability to identify optimal solutions diminishes progressively. For six-tier bays, the SOA fails to find any optimal solutions. The inability to find the optimal solution for the SOA in six-tier configurations mainly primarily stems from the inherent combinatorial challenges of its heuristic design. As the bay height increases, the exponential growth in possible container states significantly challenges the efficiency of the SOA. While strategy 1 and strategy 2 perform well in bays (under six tiers) by leveraging domain-specific knowledge (preserving good stacks and strategically using bad stacks), their rule-based nature faces limitations in deeply layered contexts. Specifically, first, local optimization choices under these strategies accumulate suboptimal effects over extended relocation sequences in taller stacks. Second, the predefined strategy conditions become less adaptable to the increased diversity of complex states in six-tier bays.

The S-IDB&B algorithm finds optimal solutions for instances up to five-tier eight-stack bays with an average solving time within 0.1 s. In contrast, the S-B&B algorithm fails to solve five-tier 10-stack or larger instances within the time limit. Consequently, S-IDB&B demonstrates superior performance to S-B&B at these scales, attributable to its iterative deepening search strategy, tighter lower-bound estimations, and enhanced pruning techniques. It has to be admitted that although our algorithm can precisely solve more instances than the S-B&B algorithm, as the scale of instances increases, the number of its precise solutions keeps decreasing. Moreover, for large-scale individual instances, although it can find the optimal solution, the time it takes is very long, resulting in an increase in the average solution time. Nevertheless, it maintains exact solution capability for over 80% of instances within the time threshold.

6.2. Comparison with Heuristic Algorithm

6.2.1. Comparison Between SOA and Heuristic Algorithms

In order to test the solving performance of the SOA, this paper selects the RB algorithm [18] and Min–Max algorithm [7] as the basic comparison of the SOA designed in this paper. We select a portion of the instances from the ZQLZ dataset, with 40 instances set for each group. The performance indicators in

Table 5. Performance of SOA vs. RB, Min–Max for ZQLZ subset.

H	S	N	INST	SOA		RB [18]		Min-Max [7]
				Time (s)	Relo	Time (s)	Relo	Time (s)	Relo
4	7	26	40	0.001	16.51	0.003	17.23	0.002	18.51
	8	30	40	0.002	18.66	0.025	19.62	0.007	20.28
	9	34	40	0.002	20.61	0.023	21.58	0.013	21.64
	10	37	40	0.004	21.94	0.005	22.73	0.003	24.18
5	7	32	40	0.001	19.57	0.003	21.92	0.001	21.86
	8	37	40	0.002	22.61	0.036	24.27	0.026	23.94
	9	42	40	0.047	25.07	0.076	27.06	0.038	26.72
	10	47	40	0.052	28.73	0.017	30.76	0.074	31.26
6	7	38	40	0.031	25.12	0.024	27.73	0.039	27.86
	8	44	40	0.048	28.56	0.054	30.64	0.034	32.49
	9	50	40	0.062	30.51	0.059	34.57	0.045	36.61
	10	56	40	0.061	33.29	0.051	37.79	0.087	38.26

are all mean values, and “relo” denotes the feasible solution obtained by the algorithm, that is, the number of relocations.

For the convenience of display, the main data in Table 5 are organized as shown in Figure 18 and Figure 19.

Figure 18 compares the number of relocations obtained by the SOA and the RB and Min–Max algorithms for selected instances within the ZQLZ dataset. The legends “DevSR%” and “DevSM%” denote the percentage deviation in the number of relocations for the RB and Min–Max algorithms, respectively, relative to those obtained by the SOA. It can be observed that the SOA consistently achieves a lower average number of relocations than both comparative algorithms across all tested instance sizes (ranging from four tiers and 7 bays to six tiers and 10 bays). This indicates that the SOA produces superior feasible solutions, yielding a tighter upper bound. As the bay size increases, the maximum DevSM% deviation (19.9%) occurs for the six-tier 9-bay instance, while the maximum DevSR% (13.5%) is observed for the six-tier 10-bay instance. These results demonstrate that the SOA’s optimization effectiveness becomes more pronounced with larger bay sizes. As illustrated in Figure 19, the average computation times for these three algorithms show minimal differences, with none exceeding 0.1 s. Therefore, considering both the tightness of the upper bounds obtained and the computational efficiency, the SOA demonstrates superior performance over the RB and Min–Max algorithms on the ZQLZ dataset instances.

6.2.2. Comparison Between S-IDB&B and Heuristic Algorithms

In order to test the performance of the strategy-iterative deepening branch-and-bound algorithm (S-IDB&B) in solving the CRP under the early stopping mechanism, in this section, the algorithm sets truncation conditions of ulgap ≤ 2%, 5%, and 10%, where ulgap is

$$\mathit{ulgap}={\displaystyle \frac{s^{\mathit{best}}-\mu }{\mu }}\times 100\%$$

(12)

We select the Beam Search algorithm [18] and Corridor Method [9] for comparative testing. The test dataset is a subset of the ZQLZ dataset. The experimental results are shown in

Table 6. Performance of S-IDB&B with early stopping vs. BS and CM on ZQLZ subset.

S × H	INST	S-IDB&B						Beam Search [18]		Corridor Method [9]
		Ulga 2%		Ulgap ≤ 5%		Ulgap ≤ 10%
		Relo	Time	Relo	Time	Relo	Time	Relo	Time	Relo	Time
6 × 3	40	260	0.03	260	0.03	260	0.03	260	0.02	260	0.02
7 × 3	40	306	0.03	306	0.03	306	0.03	306	0.02	306	0.02
8 × 3	40	355	0.10	355	0.10	355	0.10	355	0.05	355	0.05
9 × 3	40	409	0.16	409	0.16	409	0.16	409	0.10	409	0.10
10 × 3	40	457	0.38	457	0.38	457	0.38	457	0.32	457	0.32
6 × 4	40	474	0.38	474	0.38	474	0.38	474	0.32	474	0.32
7 × 4	40	552	0.48	552	0.43	552	0.43	624	0.30	635	0.30
8 × 4	40	633	0.48	633	0.45	697	0.43	760	0.30	728	0.30
9 × 4	40	706	0.77	706	0.56	777	0.43	848	0.32	812	0.32
10 × 4	40	798	0.38	798	0.38	861	0.38	979	0.30	939	0.30
6 × 5	40	724	1.54	724	1.02	781	0.77	852	0.32	866	0.35
7 × 5	40	852	7.30	877	4.30	919	2.30	1002	0.34	1027	0.38
8 × 5	40	972	139.39	1000	30.60	1048	3.84	1095	1.09	1143	1.20
9 × 5	40	1070	52.99	1102	17.20	1154	5.76	1259	2.10	1206	2.31
10 × 5	40	1186	434.30	1221	42.70	1279	7.68	1454	3.00	1396	3.30
6 × 6	40	1010	405.89	1039	58.30	1089	9.98	1138	1.31	1188	1.44
7 × 6	40	1155	2077.82	1189	70.60	1246	15.74	1359	2.76	1302	3.04
8 × 6	40	1311	5536.13	1350	94.62	1414	21.50	1607	4.47	1569	4.24
9 × 6	40	1462	9912.19	1505	118.27	1577	26.88	1792	6.61	1720	6.28
10 × 6	40	1600	15,421.82	1647	133.06	1725	29.57	1882	9.15	1913	8.70
6 × 7	40	#	/	1282	124.42	1343	27.65	1465	3.59	1526	3.41
7 × 7	40	#	/	1457	160.36	1527	33.41	1666	6.07	1693	5.77
8 × 7	40	#	/	1625	174.99	1703	35.71	1858	9.66	1935	11.11
9 × 7	40	#	/	1808	191.92	1894	37.63	2066	14.39	2152	16.55
10 × 7	40	#	/	1979	203.52	2073	38.40	2261	19.39	2374	22.30

. The time unit is seconds. Note: “/” indicates that the solution time is too long, and “#” indicates that it has not been counted.

For the convenience of display, the main data in Table 6 are organized as shown in Figure 20 and Figure 21.

The legends “Dev_BS5%” and “Dev_BS10%” represent the percentage deviations in the number of relocations calculated by the Beam Search algorithm and the S-IDB&B algorithm, with truncation conditions set at 5% and 10%, respectively,. Similarly, “Dev_CM5%” and “Dev_CM10%” represent the same for the Corridor Method algorithm.

As indicated by Table 6 and Figure 20 and Figure 21, under the strict truncation condition (ulgap ≤ 2%), S-IDB&B achieves the highest solution quality among these algorithms. However, its computational time for medium-to-large-scale instances (particularly those with five tiers and 10 stacks or more) is significantly longer than that of other algorithms. Under the truncation condition (ulgap ≤ 5%), the solution quality of S-IDB&B slightly decreases but remains superior to that of the Beam Search and Corridor Method algorithms. For most tested instances, the “DevBS5%” deviation reached approximately 15%. This value even reached 20% in many instances with four and six tiers. Similarly, the “DevCM5%” deviation was around 15%, approaching 20% for instances with seven tiers. Nevertheless, the computational time difference between S-IDB&B and the comparative algorithms became substantial for instances with five tiers and eight stacks or more. Under the looser truncation condition (ulgap ≤ 10%), S-IDB&B maintained solution quality exceeding the Beam Search and Corridor Method, with “DevBS10%” and “DevCM10%” around 10%. It also achieved significantly shorter computational times, with the time difference relative to the comparative algorithms falling within a much smaller range (showing only a linear, acceptable increase in solution time). In summary, the exact algorithm S-IDB&B proposed in this study, through its early termination strategy, transcends the traditional binary opposition between exact and inexact algorithms. By setting appropriate truncation conditions, it demonstrates performance superior to the Beam Search and Corridor Method algorithms. This challenges the conventional perception of exact algorithms being “slow but accurate” and provides a novel perspective on the practical applicability of exact algorithms for industrial optimization.

6.3. Analysis of Probing Condition Change

In order to investigate the impact of different probing conditions on algorithm optimization, two sets of comparative experiments using the S-IDB&B algorithm were conducted. “S-IDB&B I” represents the configuration where the probing condition is set to Equation (10). “S-IDB&B II” represents a stricter configuration requiring both Equations (10) and (11) to be satisfied before a node is probed. We believe the ratio of $n^b$ count and the ratio of container count, both between the current node and the root node, are equally important in measuring the probing value of nodes, so we set parameter γ to 0.5. As mentioned earlier (Section 5.3), the bay distribution corresponding to a node becomes more concise as the depth increases, and its $g^{\mathit{est}}$ also decreases. Therefore, the corresponding probing threshold is dynamically set to decrease, with the upper limit of δ set to 0.8 and the rate of decrease in ε set to 0.3. The experimental results are shown in

Table 7. Performance of S-IDB&B under different probing conditions.

H	S	N	INST	S-IDB&B I			S-IDB&B II ($\mathit{\gamma }$ = 0.5, $\mathit{\delta }$ =0.8, $\mathit{\epsilon }$= 0.3)
				Time	Opt	# Probe	Time	Opt	# Probe
4	7	26	100	0.007	100	6.7 × 102	0.007	100	6.5 × 102
	8	30	100	0.007	100	1.2 × 103	0.007	100	1.1 × 103
	9	34	100	0.012	100	8.5 × 103	0.012	100	7.2 × 103
	10	37	100	0.023	100	2.2 × 104	0.022	100	2.1 × 104
5	7	32	100	0.042	100	6.3 × 105	0.041	100	5.7 × 105
	8	37	100	0.054	100	7.9 × 106	0.057	100	7.6 × 106
	9	42	100	7.13	99	1.7 × 107	16.82	99	1.6 × 107
	10	47	100	18.1	97	4.5 × 107	22.3	97	4.1 × 107
6	7	38	100	75.6	95	1.2 × 108	72.6	95	9.7 × 107
	8	44	100	286.3	92	2.5 × 108	261.4	92	2.2 × 108
	9	50	100	472.6	86	3.8 × 108	436.3	86	3.4 × 108
	10	56	100	608.8	80	4.3 × 108	553.6	80	3.7 × 108

. The term “#probe” denotes the number of SOA calls executed during the algorithm run.

For the convenience of display, the main data in Table 7 are organized as shown in Figure 22.

It can be seen that in the instances of five-tier 9-stack and five-tier 10-stack configurations, S-IDB&B II missed some nodes that may have obtained the optimal solution due to the use of stricter probing conditions, resulting in a slightly longer solution time than S-IDB&B I. However, for larger-scale instances (six-tier seven-stack and above), stricter probing conditions successfully eliminate some invalid probes, thereby reducing the average computation time significantly (by up to about 1 min). This demonstrates that probing strategies significantly impact algorithmic efficiency, especially for larger instances with more iterations. Stricter probing conditions are beneficial for accelerating algorithm execution efficiency.

7. Conclusions

This paper investigates the restricted container relocation problem (RCRP) in port container terminals and verifies the effectiveness and advantages of the proposed algorithm through computational experiments. It treats the problem as a shortest path problem, where each bay container configuration is represented as a node in a search tree, and each container relocating operation is considered an edge. The path from an initial bay stacking state to an empty bay state with the fewest edges corresponds to the minimum number of relocations required.

Firstly, a strategy-oriented algorithm (SOA) is proposed. This algorithm guides the selection of the target stack for containers awaiting relocation by establishing a set of container relocation strategies, enabling the rapid identification of reasonably feasible solutions. The computational comparative experimental results (Section 6.2.1) demonstrate the competitiveness of the SOA.

Secondly, a strategy-iterative deepening branch-and-bound algorithm (S-IDB&B) is developed. Upper bounds for branch-and-bound nodes in the S-IDB&B algorithm are computed using the strategy-oriented algorithm, while lower bounds consider the dynamic changes in stack support capability to achieve more accurate estimations. Furthermore, to enhance the search efficiency of S-IDB&B, a proactive probing mechanism is introduced. This mechanism actively attempts to improve the quality of the current optimal solution during the search, aiming to identify a solution whose objective function value equals the lower bound, thereby allowing the immediate termination of the algorithm. The S-IDB&B algorithm also integrates two dominance rules designed to eliminate symmetric nodes and non-optimal paths generated during the relocating process, thereby reducing redundant searches. The computational experimental results on randomly generated instances of varying sizes (Section 6.1) demonstrate that the proposed S-IDB&B algorithm exhibits superior exact solving capabilities for the RCRP compared to general B&B algorithms. Specifically, on large-scale instances where general B&B algorithms fail to find optimal solutions within a time limit, the S-IDB&B algorithm can identify the optimal solution within the specified time frame. The computational experimental results (Section 6.2.2) on public datasets show that S-IDB&B exhibits both high-quality solutions and fast computation performance by adopting an early stopping mechanism and flexibly setting truncation conditions. In the case of computation time similar to other heuristic algorithms, the quality of the solutions is higher than theirs.

Thirdly, the impact of different probing conditions on the S-IDB&B algorithm was briefly explored, and appropriate probing conditions may result in less computation time for the S-IDB&B algorithm.

Future research on container relocation problems could extend the application of these algorithms to the Unrestricted Container Relocation Problem (UCRP) or multi-bay relocation scenarios [43,44]. Additional dominance rules [45] could be developed to facilitate rapid pruning and enhance algorithmic efficiency. Machine learning mechanisms could be incorporated into the algorithm to extract node features indicative of potentially optimal solutions, thereby guiding the refinement of probing mechanisms. And a promising direction for future research is to extend the current work by comparing the proposed algorithm with established heuristic methods such as the Tabu Search and Genetic Algorithm. Such comparisons would provide deeper insights into algorithmic performance and could guide practitioners in selecting appropriate solutions for real-world scenarios.