A Branch-Bound-and-Remember Search Framework for U-Shaped Disassembly Line Balancing Problems

Abstract

The U-shaped Disassembly Line Balancing Problem (UDLBP) is a challenging combinatorial optimization problem for which efficient solution approaches remain limited. This study proposes an efficient branch-bound-and-remember (BBR) algorithm that integrates a memory-based mechanism and U-shaped dominance rules to effectively reduce the search space. Specifically, a new branching method, an additional lower bounding method, and new dominance rules are developed to suit the UDLBP, and different search strategies are developed and explored. Extensive computational experiments are conducted on a comprehensive set of benchmark instances to evaluate the performance of the proposed approach. The results demonstrate that the proposed BBR algorithm can consistently identify the best-known solutions for the evaluated benchmark instances. Compared with constraint programming, mixed-integer linear programming, and several state-of-the-art metaheuristic algorithms, the proposed approach achieves competitive solution quality and computational efficiency, consistently matching the best-known solutions with an average recorded CPU time of 0.0199 s under the 500 s computational setting. These findings indicate that the proposed algorithm provides an efficient optimization framework for solving UDLBP, achieving high-quality solutions with substantially low computational cost.

1. Introduction

With the rapid development of sustainable manufacturing and circular economy paradigms, end-of-life (EOL) product recovery has become a critical component of modern industrial systems. Disassembly, as the reverse process of assembly, plays a fundamental role in enabling remanufacturing, recycling, and material reuse. Efficient disassembly operations not only reduce environmental impact but also improve economic returns by recovering valuable components [1,2].

Among various operational problems in disassembly systems, the disassembly line balancing problem (DLBP) has attracted significant attention. The DLBP aims to assign disassembly tasks to workstations while satisfying precedence constraints and optimizing performance criteria such as minimizing the number of workstations or cycle time. However, DLBP is known to be NP-hard, making it computationally challenging for large-scale instances [3,4]. Inherent uncertainties, complex precedence relationships, and possible destructive operations make this problem more complex in real applications.

In recent years, the U-shaped disassembly line balancing problem (UDLBP) has emerged as an important extension of the traditional straight-line configuration. Compared with straight disassembly lines, U-shaped layouts allow tasks to be assigned in both forward and backward directions, thereby increasing flexibility in task allocation and improving line efficiency. This structural advantage enables better utilization of workstations and reduces idle time, making U-shaped lines particularly attractive in practical industrial applications [5,6]. However, the bidirectional assignment characteristic significantly enlarges the feasible solution space and introduces additional combinatorial complexity, making the design of efficient optimization methods for UDLBP particularly challenging.

Despite the substantial progress made in the literature, most existing studies rely on heuristic or metaheuristic algorithms, which are effective in obtaining high-quality solutions but generally lack the ability to guarantee optimality. On the other hand, classical exact approaches, such as mixed-integer linear programming (MILP) and constraint programming (CP), can theoretically provide best-known solutions but often suffer from poor scalability and high computational cost when solving large-scale instances. Therefore, there is a clear need for efficient optimization algorithms that can effectively explore the complex solution space of UDLBP while maintaining high solution quality and computational efficiency.

To address these challenges, this study develops an efficient branch-bound-and-remember (BBR) framework for the UDLBP. The proposed framework integrates a memory-based mechanism with problem-specific branching, lower-bound, and dominance strategies to reduce redundant exploration and improve computational efficiency. In particular, the framework is designed to efficiently identify high-quality solutions and the best-known solutions for benchmark instances within limited computational time. In particular, the main contributions of this study are summarized as follows:

(1)

A novel BBR algorithm is proposed for the UDLBP. To the best of our knowledge, the present study is among the first attempts to develop a BBR-based search framework specifically for the UDLBP. By integrating a memory-based dominance mechanism, the proposed algorithm effectively avoids redundant exploration of equivalent states, thereby significantly reducing the search space and computational burden.

(2)

A set of U-shaped layout-specific pruning rules and several search strategies are developed and explored. Compared with Li, Çil [5], the new branching method, one more lower bounding method (LB6), and new dominance rules (task dominance rule, no successor/predecessor rule) are utilized to suit the UDLBP. Meanwhile, five search strategies are developed and explored.

(3)

Extensive computational experiments on a comprehensive benchmark set demonstrate that the proposed framework can consistently identify solutions matching the adopted best-known reference values within short computational times. Compared with classical mathematical models, including MILP and CP, and representative metaheuristic algorithms, the proposed approach achieves competitive solution quality and computational efficiency.

(4)

To promote reproducibility and facilitate future research, the benchmark instances used in this study, together with their corresponding source information, are made publicly available in the repository maintained by the authors at https://github.com/zixiangliwust/Instances_DLBP1_with_OR_Predecessor (accessed on 1 September 2026). The repository provides the benchmark instances used for the computational experiments and serves as a public source for the data employed in this study.

The remainder of this study is organized as follows. Section 2 reviews the relevant literature on disassembly line balancing problems and U-shaped configurations. Section 3 presents the problem description and mathematical formulations, including both MILP and CP models. Section 4 introduces the proposed BBR algorithm in detail. Section 5 reports the computational experiments and analyzes the results. Finally, Section 6 sets out the conclusions and outlines directions for future research.

2. Literature Review

This section provides a comprehensive review of the existing literature related to disassembly line balancing problems. Specifically, Section 2.1 reviews general studies on DLBP, Section 2.2 focuses on different disassembly line configurations with an emphasis on U-shaped layouts, and Section 2.3 identifies the research gaps and summarizes the main contributions of this study.

2.1. Review of Disassembly Line Balancing Problems

The DLBP has been extensively studied due to its critical role in end-of-life product recovery and sustainable manufacturing systems. Early studies primarily focused on adapting classical assembly line balancing formulations to disassembly contexts, while accounting for the unique characteristics of reverse operations, such as destructive disassembly and uncertain task precedence relationships [2,6,7].

Subsequent research introduced more realistic modeling features, including stochastic processing times, sequence-dependent operations, and multiple objective functions. For instance, several studies incorporated uncertainty into task times and precedence constraints, thereby reflecting real-world variability in disassembly processes [8,9]. Other works extended the problem to multi-objective formulations, aiming to simultaneously optimize economic and environmental criteria, such as minimizing cost, energy consumption, and hazardous waste [10,11,12,13,14].

From a methodological perspective, both exact and heuristic approaches have been widely explored. Exact methods, such as mixed-integer linear programming and dynamic programming, have been applied to small-scale instances due to their ability to guarantee optimality [15]. However, the computational complexity of DLBP significantly limits the scalability of these approaches. As a result, a large body of research has focused on heuristic and metaheuristic algorithms, including genetic algorithms, simulated annealing, tabu search, and particle swarm optimization, which can provide high-quality solutions within reasonable computational time [16,17,18,19].

More recently, increasing attention has been paid to improving the computational efficiency of solution approaches for DLBP. While heuristic and metaheuristic algorithms have demonstrated strong performance in obtaining high-quality solutions, they generally lack the ability to guarantee optimality. On the other hand, exact methods can provide best-known solutions but often suffer from poor scalability when dealing with large-scale instances.

However, the integration of exact and heuristic techniques for solving DLBP remains relatively limited in the existing literature. In particular, there is a lack of efficient exact frameworks that incorporate advanced pruning or learning strategies to accelerate convergence. As a result, developing fast and scalable efficient algorithms for DLBP, especially for complex configurations such as U-shaped layouts, remains an open and challenging research problem.

2.2. Review of Different Disassembly Line Layouts

Previous studies on disassembly line configurations have mainly focused on four layouts: straight [20,21], parallel [22,23], two-sided [24,25], and U-shaped [26,27]. The straight line is often applied due to its simple structure and ease of implementation. Li, Çil [5] introduced a BBR algorithm that incorporates AND/OR precedence constraints, while Ren, Zhang [28] combined multi-criteria decision making with a variable neighborhood search strategy to design a new heuristic. Wang, Li [7] developed a model addressing both environmental and economic objectives, aiming to improve efficiency, reduce energy consumption, and achieve workload balance. In addition, Qin, Wang [29] considered the learning effect of workers and formulated a mixed-integer programming model to determine best-known solutions.

Parallel disassembly lines consist of multiple identical or similar lines operating simultaneously to increase throughput and enhance system robustness. Such configurations are commonly adopted in high-volume remanufacturing environments where multiple products can be processed independently. Research on parallel DLBP mainly focuses on workload allocation among lines, synchronization mechanisms, and capacity optimization under demand uncertainty. Compared with single-line configurations, parallel layouts emphasize production scalability rather than structural flexibility within a single line.

For large-scale products such as vehicles and electronic waste, two-sided layouts allow simultaneous operations on both sides of the line, thereby improving efficiency. Li and Kucukkoc [30] were the first to mathematically model the two-sided DLBP, followed by Zhang, Wu [31], who proposed an encoding–decoding strategy for disassembly scheme planning. Later, Çil, Kizilay [32] extended the model by including sequence-dependent setup times, while Xu and Han [4] considered worker rest periods.

Compared with the above layouts, the U-shaped configuration offers superior space utilization, greater flexibility, and higher efficiency [33]. Guo, Wei [34] established a mixed-integer linear programming model to balance worker fatigue and maximize profits, whereas Li, Kucukkoc [35] incorporated AND/OR precedence constraints to minimize the number of workstations. More recently, Wang, Li [36] applied deep reinforcement learning to achieve dynamic balancing in U-shaped disassembly lines. Motivated by these findings, this study focuses on the optimization of U-shaped disassembly line balancing.

2.3. Research Gap and Contributions

As summarized in Table 1, existing studies have investigated disassembly line balancing from different perspectives, including U-shaped configurations, sequence-dependent operations, multi-objective optimization, deep reinforcement learning, fuzzy environments, flexible workstations, and human–robot collaboration. Although these studies have significantly expanded the applicability of disassembly line balancing models and solution methods, several research gaps remain.

Table 1. Comparison of representative studies on disassembly line balancing and related line balancing problems.

Study	Layout	Solution Method	Exact/Heuristic	Main Limitation
Li, Kucukkoc [1]	U-shaped	ILS + mathematical model	Heuristic	Does not use an exact BBR framework
Li, Çil [5]	Straight	BBR	Exact	Does not consider U-shaped layout
Li, Kucukkoc [35]	U-shaped	Two-phase bee algorithms	Metaheuristic	No exact search mechanism
Wang, Li [36]	U-shaped	Deep reinforcement learning	Learning-based	No exact optimality mechanism
Li, Kucukkoc [37]	U-shaped assembly	BBR	Exact	Assembly rather than disassembly; different precedence and task feasibility characteristics
Zhang, Huang [38]	U-shaped	Fuzzy optimization	Metaheuristic	Uncertain/fuzzy setting; not an exact BBR framework
Zhang, Zhang [39]	U-shaped	CP + cross-entropy	Hybrid	Does not focus on exact UDLBP search
Huang, Zhang [40]	U-shaped	Hybrid optimization	Metaheuristic	Stochastic/HRC setting; not exact
Hu, Fu [41]	U-shaped	Adaptive flower pollination	Metaheuristic	No exact-search mechanism
This study	U-shaped disassembly	BBR + U-shaped branching + LB + dominance + memory + search strategies	Exact-search framework	—

First, most existing studies on U-shaped disassembly line balancing rely on heuristic, metaheuristic, learning-based, or hybrid approaches. For example, ILS, two-phase bee algorithms, deep reinforcement learning, fuzzy optimization, constraint programming combined with cross-entropy, and other metaheuristic approaches have been developed to obtain high-quality solutions. These methods can effectively address complex optimization characteristics, but they generally do not provide a systematic exact-search mechanism for exploring the solution space. Therefore, there remains a need for an efficient BBR-based search framework for U-shaped disassembly line balancing problems.

Second, existing BBR-based studies do not fully address the structural characteristics of U-shaped disassembly lines. Li, Çil [5] developed a BBR algorithm for the disassembly line balancing problem with AND/OR precedence relationships. However, their study focuses on a straight disassembly line and therefore does not explicitly exploit the bidirectional task assignment characteristics of a U-shaped configuration. In a U-shaped disassembly line, a workstation has an entrance side and an exit side, and tasks can be assigned from both directions. Consequently, task feasibility and workstation load generation require additional structural consideration. Therefore, the present study does not simply apply the BBR approach of Li, Çil [5] to a U-shaped configuration; instead, it develops a problem-specific BBR-based search framework that incorporates U-shaped branching, lower-bound, dominance, and memory mechanisms to account for the structural characteristics of U-shaped disassembly operations.

Third, although Li, Kucukkoc [37] developed a BBR algorithm for the U-shaped assembly line balancing problem, assembly and disassembly systems have fundamentally different task feasibility characteristics. In the present UDLBP, both AND and OR precedence relationships must be considered, and the feasibility of tasks assigned to the entrance and exit sides of a workstation depends on the corresponding predecessor and successor satisfaction conditions. Therefore, the BBR mechanisms developed for U-shaped assembly lines cannot be directly transferred to U-shaped disassembly lines without problem-specific adaptation.

Fourth, existing studies have mainly focused on developing individual optimization models or solution algorithms, while relatively limited attention has been paid to systematically integrating problem-specific branching, lower bounds, dominance rules, memory-based state reduction, and alternative search strategies into a unified BBR framework for UDLBP. In particular, the contribution of these components to the computational performance of a U-shaped disassembly line balancing algorithm has not been sufficiently investigated.

To address these gaps, this study develops a BBR-based exact-search framework specifically for the U-shaped disassembly line balancing problem with AND/OR precedence relationships. Rather than directly applying an existing BBR algorithm, the proposed framework incorporates problem-specific mechanisms that exploit the structural characteristics of UDLBP. The main contributions are summarized as follows:

(1)

A BBR-based exact-search framework is developed for the U-shaped disassembly line balancing problem with AND/OR precedence relationships. The framework combines state memorization with systematic branching and pruning to reduce redundant exploration of the combinatorial solution space.

(2)

A U-shaped workstation-oriented branching mechanism is developed to generate feasible task assignments by explicitly considering the entrance-side and exit-side characteristics of U-shaped workstations. This mechanism distinguishes the proposed approach from existing BBR algorithms developed for straight disassembly lines and U-shaped assembly lines.

(3)

Problem-specific lower bounds and dominance mechanisms are incorporated into the BBR framework to improve search space reduction. These mechanisms include the lower-bound calculations, maximal load reduction, task dominance, no-successor/predecessor reduction, and memory-based dominance mechanism.

(4)

Five BBR variants are constructed to investigate the effect of different search strategies within the common BBR framework. The variants employ the same problem representation, branching mechanism, lower bounds, dominance mechanisms, and memory mechanism, while using different Phase II search strategies.

(5)

Extensive computational experiments are conducted on benchmark UDLBP instances to evaluate the proposed framework against MILP, CP, and representative metaheuristic approaches. The computational results are further analyzed to clarify the respective roles of the problem-specific branching mechanism, lower-bounding procedures, dominance mechanisms, memory-based state management, and Phase II search strategies within the proposed BBR framework.

3. Problem Statement and Mathematical Formulation

This section first describes the UDLBP, including its operational characteristics and precedence constraints in Section 3.1. Later on, Section 3.2 presents the MILP formulation and Section 3.3 introduces the CP model.

3.1. Problem Description

The UDLBP considered in this study is defined as follows. A set of $n$ elementary disassembly tasks $I=\{1,2,\dots ,n\}$ is given. Each task $i$ has a deterministic processing time $t_i$. A cycle time $CT$ is specified, representing the maximum time allowed at any workstation. The tasks are subject to precedence constraints of two types: (1) AND precedence: If task $i$ must be completed before task $j$ can start, we denote $i<j$. This relation is transitive. A task can be disassembled only after all of its AND predecessors have been completed. (2) OR precedence: Task $j$ can start as soon as any one of its OR predecessors is finished. In other words, when a task has multiple OR predecessors, the completion of a single predecessor suffices to enable the task.

Figure 1 illustrates a precedence diagram for a small instance with nine parts. In the figure, numbers represent the parts, and arrows indicate precedence relations. Parts connected by an arc are governed by OR precedence relations, while those not connected by an arc follow AND precedence relations. For example, part 2 and part 3 are the OR predecessors of part 1: when either part 2 or part 3 has been completed, part 1 can be disassembled. The deterministic disassembly times of all components are incorporated into Figure 1, with the processing time of each component displayed above the corresponding node.

Figure 1. Precedence diagram for a single instance.

The disassembly line is arranged in a U shape: workstations are placed along a U curve, and each workstation consists of two sides—an entrance side and an exit side. A task can be assigned to either the entrance side or the exit side of a workstation. Tasks on the entrance side are processed from left to right, while tasks on the exit side are processed from right to left. All tasks assigned to the same workstation (both sides together) must have a total processing time not exceeding $CT$. Figure 2 shows the optimal task allocation for a U-shaped disassembly line designed to minimize the number of workstations while maintaining a cycle time of $CT=7$. The line consists of five workstations, each divided into an entrance side and an exit side. The allocation is: workstation S1 = {1, 2}, S2 = {4, 8, 3}, S3 = {7}, S4 = {6, 9}, S5 = {5}. The total operation time at each workstation equals 7, fully utilizing the cycle time with minimal idle time.

Figure 2. The U-shaped disassembly line with five workstations.

3.2. Mixed-Integer Linear Programming Model

The notation used throughout this study is firstly summarized in Table 2. Notice that indices $0,\dots ,ub-1$ represent the entrance side of workstations $0,\dots ,ub-1$; indices $2ub-1,\dots ,ub$ represent the exit side of the same workstations in reverse order. This ensures that a smaller index corresponds to an earlier position in the disassembly sequence.

Table 2. Notations utilized by MILP and CP models.

Indices and Sets:
$i,h$	Task indices, $i,h\in \{1,\dots ,n\};$
$j,k$	Workstation indices, $j,k\in \{1,\dots ,ns\};$
$I$	Set of tasks, $I=\{1,\dots ,n\};$
$m,p,s$	Position indices, $m,p,s=0,\dots ,2ub-1$
$J$	Set of workstations, $J=\{1,\dots ,ns\};$
$P$	Set of precedence relations: $(i,h)\in P$ if $i$ must precede $h;$
$OR(j)$	Set of OR-predecessors of task $j;$
Parameters:
$n$	Total number of tasks
$t_i$	Processing time of task $i$ (deterministic)
$CT$	Cycle time (maximum time per workstation)
$ub$	Upper bound on the number of workstations (e.g., $ub=n$)
$lb$	Lower bound on the number of workstations
Decision variables:
$x_{i,s}\in \{0,1\}$	1 if task $i$ is assigned to position $s$ ($s=0,\dots ,2ub-1$)
$y_j\in \{0,1\}$	1 if workstation $j$ is opened
$ns$	Total number of opened workstations (integer)
$N_i$	Position index of task $i$ (used in CP model)

The proposed MILP formulation is developed based on Li, Kucukkoc [1] to address the U-shaped disassembly line balancing problem with AND/OR precedence constraints considered in this study. The MILP model is formulated with expressions ((1)–(9)). Equation (1) is the objective function that minimizes the number of workstations $ns$. Equation (2) is the unique assignment constraint, ensuring that each task $i$ is assigned to exactly one position $s$ (either the entrance side or the exit side of a workstation). Equation (3) enforces the AND precedence relations: if task $i$ must precede task $h$, then the position index of $i$ is not larger than that of $h$. Equation (4) handles the OR precedence relations: if a task $j$ has OR predecessors, then its position $m$ can be used only if at least one of its OR predecessors is assigned to a position not larger than $m$. Equation (5) is the cycle time constraint, stating that for each workstation $j$, the total processing time of tasks on its entrance side (index $j$) and exit side (index $2ub-1-j$) does not exceed $CT$. Equation (6) links task assignment to workstation activation: if any task is assigned to workstation $j$ (either side), the workstation must be opened ($y_j=1$). Equation (7) ensures contiguity of opened workstations: if workstation $j+1$ is opened, then workstation $j$ must also be opened. Equation (8) calculates the total number of opened workstations as the sum of all $y_j$. Equation (9) restricts the domains of the decision variables: $x_{i,s}$ and $y_j$ are binary, and $ns$ is a non-negative integer.

$$\mathrm{m}\mathrm{i}\mathrm{n} ns$$

(1)

$${\displaystyle \sum _{s=0}^{2ub-1}}{x}_{i,s}=1,\forall i\in I$$

(2)

$$x_{h,m}\le {\displaystyle \sum _{p=0}^m}{x}_{i,p},\forall (i,h)\in P_{\mathrm{AND}}, \forall m=0,\dots ,2ub-1$$

(3)

$$x_{(j,m)}\le {\displaystyle \sum _{p=0}^m}\sum _{i\in OR(j)}{x}_{i,p},\forall j:OR(j)\ne \varnothing ,\forall m=0,\dots ,2ub-1$$

(4)

$$\sum _{i\in I}(x_{i,j}+x_{i,2ub-1-j})·t_i\le CT,\forall j=0,\dots ,ub-1$$

(5)

$$x_{i,j}+x_{i,2ub-1-j}\le y_j,\forall i\in I, \forall j=0,\dots ,ub-1$$

(6)

$$y_j\ge y_{j+1},\forall j=0,\dots ,ub-2$$

(7)

$$ns={\displaystyle \sum _{j=0}^{ub-1}}{y}_j$$

(8)

$$x_{i,s}\in \left\{0,1\right\},y_j\in \{0,1\},ns\in {\mathbb{Z}}^{+}$$

(9)

The proposed MILP model can be solved using the CPLEX Optimizer, which is capable of obtaining exact best-known solutions or proving optimality for the small-scale instances within the specified computation time limits.

3.3. Constraint Programming Model

The CP model uses integer variables $N_i$ for the position of each task and an integer variable $ns$ for the total number of workstations. The proposed CP formulation is inspired by the chance-constrained CP-based U-type assembly line balancing framework proposed by Pınarbaşı [42]. However, to the best of our knowledge, no existing study has developed a CP model for the deterministic U-shaped disassembly line balancing problem with AND/OR precedence constraints. Therefore, the CP model presented in this study can be regarded as the first CP formulation specifically designed for this problem setting.

The model is formulated with expressions ((10)–(15)). Equation (10) is the objective function, identical to that of the MILP model, minimizing $ns$. Equation (11) is the cycle time constraint expressed with integer variables $N_i$: for each workstation $j$, the tasks whose $N_i$ equals $j$ (entrance side) or $2ns-1-j$ (exit side) must have a total processing time no greater than $CT$. Equation (12) enforces the AND precedence relations: if $i$ precedes $h$, then $N_i\le N_h$. Equation (13) models OR precedence using an implication: for each task $j$ with OR predecessors and each possible position $m$, if $N_j=m$, then there exists an OR predecessor $i$ such that $N_i\le m$. Equation (14) provides an upper bound on position indices: no task can be assigned to a position beyond $2ns-1$. Equation (15) defines the domains: $N_i$ are integers from $0$ to $2ub-1$, and $ns$ is an integer bounded by the pre-computed lower bound $lb$ and upper bound $ub$.

$$\mathrm{m}\mathrm{i}\mathrm{n} ns$$

(10)

$$\sum _{i:N_i=j \mathrm{or} N_i=2ns-1-j}{t}_i\le CT,\forall j=0,\dots ,ns-1$$

(11)

$$N_i\le N_h,\forall (i,h)\in P_{\mathrm{AND}}$$

(12)

$$(N_j=m)\Rightarrow (\underset{i\in OR(j)}{\bigvee }(N_i\le m)),\forall j:OR(j)\ne \mathrm{\varnothing }, \forall m=0,\dots ,2ub-1$$

(13)

$$N_i+1\le 2·ns,\forall i\in I$$

(14)

$$N_i\in \{0,\dots ,2ub-1\},ns\in \{lb,\dots ,ub\}$$

(15)

The proposed CP model can be solved using the IBM ILOG CP Optimizer, which is particularly suitable for handling logical constraints, implication relations, and combinatorial search structures, and can directly obtain exact best-known solutions for the small-scale and medium-scale instances.

4. Proposed Branch-Bound-and-Remember Algorithm

For the UDLBP, metaheuristic algorithms can obtain high-quality solutions but generally do not provide optimality certification, while general-purpose exact approaches may become computationally expensive as the problem size increases. Therefore, this study develops a BBR-based search framework to efficiently explore the solution space of UDLBP. The framework combines problem-specific branching, lower bounds, dominance rules, memory mechanisms, and multiple search strategies to reduce redundant exploration and accelerate the identification of high-quality and best-known solutions.

4.1. Overall Framework

The proposed BBR algorithm consists of three phases. Phase I achieves an initial upper bound using a modified Hoffman heuristic. Phase II performs a cyclic best-first search (CBFS). If optimality is not proven, Phase III executes a breadth-first search (BFS) to close the gap. The main procedure is described in Algorithm 1.

Algorithm 1: BBR search framework

Preprocessing: Compute the transitive closure of AND-precedence relations and retain OR-precedence relations explicitly for dynamic feasibility evaluation. Build the list of successors and predecessors for each task. Compute the required lower bounds and problem-specific dominance information. Generate random hash values for state memorization. Phase I-Modified Hoffman heuristic: Obtain an initial upper bound using the modified Hoffman heuristic. If the initial upper bound reaches the root-level lower bound, then   Return the current best-known solution. End if Initialize the memory structures including the hash table, state storage, and priority queues. Create the root state with all tasks unassigned and initialize the precedence information. Insert the root state into the memory structure and the corresponding priority queue. Phase II-Cyclic best first search: While the computation time does not exceed the prescribed limit do:   Select a state according to the adopted search strategy.   If no such state exists, then break.   End if   Check the lower-bound-based pruning condition.   Generate feasible workstation loads using the branching procedure.   Apply the dominance rules to remove redundant states.   Insert the retained states into the corresponding priority queues.   If a complete solution is obtained, update the incumbent best-known solution.  End while Phase III-Breadth-first search (BrFS): If computational time remains, then   Continue exploring the retained states using BrFS according to the number of opened workstations.   Apply the same feasibility checks and problem-specific search-space reduction mechanisms.   Update the incumbent solution whenever a complete feasible solution with improved objective value is obtained. End if Return the best solution found.

Precedence Preprocessing

Before the search starts, the precedence relations are preprocessed to obtain the information required for state feasibility evaluation. The AND precedence relations are processed using transitive closure. Specifically, if task ($i$) precedes task ($j$) and task ($j$) precedes task ($k$) through AND relations, the implied relation ($i$ precedes task $k$) is also included in the AND precedence information.

OR precedence relations are not converted into ordinary transitive closure relations. Instead, their disjunctive semantics are retained explicitly and evaluated during the search. For a task associated with OR precedence requirements, feasibility is determined according to the corresponding OR condition and the currently satisfied predecessor information.

Therefore, transitive closure is applied to the conjunctive AND precedence structure, whereas OR precedence relations are retained explicitly for dynamic feasibility evaluation during branching and state expansion.

4.2. Branching Method

A workstation-oriented branching mechanism is adopted to construct feasible partial solutions for the UDLBP [43,44]. Unlike conventional straight-line balancing problems, the UDLBP allows task assignments from both the entrance and exit sides of a workstation. This bidirectional assignment characteristic introduces additional precedence feasibility interactions and enlarges the feasible search space. Therefore, the branching procedure explicitly considers the two possible workstation sides when generating feasible workstation loads.

At a partial solution in which the previously opened workstations have been completed, a new workstation is opened and feasible task subsets are generated subject to the cycle time constraint and the current precedence satisfaction status. At each branching step, the set of currently eligible tasks is updated according to the assigned tasks and the remaining AND/OR precedence relations.

For the entrance side of a U-shaped workstation, a task is considered feasible when all of its required AND predecessors have been assigned. For the exit side, a task is considered feasible when its required AND successor conditions are satisfied. For OR precedence relations, the corresponding disjunctive condition is evaluated explicitly, and an OR precedence requirement is considered satisfied when the required OR condition specified by the problem is met.

If a task is feasible only on the entrance side, the corresponding entrance-side assignment is generated. If it is feasible only on the exit side, the exit-side assignment is generated. If both sides are feasible, both side assignments are considered as candidate branches in the unrestricted branching procedure. The practical search configuration may subsequently prioritize or retain candidate states according to the adopted candidate generation and search control mechanisms.

The branching procedure recursively generates feasible workstation loads while updating the remaining workstation capacity, task eligibility, precedence satisfaction information, and state memory information. After each recursive branch is completed, the updated information is restored to its previous state. The detailed procedure for generating workstation loads is presented in Algorithm 2. To control the computational burden associated with candidate generation, the number of complete workstation loads considered at each branching step is restricted by a predefined candidate generation limit.

Algorithm 2: Generate loads-branching method

Let the current workstation have a remaining idle time $R$ (initially $R=CT$). Let $E$ be the set of currently eligible tasks (those whose AND-predecessors are all assigned and whose OR-condition is satisfied). Initially, assume that no task is added to the current workstation. For each task $i$ in $E$ (starting from a given index),    if $t_i\le R$, then      A task is added to the workstation.      Determine the assignment side: entrance side if all AND-predecessors of $i$ are assigned; exit side if $i$ has no unassigned AND-successors.      Assign $i$ to the current workstation on the determined side.      Update the precedence counts (decrease the counts of successors/front-side predecessors accordingly) and the hash value.      Compute the new remaining time $R^{\prime }=R-t_i$.      Update the set of eligible tasks $E^{\prime }$.      Recursively generate workstation loads using $R^{\prime }$ and $E^{\prime }$.      Restore the precedence counts and hash value to their previous state.    End if End For If no task is added, then    Create a completed workstation load and generate the corresponding state. End if

4.3. Upper Bounds and Lower Bounds

The initial upper bound is obtained by a Modified Hoffman Heuristic (MHH) following Li, Çil [5]. For each workstation, the heuristic generates up to 1000 feasible loads and selects the one that maximizes the composite score of $\sum _{i\in U}(t_i+\alpha W_i+\beta \mid F_i\mid -\gamma ),$ where $U$ is the set of unassigned tasks, $W_i=t_i+{\sum }_{h\in F_i^{\ast }}{t}_h$ is the positional weight, $\mid F_i\mid$ is the number of immediate successors, and $\alpha , \beta , \gamma$ are parameters tuned from a small set. The heuristic is run for several parameter combinations, and the best solution is taken as the initial $UB$. During the search process, whenever a complete solution with fewer workstations is found, $UB$ is updated.

The simple LB1, LB2 and LB3 and the complex bin-packing lower bound (BPLB), which is achieved by solving the bin packing problem exactly, are utilized here as Li, Çil [5]. Detailed descriptions refer to the cited papers.

Because the BPLB may not be obtained within the prescribed 10 s computational limit for some partial states, the lower bound LB6 from [45] is incorporated as a fallback procedure. LB6 is not proposed as a new lower-bound formulation in this study; rather, it is introduced into the BBR framework to provide an alternative lower-bound estimate when BPLB cannot be obtained within the allocated time. Although LB6 requires more computational effort than LB1–LB3, it can provide a tighter lower-bound estimate for the corresponding partial state. Accordingly, LB1–LB3 are calculated for generated partial states, BPLB is applied to selected states when computationally feasible, and LB6 is used as the fallback lower bound when BPLB cannot be obtained within the prescribed time.

4.4. Search Space Reduction and Dominance Mechanisms

This section presents four search space reduction mechanisms used in the proposed BBR framework: the maximal load rule, task dominance rule, no-successor/predecessor rule, and memory-based dominance rule. These mechanisms are applied after generating feasible workstation loads and before the resulting states are inserted into the search queues.

A search state is represented by the set of assigned tasks, the set of remaining tasks, the current number of opened workstations, the remaining capacity of the current workstation, and the precedence satisfaction information associated with the remaining tasks. For AND precedence relations, a task becomes eligible only when all of its required AND predecessors have been assigned. For OR precedence relations, the corresponding OR condition is satisfied when at least one required OR predecessor has been assigned. For a U-shaped workstation, the feasibility of assigning a task to the entrance or exit side is additionally determined by the corresponding predecessor or successor conditions.

The purpose of the four mechanisms is to reduce redundant or less promising states during practical computational search. Because the implemented framework employs candidate generation and beam width restrictions for computational control, these mechanisms are not interpreted individually as mathematical certificates that no globally optimal completion can ever be removed. Instead, they are used to improve search efficiency while preserving the feasibility requirements of retained states.

4.4.1. Maximal Load Rule

Let ($L_k$) denote the task load assigned to the current workstation ($k$), and let ($I_k$)) denote its remaining idle capacity. A workstation load is considered maximal with respect to the currently available eligible tasks if no additional eligible task can be inserted into the workstation without violating the cycle time constraint or the corresponding precedence feasibility conditions.

If an additional eligible task can be feasibly inserted, the current load is classified as non-maximal and is deprioritized or excluded from the practical candidate set according to the adopted search configuration. The rule is motivated by the observation that compact workstation loads can reduce unnecessary idle capacity and shorten the subsequent search process.

The maximal load rule is therefore used as a search space reduction mechanism rather than as an independent optimality certificate. In particular, the rule does not alter the feasibility definition of a retained state: every retained workstation load must satisfy the cycle time and AND/OR precedence conditions.

4.4.2. Task Dominance Rule

Consider two currently available tasks ($i$) and ($j$) that can be considered as alternative assignments to the same workstation side. Task ($i$) is regarded as less restrictive than task ($j$) when its processing time is no greater than that of ($j$), its required AND predecessors do not exceed those required by ($j$), and its AND successors do not exceed those associated with ($j$). In addition, replacing ($j$) with ($i$) must satisfy the remaining workstation capacity constraint.

Under these conditions, assigning the more restrictive task may consume workstation capacity while providing fewer opportunities for subsequent task assignments. The rule therefore identifies such candidate loads as dominated or less promising and reduces their exploration priority during the practical search.

For tasks assigned from the exit side of the U-shaped workstation, the same comparison is applied symmetrically by exchanging the roles of predecessors and successors. All retained states continue to satisfy the original AND/OR precedence and cycle time feasibility conditions.

4.4.3. No Successor/Predecessor Rule

For a partial U-shaped workstation assignment, the entrance-side tasks are examined with respect to their remaining AND successors, whereas the exit-side tasks are examined with respect to their remaining AND predecessors. This information is used to determine whether the current workstation assignment provides useful precedence connectivity to the remaining unassigned tasks.

If the currently assigned tasks do not contribute to unlocking any remaining precedence-dependent tasks, the corresponding partial assignment is regarded as having low search potential. Such a state is therefore deprioritized or removed from the practical candidate set according to the adopted search configuration.

For OR precedence relations, the rule does not treat an individual OR predecessor as mandatory. Instead, OR feasibility is evaluated according to the original disjunctive condition: a task with multiple OR predecessors becomes eligible when at least one required OR predecessor has been satisfied. Consequently, the rule is applied only after the current AND/OR precedence satisfaction status has been updated.

4.4.4. Memory-Based Dominance Rule

To reduce repeated exploration of equivalent partial solutions, the proposed framework stores previously explored states in a hash table. A state is characterized by the set of assigned tasks, the remaining unassigned tasks, the current workstation information, and the corresponding precedence satisfaction status.

A random hash value is associated with each task, and the hash value of a state is calculated from the assigned task information for efficient retrieval. Importantly, the hash value is used only as a lookup index. When a hash match occurs, the complete state information is subsequently compared, including the assigned task set and the precedence satisfaction information, so that hash collisions do not directly result in state elimination.

If two states have equivalent task assignment and precedence satisfaction information, their workstation-related status is compared. When one state does not provide a better incumbent objective or search potential than the stored state, the newly generated state is treated as redundant and is not further explored. Otherwise, the memory record is updated.

This mechanism reduces repeated exploration of equivalent states and improves computational efficiency. It is therefore regarded as a memory-based search space reduction mechanism in the practical BBR framework.

4.4.5. Summary of the Search Space Reduction Mechanisms

The four mechanisms operate at different levels of the search process. The maximal load rule focuses on workstation utilization, the task dominance rule compares alternative task assignments, the no-successor/predecessor rule evaluates precedence connectivity, and the memory-based dominance rule prevents repeated exploration of equivalent states. The first three mechanisms use problem-specific structural information, whereas the memory mechanism uses previously explored state information.

Because the practical BBR implementation includes candidate generation and beam width controls, the above mechanisms are presented as computational search space reduction strategies rather than independent mathematical proofs of global optimality. Their effectiveness is evaluated through the computational results reported in Section 5.

4.4.6. Component Contribution Clarification

The major components of the proposed BBR framework contribute at different stages of the search process. The U-shaped branching mechanism primarily contributes to feasible state generation by explicitly exploiting the entrance-side and exit-side assignment characteristics of U-shaped workstations. The lower-bounding procedures contribute to early estimation of the minimum number of additional workstations and therefore support bound-based pruning. In particular, LB6 serves as a fallback tightening mechanism when the exact BPLB cannot be obtained within the prescribed computational time. The problem-specific dominance rules contribute to reducing redundant or low-potential candidate states by exploiting workstation utilization and precedence relationships, while the memory-based dominance mechanism prevents repeated exploration of equivalent partial states generated through different construction paths. Finally, the Phase II search strategy determines the order in which retained states are explored and therefore directly affects the convergence behavior and computational efficiency. These components are complementary rather than interchangeable: branching controls candidate generation, lower bounds support bound-based evaluation, dominance mechanisms reduce redundant candidates, memory avoids repeated state exploration, and search strategies control exploration order. Therefore, the overall computational performance of the BBR results from their integrated interaction rather than from a single isolated component.

4.5. Search Strategy

This section describes the search strategy adopted in the proposed BBR framework for exploring partial solutions of the U-shaped disassembly line balancing problem. This study considers five Phase II search configurations: cyclic best-first search (CBFS), modified cyclic best-first search (MCBFS), beam search (BS), best-first search (BFS), and depth-first search (DFS) (please see [46] for detailed description). To avoid ambiguity between best-first search and breadth-first search, the latter is denoted as breadth-first search (BrFS) throughout the revised manuscript. The five BBR variants are denoted by BBR1, BBR2, BBR3, BBR4, and BBR5, respectively.

If the Phase II search does not obtain a solution matching the adopted best-known reference value within the prescribed computational budget, the framework can continue with the breadth-first search (BrFS) configuration when computational time remains. The BFS procedure explores states level by level according to the number of opened workstations and guarantees that all states with fewer workstations are fully explored before deeper levels are considered. Therefore, the BFS phase improves the ability of the proposed framework to verify optimality.

The workstation load is also vital in the search process. To guide the search process, a score function is utilized to evaluate the priority of each state. Here, each search state is represented by a partial solution $\varphi$, which contains the set of assigned tasks, the set of remaining unassigned tasks, the number of already opened workstations $k(\varphi )$, and the remaining idle capacity of the current workstation. During the search process, the lower bounds described in Section 4.3 are evaluated for every generated state. Let $LB(\varphi )$ denote the remaining lower bound of state $\varphi$, which estimates the minimum number of additional workstations required to complete all remaining tasks.

The score value of state $\varphi$ is defined as $f(\varphi )=k(\varphi )+LB(\varphi )+\alpha ·{\displaystyle \frac{Idle(\varphi )}{C}}$, where $k(\varphi )$ denotes the number of opened workstations in state $\varphi$, $LB(\varphi )$ represents the lower bound value of the remaining subproblem, $Idle(\varphi )$ denotes the remaining idle capacity of the current workstation, $C$ is the cycle time, and $\alpha$ is a small weighting parameter. The first two terms estimate the minimum total number of workstations required to complete the solution, while the last term favors states with better workstation utilization by preferring smaller idle capacities. To organize the exploration process, multiple priority queues are maintained during the search. Let $Q_k=\{\varphi \mid k(\varphi )=k\}$ denote the priority queue containing all states that currently use exactly $k$ workstations. Each queue is ordered according to the score value $f(\varphi )$, where states with smaller score values have higher exploration priority. Initially, the root state is inserted into $Q_0$.

Taking the cyclic best-first search as an example, the proposed framework adopts a cyclic best-first search (CBFS) strategy to select states for exploration. A cyclic pointer repeatedly scans the queues $Q_0, Q_1,\dots$ and selects the best state from the current nonempty queue. Compared with a pure best-first strategy, the CBFS mechanism improves the diversification of the search process and prevents excessive exploration of a single search level.

To control memory consumption and improve computational efficiency, a beam width restriction is introduced during the computational search. For each priority queue, only a predefined number of high-priority states according to the evaluation score are retained. The remaining states are temporarily excluded from further exploration in the corresponding search configuration. This mechanism is intended to control memory consumption and prioritize promising states, particularly for relatively large benchmark instances.

It should be emphasized that the beam width restriction is a computational search-control mechanism rather than an optimality certification mechanism. Therefore, the use of this restricted search configuration does not by itself provide a mathematical proof of global optimality. In the revised manuscript, the computational results obtained under this configuration are consequently interpreted in terms of solution quality and agreement with the best-known reference solutions rather than as independent optimality certificates.

5. Computational Study

This section presents the computational experiments conducted to evaluate the performance of the proposed method. Section 5.1 describes the experimental setup, including benchmark instances, compared methods, and evaluation metrics. Afterwards, Section 5.2 evaluates the performance of different variants of the BBR, Section 5.3 compares the proposed method with exact approaches, and Section 5.4 provides comparisons with metaheuristic algorithms.

5.1. Experimental Setup

A comprehensive set of 247 benchmark instances from Li, Çil [5] is utilized to evaluate the performance of all algorithms. The benchmark set covers the instance families, task sizes, and cycle time settings defined in the original benchmark source. The corresponding best-known or optimal objective values are adopted from the benchmark source in [5]. The same benchmark set is consistently used for the BBR variants, mathematical models, and metaheuristic algorithms to ensure a fair comparison. To provide a thorough evaluation, both exact methods and metaheuristic algorithms are considered. First, five variants of the BBR algorithm, denoted as BBR1 to BBR5, are evaluated to compare alternative Phase II search strategies under an otherwise identical BBR framework. This comparison is used to examine how the choice of search strategy affects solution quality and computational efficiency. Second, MILP and CP are compared with the proposed BBR algorithm. Third, a set of ten metaheuristic algorithms is included for comparison. The metaheuristic methods contain three effective evolutionary algorithms: teaching–learning-based optimization (TLBO) [47], grey wolf optimizer (GWO) [48], and whale optimization algorithm (WOA) [49]. Meanwhile, this study also includes some algorithms in solving variants of DLBP, including late acceptance hill-climbing algorithm (LAHC) [50], simulated annealing algorithm (SA) [51], tabu search algorithm (TS) [52], genetic algorithm (GA) [53], particle swarm optimization algorithm (PSO) [54], artificial bee colony algorithm (ABC) [55], and bees algorithm (BA) [55].

5.1.1. Computational Settings

Five computational time limits are considered in the experiments, namely, 1 s, 10 s, 60 s, 180 s, and 500 s. The same time limits are applied consistently across the compared algorithms and mathematical models.

For the BBR framework, the initial upper bound is generated using the Modified Hoffman Heuristic (MHH). During this procedure, up to 1000 feasible workstation loads are generated for each workstation, and the best resulting solution is selected as the initial upper bound. For the lower-bounding procedure, LB1, LB2, and LB3 are calculated for generated partial states. The bin-packing lower bound (BPLB) is applied to selected states with a maximum computation time of 10 s. When BPLB cannot be obtained within this limit, LB6 is used as the alternative lower-bound procedure.

The five BBR variants are defined according to their Phase II search strategies. Specifically, BBR1, BBR2, BBR3, BBR4, and BBR5 employ cyclic best-first search (CBFS), modified cyclic best-first search (MCBFS), beam search (BS), best-first search (BFS), and depth-first search (DFS), respectively. All five BBR variants share the same problem representation, Modified Hoffman Heuristic (MHH) for obtaining the initial upper bound, branching procedure, lower-bound calculations, pruning and dominance mechanisms, and memory-based state management. In particular, the lower-bound procedure includes LB1–LB3 and BPLB, with LB6 used as an alternative lower bound when BPLB cannot be obtained within the prescribed time. Thus, the only systematic difference among BBR1–BBR5 is the Phase II search strategy. The detailed composition of the five variants is summarized in Table 3.

Table 3. Components and search strategies of the BBR variants.

BBR Variant	Common Components	Phase II Search Strategy
BBR1	Problem representation; MHH; branching procedure; LB1–LB3; BPLB/LB6; pruning and dominance mechanisms; memory-based state management	CBFS
BBR2	Same as BBR1	MCBFS
BBR3	Same as BBR1	BS
BBR4	Same as BBR1	BFS
BBR5	Same as BBR1	DFS

All algorithms, including the BBR variants, are implemented in C++ using Microsoft Visual Studio 2022. The mathematical models are solved using IBM ILOG CPLEX Optimization Studio 22.1.1. The experiments are conducted on a personal computer equipped with an Intel Core i9-14900KF processor and 64.0 GB RAM. The BBR algorithms and mathematical models terminate when their respective stopping conditions are satisfied or when the prescribed computational time limit is reached.

For the MILP model, the CPLEX Optimizer is used to solve the formulation described in Section 3.2. The objective is to minimize the number of workstations, and the solver terminates when an optimal solution is proven or when the prescribed computational time limit is reached. For the CP model, the IBM ILOG CP Optimizer is used to solve the formulation described in Section 3.3 under the same time limits. Unless otherwise specified, the solver configurations are kept at their default optimization settings, without introducing additional problem-specific symmetry-breaking constraints beyond those included in the mathematical formulations.

5.1.2. Evaluation Metrics

The performance of the evaluated methods is assessed using three metrics: best-known solution matching rate (BKM%), computational time (CPU Time), and average relative percentage deviation (ARPD). BKM% represents the percentage of benchmark instances for which the obtained solution matches the adopted best-known reference value within the specified computational time limit. Therefore, BKM% evaluates agreement with the reference solution quality rather than independently certifying global optimality. CPU Time measures the computational time required by each method under the corresponding experimental setting. The solution quality is evaluated using ARPD, which is calculated with respect to the instance-level best-known reference values. For each instance, the relative percentage deviation is defined as ${RPD}_i={\displaystyle \frac{f_i-f_i^{\ast }}{f_i^{\ast }}}\times 100$, where ($f_i$) is the objective value obtained by the evaluated method and ($f_i^{\ast }$) is the adopted best-known reference value. The ARPD is calculated as the average RPD over the evaluated instances. Lower ARPD values indicate better agreement with the reference solution quality, while ARPD = 0 indicates that the obtained solutions match the adopted best-known values. An ARPD value of zero therefore indicates complete agreement with the adopted best-known reference values; it does not independently establish global optimality unless the corresponding reference values have been mathematically certified.

5.2. Performance of BBR Variants

This section evaluates the performance of different variants of the proposed BBR algorithm in order to analyze the search strategies. Due to the discrete nature of the objective (number of workstations) and the relatively small optimal values, ARPD values are generally very small. Therefore, BKM% and computational time are also considered as primary indicators. The detailed results of all BBR variants under different time limits are summarized in Table 4.

Table 4. Performance comparison of BBR variants under different time limits.

Variant	Time Limit (s)	BKM (%)	Avg CPU Time (s)	ARPD
BBR1	1 s	99.19	0.0256	0.19
	10 s	99.60	0.0588	0.06
	60 s	99.60	0.2611	0.06
	180 s	99.60	0.7480	0.06
	500 s	100.00	1.2031	0.00
BBR2	1 s	99.60	0.0215	0.13
	10 s	99.60	0.0582	0.06
	60 s	99.60	0.2610	0.06
	180 s	99.60	0.7479	0.06
	500 s	100.00	0.9056	0.00
BBR3	1 s	98.38	0.0293	0.38
	10 s	100.00	0.0601	0.00
	60 s	100.00	0.0603	0.00
	180 s	100.00	0.0599	0.00
	500 s	100.00	0.0605	0.00
BBR4	1 s	99.60	0.0212	0.06
	10 s	100.00	0.0476	0.00
	60 s	100.00	0.0467	0.00
	180 s	100.00	0.0468	0.00
	500 s	100.00	0.0472	0.00
BBR5	1 s	100.00	0.0196	0.00
	10 s	100.00	0.0202	0.00
	60 s	100.00	0.0197	0.00
	180 s	100.00	0.0199	0.00
	500 s	100.00	0.0199	0.00

Note: BKM (%) denotes the percentage of instances for which the obtained solution matches the corresponding best-known reference value. It should not be interpreted as an independent optimality certificate.

From an overall perspective, all BBR variants demonstrate strong performance, achieving very small ARPD values across all time limits. However, clear differences can be observed, particularly under short time limits. Among all variants, BBR5 consistently achieves the best performance, reaching zero ARPD across all time limits, indicating that it is able to find the best-known solutions reliably and efficiently.

In terms of solution quality, the differences among the variants are most pronounced at 1 s. BBR3 shows the largest deviation with an ARPD of approximately 0.38, followed by BBR1 (0.19) and BBR2 (0.13). In contrast, BBR4 already achieves a very small deviation (0.06), while BBR5 reaches zero deviation. As the time limit increases, all variants quickly converge to the corresponding best-known solution values, with BBR3, BBR4, and BBR5 achieving zero ARPD within 10 s. At 500 s, all variants reach zero deviation, indicating their ability to eventually find best-known solutions.

The convergence speed further highlights the advantage of the full algorithm. BBR5 converges the fastest in terms of the adopted reference solution criterion, achieving zero ARPD within 1 s. BBR4 and BBR3 also show rapid convergence, while BBR1 and BBR2 require more time to reach similar performance levels.

The results in Table 4 should be interpreted specifically as a comparison of Phase II search strategies rather than as a component-wise ablation of the complete BBR framework. Since BBR1–BBR5 use the same problem representation, initial upper-bound procedure, branching mechanism, lower-bound procedures, pruning and dominance mechanisms, and memory-based state management, the observed differences can be attributed to the adopted search strategy under the common BBR architecture. The results therefore provide direct evidence that the exploration order has a substantial influence on the practical convergence behavior of the framework.

At the same time, the other components play distinct functional roles in the integrated search process. The branching mechanism ensures that feasible workstation loads are generated according to the U-shaped structure and current precedence status. The lower bounds provide estimates for pruning and state evaluation, with LB6 serving as a fallback when BPLB cannot be obtained within the prescribed time. The dominance mechanisms eliminate redundant or less promising candidate states based on workstation utilization and precedence relationships, while the memory mechanism avoids repeated exploration of equivalent states. These mechanisms form the common computational foundation of all BBR variants, whereas the results in Table 4 specifically quantify the effect of changing the Phase II search strategy.

Therefore, the superior performance of BBR5 should be attributed specifically to its depth-first search strategy within the common BBR framework, rather than to the introduction of additional components. This distinction clarifies the scope of the current comparative analysis and avoids attributing the observed performance differences to components that were not independently varied in Table 4.

5.3. Comparison with Exact Methods

This section compares the proposed BBR algorithm with two mathematical models, namely, CP and MILP. The comparative results are presented in Table 5. The results indicate that the BBR framework achieves better solution quality and substantially lower empirical computational time than the mathematical models under the evaluated computational settings. In terms of solution quality, CP gradually improves as the time limit increases, achieving ARPD values of approximately 0.57 at 10 s, 0.19 at 60 and 180 s, and 0.06 at 500 s. This indicates that CP can approach near-best-known solutions but requires substantial computational time. In contrast, the MILP model performs significantly worse, with ARPD values of approximately 71.88 at 60 s, 65.46 at 180 s, and 55.00 at 500 s. These results indicate that MILP struggles to reduce the optimality gap and is less effective for this problem.

Table 5. Comparison of BBR with exact methods (CP and MP).

Method	Time Limit (s)	BKM (%)	Avg CPU Time (s)	ARPD
CP	1 s	81.78	0.5428	Very large
	10 s	97.17	1.4529	0.57
	60 s	97.98	2.6002	0.19
	180 s	97.98	5.0153	0.19
	500 s	98.79	9.6561	0.06
MILP	1 s	57.49	0.7709	Very large
	10 s	79.76	3.2010	Very large
	60 s	85.43	11.4813	71.88
	180 s	89.07	26.5839	65.46
	500 s	93.52	51.3134	55.00
BBR5	500 s	100.00	0.0199	0.00

Note: BKM (%) denotes the percentage of instances for which the obtained solution matches the corresponding best-known reference value. It should not be interpreted as an independent optimality certificate. Avg CPU Time denotes the mean actual computational time over all 247 benchmark instances, including instances that reach the prescribed time limit.

The best-known solution matching results further demonstrate the strong solution quality of the BBR. The proposed BBR framework achieves nearly 100% matching with the best-known reference solutions across the considered time limits, while CP and MILP show lower matching rates within the same computational budgets. In terms of computational efficiency, BBR also requires substantially less computational time to obtain solutions with the same reference objective values.

These results indicate that the problem-specific search mechanisms of the BBR are effective in identifying high-quality solutions for the evaluated UDLBP benchmark instances. The observed computational advantage over CP and MILP can be attributed to the use of problem-specific branching, lower bounds, dominance mechanisms, and memory-based state management. However, because the practical search configuration employs candidate and beam width restrictions, the results are interpreted as evidence of strong computational performance and best-known solution matching rather than as a standalone mathematical proof of global optimality.

Why Does BBR Substantially Outperform MILP?

The substantial difference between the computational times of BBR5 and MILP does not imply that the BBR framework performs fewer optimization operations in a generic sense. Instead, the difference mainly results from the different search architectures and the degree to which problem-specific structural information is exploited. The MILP formulation represents the UDLBP through general-purpose binary and integer variables and linear constraints. Consequently, the solver must explore a large combinatorial search space while simultaneously handling task assignment, workstation activation, U-shaped positional relationships, and AND/OR precedence constraints. The general-purpose branch-and-cut procedure does not explicitly exploit all structural properties of U-shaped disassembly line balancing that are available during state expansion.

In contrast, the proposed BBR framework directly constructs feasible workstation loads and performs state-based enumeration. The workstation-oriented branching procedure incorporates the U-shaped entrance-side and exit-side assignment characteristics during candidate generation. Moreover, the lower bounds provide early estimates of the minimum number of additional workstations required to complete a partial solution. The maximal load rule, task dominance rule, no-successor/predecessor rule, and memory-based dominance mechanism further reduce repeated or low-potential state exploration. These mechanisms allow BBR to focus the computational effort on a substantially smaller set of promising partial solutions.

The difference is therefore not simply due to the programming language or hardware, but mainly reflects the specialization of the search procedure to the structure of UDLBP. This interpretation is consistent with the results in Table 5: MILP requires an average of 51.3134 s at the 500 s computational setting and still obtains an ARPD of 55.00%, whereas BBR5 obtains an average CPU time of 0.0199 s and an ARPD of 0.00% under the same benchmark setting.

Nevertheless, the reported 0.0199 s should be interpreted carefully. It represents the average recorded CPU time of BBR5 for the benchmark instances under the specified experimental setting and should not be interpreted as a universal guarantee that every UDLBP instance can be solved in 0.0199 s. In addition, because the adopted BBR implementation contains practical search control mechanisms, the computational results are primarily interpreted in terms of best-known-solution matching and computational efficiency rather than as a standalone mathematical proof of global optimality for every instance.

5.4. Comparison with Metaheuristics

This section compares the proposed BBR with a set of representative metaheuristic algorithms, including SA, LAHC, TS, GA, ABC, PSO, BA, WOA, TLBO, and GWO. These algorithms cover a wide range of representative optimization strategies and provide a benchmark for evaluating solution quality. From the results presented in Table 6, it can be observed that all metaheuristic algorithms achieve relatively small ARPD (%) values, indicating that they are capable of finding near-best-known solutions for most instances. However, clear performance differences still exist among them.

Table 6. Comparison with metaheuristic algorithms in terms of ARPD.

Method	ARPD
	1 s	10 s	60 s	180 s	500 s
SA	2.03	1.90	1.91	1.83	1.70
LAHC	1.01	0.88	0.94	1.04	0.94
TS	0.26	0.26	0.29	0.29	0.31
GA	0.17	0.18	0.20	0.22	0.16
ABC	0.14	0.06	0.05	0.05	0.06
PSO	0.04	0.03	0.04	0.05	0.06
BA	0.03	0.03	0.04	0.05	0.05
WOA	0.03	0.03	0.04	0.05	0.05
TLBO	0.02	0.03	0.04	0.05	0.05
GWO	0.03	0.02	0.03	0.03	0.04
BBR5	0.00	0.00	0.00	0.00	0.00

Among the compared metaheuristics, simple trajectory-based methods such as SA and LAHC exhibit the largest deviations, with ARPD values around 2.00 and 1.00, respectively. This indicates that these methods are more likely to be trapped in local optima and have limited exploitation capability. In contrast, more advanced population-based algorithms, such as GA, ABC, and PSO, achieve significantly lower ARPD values, typically in the range of 0.20 to 0.03, demonstrating improved search performance. Further improvements can be observed in algorithms such as BA, WOA, TLBO, and GWO, which consistently produce ARPD values below 0.05. These results suggest that hybrid search mechanisms and adaptive strategies contribute to better solution quality.

Despite the strong performance of these metaheuristics, the proposed BBR algorithm clearly outperforms all of them. As shown in Table 6, BBR5 achieves an ARPD of 0.00 across all time limits, indicating that its obtained solutions consistently match the adopted best-known reference solutions. In contrast, even the best-performing metaheuristics still exhibit small but non-zero deviations. Another important observation is that the ARPD values of metaheuristics do not significantly improve with increased computational time. In some cases, slight fluctuations can be observed, suggesting that these methods may converge early and lack the ability to further refine solutions. In contrast, the BBR framework consistently reaches the adopted best-known reference values under the tested computational budgets.

Overall, the results indicate that the BBR framework achieves stronger agreement with the adopted best-known reference values than the compared metaheuristic methods on the evaluated benchmark instances.

The ability of the BBR to consistently match the adopted best-known reference solutions highlights its strong solution quality and computational efficiency for the evaluated U-shaped disassembly line balancing instances.

5.5. Discussion

The computational results provide several important insights into the performance of the proposed BBR framework. First, the major advantage of the BBR is its ability to exploit the structural characteristics of the U-shaped disassembly line directly during the search process. Unlike general-purpose mathematical programming approaches, the proposed framework does not rely solely on a generic formulation of the problem. Instead, feasible workstation loads are generated according to the current precedence satisfaction status and the two-sided structure of the U-shaped workstation. This substantially reduces the number of infeasible or redundant partial solutions considered during the search.

Second, the comparison with MILP and CP indicates that problem-specific pruning is particularly important for the present problem. MILP provides a flexible general-purpose formulation, but the solver must implicitly discover useful search decisions through its general branch-and-cut mechanism. In contrast, the BBR explicitly incorporates lower bounds, dominance rules, and state memorization into the enumeration process. The memory-based dominance mechanism is especially useful because different construction paths may lead to equivalent partial states. Once such a state has already been explored, repeated exploration can be avoided. It is important to distinguish the functional contribution of these mechanisms from their isolated quantitative contribution. The present experiments evaluate the integrated BBR framework and, through Table 4, the effect of alternative Phase II search strategies under common BBR components. The branching, lower-bounding, dominance, and memory mechanisms are therefore interpreted according to their specific roles in candidate generation, bound-based pruning, redundant-state reduction, and repeated-state avoidance, respectively, rather than claiming an independently measured performance gain for each component.

Third, the comparison among BBR variants indicates that the search strategy has a significant influence on computational efficiency. Although all BBR variants employ the same branching, lower-bounding, dominance, and memory mechanisms, their convergence behaviors differ under short computational limits. BBR5 provides the best overall performance among the tested configurations, suggesting that the adopted search strategy is better suited to the structure of the evaluated UDLBP benchmark set.

Fourth, the comparison with metaheuristic methods reveals a different trade-off. Metaheuristics can obtain high-quality solutions without explicitly enumerating the search space, and several of them achieve very small ARPD values. However, their stochastic search mechanisms do not provide the same systematic state space exploration as the BBR framework. Consequently, BBR5 is able to consistently match the adopted best-known reference values across the tested computational settings.

Finally, the results should be interpreted in the context of the benchmark characteristics and the implemented search controls. The reported average CPU time of 0.0199 s is an empirical result obtained on the evaluated benchmark set rather than a universal complexity guarantee. Similarly, BKM% indicates agreement with the adopted best-known reference values and should not automatically be interpreted as independent proof of global optimality. These observations clarify the scope of the computational claims and indicate that the main contribution of the proposed framework is its efficient exploitation of U-shaped disassembly line structure through a specialized BBR search architecture.

6. Conclusions and Future Research

This study investigates the U-shaped disassembly line balancing problem and develops an efficient solution approach based on a branch-bound-and-remember (BBR) framework. The proposed framework integrates a memory-based mechanism, U-shaped layout-specific branching and search reduction rules, lower-bounding strategies, and multiple search strategies to reduce redundant exploration and improve computational efficiency. The different components serve complementary roles in the search process: the branching mechanism generates feasible U-shaped workstation assignments, the lower bounds support bound-based state evaluation, the dominance mechanisms reduce redundant or low-potential states, and the memory mechanism avoids repeated exploration of equivalent partial states. Five search strategies are further developed and compared within the common BBR framework. Among them, BBR5 demonstrates the best overall performance, achieving fast convergence and consistently matching the adopted best-known solutions.

Extensive computational experiments on a comprehensive benchmark set show that the proposed BBR significantly outperforms both classical exact methods and state-of-the-art metaheuristic algorithms. In particular, BBR5 is able to achieve a 100% best-known solution matching rate within very short computation times, while maintaining zero average relative percentage deviation across all instances. Compared with constraint programming and mixed-integer linear programming models, the proposed method exhibits superior convergence efficiency and robustness, especially under strict time limits. Furthermore, although many metaheuristics can obtain near-best-known solutions, they still exhibit small deviations and lack the ability to guarantee optimality, highlighting the advantage of the proposed exact approach. Another important advantage of the proposed BBR framework is its high computational speed, which enables high-quality or best-known solutions to be obtained within very short runtimes. Therefore, the proposed approach can provide effective decision support for production managers in practical disassembly line planning and workstation scheduling.

Although the proposed algorithm demonstrates excellent computational performance on the benchmark instances, several limitations remain. The current framework mainly focuses on deterministic UDLBP with predefined processing times and precedence relationships. In addition, some acceleration mechanisms are designed to improve search efficiency, which may introduce trade-offs between computational speed and theoretical scalability for extremely large-scale problems. Future studies will investigate adaptive search strategies, stronger theoretical guarantees, and hybrid approaches combining exact optimization and learning-based methods. Future research can be conducted in several directions. First, the proposed framework can be extended to more complex and realistic scenarios, such as stochastic or dynamic disassembly environments. Second, hybrid approaches that combine the proposed exact method with learning-based or metaheuristic strategies may further improve scalability. Finally, integrating additional practical considerations, such as energy consumption, carbon emissions, and multi-objective optimization, would enhance the applicability of the model in sustainable manufacturing systems.