Multicriteria scheduling of two-subassembly products with batch availability and precedence constraints

Introduction

Driven by the need to balance conflicting objectives, the field of multicriteria scheduling has garnered significant attention over the past few decades, see Hoogeveen, 2005, T’kindt & Billaut (2006). This article studies four specific multicriteria problems related to scheduling products with two subassemblies on a fabrication facility, subject to either strict or weak precedence constraints. The focus is on optimizing both makespan and maximum cost simultaneously, or alternatively, on the lexicographical optimization of two maximum costs along with makespan.

In formal terms, consider a set $\mathcal{T}$ of $n$ products, denoted by $T_1,T_2,\dots ,T_n$, to be processed on a single fabrication facility. Each product, $T_j\in \mathcal{T}$, consists of two parts: a common subassembly $T_j^{(1)}$ and a unique subassembly $T_j^{(2)}$, with respective processing times $t_j^{(1)}$ and $t_j^{(2)}$. For aerospace component production, strict precedence constraints might arise when assembling engines: a turbine blade subassembly ( $T_i$) must be fully completed before a combustion chamber subassembly ( $T_j$) can start, ensuring safety and structural integrity. The facility processes the common subassemblies in batches, where each batch incurs a setup time $\delta$, while the unique subassemblies are processed individually. The setup time for each unique subassembly is incorporated into its total processing time, as it is unique to the product it belongs to. Consequently, it is assumed that unique subassemblies do not require setup times. The two subassemblies of a product may be processed in either order, but the facility can handle only one subassembly at a time, and no preemption is allowed during processing.

In this article, we adopt the assumption of batch availability for the common subassemblies, meaning that a common subassembly becomes available only after the entire batch to which it belongs has been fully processed (Santos & Magazine, 1985) (Alternatively, there is the item availability assumption, where a common subassembly becomes available immediately after its processing is finished). Conversely, unique subassemblies are considered available as soon as their individual processing is completed. A product is deemed complete only when both its common and unique subassemblies are fully processed and available. Moreover, each product, $T_j\in \mathcal{T}$, is associated with two cost functions $f_j$ and $g_j$, which represent the costs incurred based on the product’s completion time. It is assumed that these cost functions are regular, meaning $f_j$ and $g_j$ are non-decreasing with respect to the product completion times.

In practical terms, the cost functions $f_j$ and $g_j$ can be linked to real-world manufacturing metrics. $f_j(C_j)$ often represents lateness penalties, such as contractual fines for delivering products after their due dates ( $d_j$). In just-in-time (JIT) production systems, this could model penalties for delaying shipments to assembly lines. $g_j(C_j)$ may quantify resource utilization costs, such as idle machine fees or inventory holding charges for early-completed products. In aerospace manufacturing, this might reflect the cost of storing specialized components before final integration. These costs are “regular” because they increase with completion time, a common assumption in scheduling problems to align with real-world inefficiencies.

For a given schedule S, let $C_j(S)$ represent the completion time of product $T_j$ in S. Define $f_j(C_j(S))$ and $g_j(C_j(S))$ as two costs associated with $T_j$ in the schedule. The values $f_{max}(S)=\underset{j}{max}{f}_j(C_j(S))$ and $g_{max}(S)=\underset{j}{max}{g}_j(C_j(S))$ correspond to the maximum costs under these criteria. Notably, two specific cases of maximum cost are the makespan, $C_{max}(S)=\underset{j}{max}\{C_j(S)\}$, and the maximum lateness, $L_{max}(S)=\underset{j}{max}\{C_j(S)-d_j\}$, where $d_j$ denotes the due date for product $T_j$. The argument S can be omitted in the notation whenever the context is clear.

In addition, the problems under consideration have either strict or weak precedence constraints. A product may depend on a set of products that must be completed or started before it can start. Formally speaking, for the strict precedence relation $\prec$, if $T_i\prec T_j$ ( $T_i$ precedes $T_j$ because of a higher priority), then $T_j$ can start only after $T_i$ is completed in any feasible schedule. Consequently, the common subassemblies of $T_i$ and $T_j$ must be in different batches. As for the weak precedence relation $⪯$, if $T_i⪯T_j$, then $T_i$ must start no later than $T_j$ in any feasible schedule. Therefore, the common subassemblies of $T_i$ and $T_j$ may be processed within the same batch.

The first two problems examined in this article focus on identifying Pareto optimal schedules that minimize both the makespan $C_{max}$ and the maximum cost $f_{max}$ simultaneously, while adhering to either strict or weak precedence constraints. Utilizing the notation conventions established in Hoogeveen (2005), T’kindt & Billaut (2006), Brucker (2007), these problems are represented as $1|\prec ,2-subpt,BA|(C_{max},f_{max})$ and $1|⪯,2-subpt,BA|(C_{max},f_{max})$, where “ $\prec$” and “ $⪯$” indicate strict and weak precedence constraints, respectively. The symbol “ $2-subpt$” refers to “two-subassembly products”, and “BA” denotes “batch availability”.

Let $\rho$ and $\tau$ represent the two performance criteria to be minimized. A schedule S is considered Pareto optimal or non-dominated if there exists no other feasible schedule S′ for which $\rho (S^{\mathrm{\prime }})\le \rho (S)$ and $\tau (S^{\mathrm{\prime }})\le \tau (S)$ where at least one of these inequalities is strict. When a schedule S meets these conditions, the resulting objective vector $(\rho (S),\tau (S))$ is termed a Pareto optimal point (Hoogeveen, 2005). This approach is referred to as Pareto optimization or simultaneous optimization.

The last two problems addressed in this article involve finding a lexicographically optimal schedule under strict or weak precedence constraints, where the criteria $f_{max}$, $g_{max}$, and $C_{max}$ are prioritized as primary, secondary, and tertiary objectives, respectively. These problems are represented as $1|\prec ,2-subpt,BA|Lex(f_{max},g_{max},C_{max})$ and $1|⪯,2-subpt,BA|Lex(f_{max},g_{max},C_{max})$. An optimal solution for $1|\cdot |Lex({\rho }_1,{\rho }_2,\dots ,{\rho }_k)$ is defined as the best possible schedule for $1|\cdot |{\rho }_k$ within the subset of schedules that are already optimal for $1|\cdot |Lex({\rho }_1,{\rho }_2,\dots ,{\rho }_{k-1})$. This approach is known as lexicographical optimization or hierarchical optimization (Hoogeveen, 2005).

The structure of this article is as follows: “Literature Review” offers a review of relevant research in the field. “Algorithms for Pareto Scheduling Two-subassembly Products with Precedence Constraints” introduces $O(n^4)$-time algorithms for $1|\prec ,2-subpt,BA|(C_{max},f_{max})$ and $1|⪯,2-subpt,BA|(C_{max},f_{max})$. “The Experiments”, the experiment of the Algorithm C_max-F_max is given and compared with the algorithm of $1|2-subpt,BA|(C_{max},f_{max})$. “Algorithms for Lexicographical Scheduling Two-subassembly Products with Precedence Constraints” presents $O(n^4)$-time algorithms for $1|\prec ,2-subpt,BA|Lex(f_{max},g_{max},C_{max})$ and $1|⪯,2-subpt,BA|Lex(f_{max},g_{max},C_{max})$. In conclusion, “Conclusions” discusses potential directions for future research.

Literature review

For an in-depth exploration of multicriteria scheduling and batch scheduling, readers are encouraged to consult the surveys provided in Hoogeveen (2005), T’kindt & Billaut (2006), Herzel, Ruzika & Thielen (2021) and Potts & Kovalyov (2000), Allahverdi et al. (2008), respectively. In this article, we focus specifically on discussing results that are directly relevant to the scheduling of two-subassembly products within the context of batch availability.

Baker (1988) initially introduced the model of scheduling two-subassembly products with the goal of minimizing total completion time, denoted as $1|2-subpt,BA|\mathrm{\Sigma }{C}_j$. Operating under the agreeability assumption—where the processing time of a product’s common subassembly is shorter than another’s whenever the same relationship holds for their unique subassemblies—he devised an $O(n^2)$-time algorithm. Later, Coffman et al. (1990) enhanced this algorithm, reducing the runtime to $O(n\log n)$. Subsequently, Gerodimos, Glass & Potts (2000) proposed an $O(n^2)$-time dynamic programming algorithm for $1|2-subpt,BA|L_{max}$. They also demonstrated that the problem of minimizing the total number of late products, denoted as $1|2-subpt,BA|\mathrm{\Sigma }{U}_j$, is NP-hard (here, $U_j=1$ if $C_j>d_j$ and $U_j=0$ otherwise). To address $1|2-subpt,BA|\mathrm{\Sigma }{U}_j$, they provided a pseudo-polynomial time dynamic programming solution. Furthermore, for the special case of $1|2-subpt,BA|\mathrm{\Sigma }{U}_j$ where all common subassemblies share identical processing times, they developed an $O(n^4\log n)$-time dynamic programming algorithm. Wagelmans & Gerodimos (2000) later refined the algorithm in Gerodimos, Glass & Potts (2000) for $1|2-subpt,BA|L_{max}$, reducing the runtime to $O(n\log n)$. Yang (2004a) explored a different scenario where common subassemblies are divided into multiple families, each with setup times that are sequence-independent but not identical. He introduced a branch-and-bound algorithm aimed at minimizing total completion time. In a separate study, Yang (2004b) investigated the problem in the context of parallel machines, with the constraint that both subassemblies of a product must be processed on the same machine. He proposed two heuristic approaches to generate near-optimal schedules for minimizing total completion time. Li (2023) examined $1|2\text{-}subpt,BA|(C_{max},L_{max})$, a bicriteria scheduling problem for two-subassembly products on a single facility, focusing on minimizing both makespan and maximum lateness, and developed an $O(n^2\log n)$-time algorithm with linear memory usage.

If all products consist solely of common subassemblies (i.e., all $t_j^{(2)}=0$), then the problem of scheduling two-subassembly products simplifies to the serial-batch scheduling problem. This problem can be modeled in two ways based on the batch capacity—the largest number of products that can be processed within a single batch. The first is the bounded model, where the batch capacity is limited, denoted as $b<n$, and the second is the unbounded model, where the batch capacity is unlimited, denoted as $b\ge n$.

Over the past two decades, serial-batch scheduling problems have received extensive attention and investigation (Baptiste, 2000; Cheng & Kovalyov, 2001; Yuan, Yang & Cheng, 2004; Ng, Cheng & Yuan, 2002; Webster & Baker, 1995; He, Lin & Yuan, 2008; He et al., 2013a, 2013b; He, Lin & Lin, 2015; Geng, Yuan & Yuan, 2018). Among the contributions, Baptiste (2000) introduced an $O(n^{14}\log n)$-time algorithm for $1|SUB,r_j,p_j=p|L_{max}$ and $1|SBB,r_j,p_j=p|L_{max}$, where products have varying release dates but identical processing times. In this context, “SUB” refers to the unbounded model of serial-batch scheduling, while “SBB” refers to the bounded model. Cheng & Kovalyov (2001) explored serial batch scheduling problems with the objective of minimizing various regular cost functions. For products with equal release dates, they developed dynamic programming algorithms aimed at minimizing several key criteria: maximum lateness, the number of late products, total tardiness, total weighted completion time, and total weighted tardiness, under the condition of equal due dates. These algorithms are polynomial when the number of distinct due dates or processing times is fixed. Additionally, they proposed more efficient algorithms for certain special cases and established the NP-hardness for several specific cases of the bounded model.

By suitably adjusting the release dates and due dates, problems $1|⪯,SUB,r_j,p_j=p|L_{max}$ (involving weak precedence constraints) and $1|⪯,SUB|L_{max}$ (where products have varying processing times but identical release dates) can be transformed in $O(n^2)$ time into $1|SUB,r_j,p_j=p|L_{max}$ and $1|SUB|L_{max}$ (Yuan, Yang & Cheng, 2004; Ng, Cheng & Yuan, 2002). These transformed problems can then be solved in $O(n^{14}\log n)$ and $O(n^2)$ time, respectively (Baptiste, 2000; Webster & Baker, 1995).

He, Lin & Yuan (2008) developed an $O(n^2)$-time algorithm for problem $1|SUB|(C_{max},L_{max})$. This result was subsequently enhanced to an $O(n^5)$-time algorithm (He et al., 2013a), and further improved to an $O(n^3)$-time algorithm for problem $1|SUB|(C_{max},f_{max})$ (He et al., 2013b). He, Lin & Lin (2015) also proposed an $O(n^6)$-time algorithm for $1|SBB|(C_{max},L_{max})$. Additionally, Geng, Yuan & Yuan (2018) introduced $O(n^4)$-time algorithms for both $1|SBB|(C_{max},f_{max})$ and $1|\prec ,SUB|(C_{max},f_{max})$. They also devised an $O(n^2)$-time algorithm for problem $1|⪯,SUB|(C_{max},L_{max})$, and demonstrated that problems $1|⪯,SBB,b=2|L_{max}$ and $1|\prec ,SBB,b=2|L_{max}$ are strongly NP-hard.

This article addresses multicriteria scheduling problems with theoretical significance: optimizing makespan and maximum cost under batch availability and precedence constraints. The polynomial-time complexity of our proposed $O(n^4)$ algorithms is critical: it demonstrates it is computationally feasible to obtain optimal solutions for these problems, contrasting with NP-hard scheduling problems where only heuristic solutions exist.

To the best of our knowledge, problems $1|\prec ,2-subpt,BA|(C_{max},f_{max})$, $1|⪯,2-subpt,BA|(C_{max},f_{max})$, $1|\prec ,2-subpt,BA|Lex(f_{max},g_{max},C_{max})$ and $1|⪯,2-subpt,BA|Lex(f_{max},g_{max},C_{max})$ have not been studied in previous research. In this article, we present $O(n^4)$-time algorithms to solve each of these problems. Note that (Li, 2023) focused on a specific variant of the first problem, where products are not subject to precedence constraints, and the objective is to minimize maximum lateness rather than maximum cost.

While earlier studies focused on single-objective batch scheduling, recent research has shifted toward multicriteria optimization in dynamic manufacturing systems. Li (2024) proposed a hybrid heuristic for two-subassembly scheduling with energy consumption constraints, extending the batch availability model to sustainable manufacturing. Hidri & Tlija (2024) addressed sequence-dependent setup times in hybrid flow shops, a scenario analogous to our unique subassembly processing with individual setup costs. These advancements highlight the growing need to model real-world complexities like dynamic precedence rules and multi-echelon inventory constraints.

Additionally, Li (2024) examined the bounded model for scheduling two-subassembly products with equal processing times for all common subassemblies. Hidri & Tlija (2024) and Xu et al. (2024) introduces a heuristic algorithm to solve this complex problem. The flexible job shop scheduling problem (FJSP) is (Serna et al., 2021) combination problem. In this context, Li (2024) developed an $O(n^2\log n)$-time algorithm for the simultaneous optimization of makespan and maximum lateness, along with an $O(n^4)$-time algorithm for the lexicographical optimization involving two maximum lateness objectives and makespan.

Algorithms for Pareto scheduling two-subassembly products with precedence constraints

In this section, we will present an $O(n^4)$-time algorithm designed to solve problem $1|\prec ,2-subpt,BA|(C_{max},f_{max})$. Additionally, the final schedule produced by this algorithm is also optimal for the single criterion problem $1|\prec ,2-subpt,BA|f_{max}$. Towards the end of this section, we will demonstrate how minor adjustments to the algorithm allow it to efficiently solve $1|⪯,2-subpt,BA|(C_{max},f_{max})$ in $O(n^4)$ time as well.

Precedence constraints on $\mathcal{T}$ can be represented using a graph $G=<V,E>$, where each vertex in V corresponds to a product in $\mathcal{T}$, and each edge in E represents a pair $<T_p,T_j>$ indicating that $T_p\prec T_j$, i.e., $T_p$ must precede $T_j$.

In the context of automotive component manufacturing, a workshop’s production scheduling problem for gearbox systems can be abstracted into the dual-component product scheduling model studied in this article. Specifically, each gearbox product consists of two types of subassemblies: one is a common subassembly shared by all models (e.g., the gearbox housing), which must be processed in batches with a 2-h mold setup time ( $\delta =2$) required before each batch production; the other is a customized unique subassembly (e.g., the gear set) for different vehicle models, which requires no additional preparation time and can be processed individually. During production, strict assembly sequence constraints exist between some models—for example, the basic-type gearbox must be completed before the high-performance type—corresponding to the strict precedence constraint ( $T_i\prec T_j$) in the model, meaning that the successor product can only start production after both the common and unique subassemblies of the predecessor product are completed. This scenario necessitates simultaneous optimization of two key objectives: minimizing makespan ( $C_{\mathrm{m}\mathrm{a}\mathrm{x}}$) to enhance equipment utilization by reducing idle time of the CNC machining center, and minimizing maximum delay cost ( $f_{\mathrm{m}\mathrm{a}\mathrm{x}}$) to avoid contractual penalty fees for late deliveries. This scenario necessitates simultaneous optimization of two key objectives: minimizing makespan ( $C_{\mathrm{m}\mathrm{a}\mathrm{x}}$) to enhance equipment utilization by reducing idle time of the CNC machining center, and minimizing maximum delay cost ( $f_{\mathrm{m}\mathrm{a}\mathrm{x}}$) to avoid contractual penalty fees for late deliveries.

The integration of these constraints and objectives is visualized in the following production scheduling flowchart (Fig. 1), which illustrates the batch processing of common subassemblies, individual machining of unique subassemblies, and the enforcement of strict precedence relationships within the dual-component scheduling framework.

Recall that Lawler’s algorithm (Lawler, 1973) solves $1|\prec |f_{max}$ (the problem of minimizing maximum cost under precedence constraints on a single facility) in $O(n^2)$ time. The algorithm constructs the schedule in reverse order, relying on the following key insight: Let U be the set of unscheduled products and $P_U$ be the total processing time of all products in U. If a product $T_j$ has no successors in U and has the smallest $f_j(P_U)$-value—i.e., $f_j(P_U)=\underset{T_{j\mathrm{\prime }}\in U}{min}{f}_{j\mathrm{\prime }}(P_U)$—then $T_j$ should be scheduled at the last position among all products in U to achieve an optimal schedule.

In the following algorithm (Algorithm 1: Algorithm C_max-F_max), we adapt the idea of Lawler’s algorithm to schedule the unique subassemblies of products in ${\mathcal{T}}^{\mathrm{\prime }}$ (where ${\mathcal{T}}^{\mathrm{\prime }}$ consists of $n^{\mathrm{\prime }}$ unscheduled independent products, meaning there are no precedence constraints among them) within a designated time interval $[\tilde{t},\tilde{t}+{\mathrm{\Sigma }}_{T_{j\mathrm{\prime }}\in {\mathcal{T}}^{\mathrm{\prime }}}{t}_{j^{\mathrm{\prime }}}^{(2)})$. For $i=n^{\mathrm{\prime }},n^{\mathrm{\prime }}-1,\dots ,1$, we select a product $T_{S(i)}\in U={\mathcal{T}}^{\mathrm{\prime }}\mathrm{\backslash }\{T_{S(n^{\mathrm{\prime }})},T_{S(n^{\mathrm{\prime }}-1)},\dots ,T_{S(i+1)}\}$ such that $f_{S(i)}(\tilde{t}+{\mathrm{\Sigma }}_{T_{j^{\mathrm{\prime }}}\in U}{t}_{j^{\mathrm{\prime }}}^{(2)})=\underset{T_j\in U}{min}{f}_j(\tilde{t}+{\mathrm{\Sigma }}_{T_{j^{\mathrm{\prime }}}\in U}{t}_{j^{\mathrm{\prime }}}^{(2)})$ and place it as the last product in U. The sequence $S(1),S(2),\dots ,S(n^{\mathrm{\prime }})$ represents the indices of the products in ${\mathcal{T}}^{\mathrm{\prime }}$ which are processed on the facility during the time interval $[\tilde{t},\tilde{t}+{\mathrm{\Sigma }}_{T_{j^{\mathrm{\prime }}}\in {\mathcal{T}}^{\mathrm{\prime }}}{t}_{j^{\mathrm{\prime }}}^{(2)})$. For simplicity, we will refer to this sequence as being scheduled in Lawler’s order.

Let us briefly explain the meaning of $\tilde{t}$, which will become clearer in Step 2.2 of Algorithm C_max-F_max. The algorithm essentially involves scheduling products in reverse order, moving backward along the time axis (from right to left). Suppose we begin scheduling certain unique subassemblies immediately after the completion of the $i$-th batch of common subassemblies (counting from left to right). In this context, $\tilde{t}$ represents the exact beginning time of the first unique subassembly among those being scheduled.

We will utilize the following well-established method for multicriteria scheduling (Hoogeveen, 2005) to identify Pareto optimal schedules.

Lemma 1 (Hoogeveen, 2005). Let $y$ be the optimal value for the problem of minimizing $\tau$ under the constraint $\rho \le \hat{x}$(where $\hat{x}$ is a known upper bound on $\rho$), and let $x$ be the optimal value for the problem of minimizing $\rho$ under the constraint $\tau \le y$. Then, $(x,y)$ is identified as a Pareto optimal point for two criteria $\rho$ and $\tau$.

The following lemma outlines the structure of the Pareto optimal schedules that we aim to identify. The proof is omitted here as it closely parallels the one presented in Gerodimos, Glass & Potts (2000).

Lemma 2. For every Pareto optimal point in $1|\prec ,2-subpt,BA|(C_{max},f_{max})$, there is an associated schedule where the common subassembly of each product is placed in the batch that directly precedes its unique subassembly.

According to Lemma 2, a feasible schedule can be expressed as a sequence of product-subsequences $Q_1,Q_2,\dots ,Q_n$, where $Q_i$ comprises the products whose common subassemblies are processed in the $i$-th batch. Particularly, we assume that only the last $l$ product-subsequences are nonempty. Hence, it is evident that the subsequences $Q_{n\text{-}l+1},Q_{n\text{-}l+2},\dots ,Q_n$ form a partition of $\mathcal{T}$ and must adhere to the precedence constraints.

The sub-schedule for the products in $Q_i$ can be represented as ${\lambda }_i{\mu }_i$, where ${\lambda }_i$ is a batch containing the common subassemblies of the products in $Q_i$, and ${\mu }_i$ is a unique-subsequence comprising the unique subassemblies of the products in $Q_i$ arranged in Lawler’s order. Let $t({\lambda }_i)={\mathrm{\Sigma }}_{T_j\in Q_i}{t}_j^{(1)}$ and $t({\mu }_i)={\mathrm{\Sigma }}_{T_j\in Q_i}{t}_j^{(2)}$ represent the processing times for the batch and the unique-subsequence of $Q_i$, respectively. The processing time of the entire product-subsequence $Q_i$ is denoted by $t(Q_i)=t({\lambda }_i)+t({\mu }_i)$. Additionally, the processing time for any empty product-subsequence is considered to be zero. The setup time for batch ${\lambda }_i$ is denoted by $\delta ({\lambda }_i)$, which is $\delta$ if ${\lambda }_i$ is nonempty, and 0 otherwise. The beginning time and completion time for $Q_i$ are denoted by $B(Q_i)$ and $C(Q_i)$, respectively. We have the relationship: $C(Q_i)=B(Q_i)+t(Q_i)$. Therefore, we obtain:

Lemma 3. In a feasible schedule $S=\left(Q_1,Q_2,\dots ,Q_n\right)$, the relationship is given by: $B(Q_1)=\delta ({\lambda }_1)$, $B(Q_i)=C(Q_{i-1})+\delta ({\lambda }_i)$, $i=2,\dots ,n$.

A natural feasible schedule $S^{(0)}=\{Q_1^{(0)},Q_2^{(0)},\dots ,Q_n^{(0)}\}$ can be constructed, where $Q_i^{(0)}$ includes all products (vertices) with an out-degree of zero in the graph $G\mathrm{\backslash }{\cup }_{h=i+1}^n{Q}_h^{(0)}$, $i=n,n-1,\dots ,1$. The construction of $S^{(0)}$ from G requires $O(n^2)$ time.

Let $\mathrm{\Gamma }\left(\mathcal{T}\right)$ represent the set of all feasible schedules for $\mathcal{T}$. Our focus is on the subset of schedules in $\mathrm{\Gamma }\left(\mathcal{T}\right)$ that possess the characteristics outlined in Lemmas 2 and 3. Define $\mathrm{\Gamma }\left(\mathcal{T},y\right)$ as the set of schedules in $\mathrm{\Gamma }\left(\mathcal{T}\right)$ with a $f_{max}$-value less than $y$. Clearly, $\mathrm{\Gamma }\left(\mathcal{T},+\mathrm{\infty }\right)=\mathrm{\Gamma }\left(\mathcal{T}\right)$. Let $PO(\mathcal{T})$ represent the Pareto set, which includes all Pareto optimal points, with each point associated with a schedule.

We are ready to present the algorithm for solving $1|\prec ,2-subpt,BA|(C_{max},f_{max})$, Algorithm C_max-F_max (Algorithm 1).

Step 1 of Algorithm C_max-F_max can be executed in $O(n^2)$ time. Step 2 requires $O(n^2)$ time for each pass. During each pass of Step 2.1, every product is checked exactly once, starting from the last product-subsequence and proceeding to the first. Multiple passes of Steps 2.1 and 2.2 may occur in a single round. Steps 3 and 4 can be completed in $O(1)$ time per round.

In each pass, at least one product must be moved to the left. It is important to note that in Algorithm 1, products can only be moved leftward. Given that there are $n$ product-subsequences, each product can be moved to the left at most $n-1$ times. Consequently, the total number of passes is $O(n^2)$. Therefore, the overall running time of Algorithm C_max-F_max is $O(n^4)$.

Heuristic methods (e.g., Hidri & Tlija, 2024) are typically employed to handle complex dynamic constraints such as sequence-dependent setup times, but they come at the cost of optimality. The exact algorithm proposed above achieves a balance between computational efficiency and solution quality in polynomial time through rational design of batch structures (e.g., batch processing of common subassemblies and scheduling of unique subassemblies in Lawler’s order). Compared with heuristic methods, this algorithm provides theoretical optimality guarantees; compared with high-complexity exact methods (such as $O(n^6)$ algorithms), its computational efficiency is significantly improved. Future research can further expand its applicability in industrial scenarios by integrating dynamic constraint management (e.g., real-time priority adjustment) and parallel computing technologies (e.g., GPU acceleration).

Lemma 4 Let $S^{(e)}=(Q_1^{(e)},Q_2^{(e)},\dots ,Q_n^{(e)})$ be obtained at the $e$-th round of Algorithm C_max-F_max, where $e\ge 0$. Let $S=(Q_1,Q_2,\dots ,Q_n)$ be any one in $\mathrm{\Gamma }\left(\mathcal{T},y^{(e)}\right)$. Then, ${\cup }_{q=i}^n{Q}_q\subseteq {\cup }_{q=i}^n{Q}_q^{(e)}$, $i=n,n-1,\dots ,1$.

Proof 1 The proof is conducted using induction on $e$.

The base case $e=0$ is verified trivially. The initial schedule $S^{(0)}=(Q_1^{(0)},Q_2^{(0)},\dots ,Q_n^{(0)})$ is the natural feasible schedule, which inherently satisfies the lemma. This is because each product in $Q_i^{(e)}$ must have a successor in $Q_{i+1}^{(e)}$, and therefore, it cannot be included in $Q_{i+1}^{(e)}$ in any schedule in $\mathrm{\Gamma }\left(\mathcal{T},y^{(0)}\right)=\mathrm{\Gamma }\left(\mathcal{T}\right)$, $i=1,2,\dots ,n-1$.

Assume that the lemma holds for $S^{(e)}$ and any schedule in $\mathrm{\Gamma }\left(\mathcal{T},y^{(e)}\right)$. Now, consider $S^{(e+1)}$ and any schedule $S\in \mathrm{\Gamma }\left(\mathcal{T},y^{(e+1)}\right)$. Since $y^{(e+1)}<y^{(e)}$, $S\in \mathrm{\Gamma }\left(\mathcal{T},y^{(e)}\right)$. By the inductive assumption, the lemma holds for $S^{(e)}$ and S. Therefore, for $i=n,n-1,\dots ,1$, we have ${\cup }_{q=i}^n{Q}_q\subseteq {\cup }_{q=i}^n{Q}_q^{(e)}$. Equivalently, we have: for $i=1,2,\dots ,n$, ${\cup }_{q=1}^i{Q}_q^{(e)}\subseteq {\cup }_{q=1}^i{Q}_q$.

Consider the first (i.e., rightmost) inequality violation during the $(e+1)$-th round. Let the first moved product be $T_k\in Q_i^{(e)}$. Since the inequality $f_k^{(e)}<y^{(e+1)}$ does not hold and the unique subassemblies of the products in $Q_i^{(e)}$ are scheduled in Lawler’s order, $T_k$ and all the products which are in $Q_i^{(e)}$ but scheduled earlier than $T_k$ cannot stay in ${\cup }_{q=i}^n{Q}_q^{(e)}$. Therefore, we move these products from $Q_i^{(e)}$ into $Q_{i-1}^{(e)}$. By the inductive assumption, in S any of these products cannot stay in ${\cup }_{q=i}^n{Q}_q$, otherwise the last one will complete no earlier than $C_k(S^{(e)})$ and thus incur an inequality violation.

After moving these products to the left in $S^{(e)}$, we further adjust $S^{(e)}$ to obey the precedence constraints. Observing S accordingly, we can know that S coincides with the adjustment. Then we consider the next inequality violation, and so on. By repeating this argument, we ultimately demonstrate that the lemma holds for the $(e+1)$-th round.

By applying the principle of induction, the proof is thereby completed.

We get:

Lemma 5 Let $S^{(e)}=(Q_1^{(e)},Q_2^{(e)},\dots ,Q_n^{(e)})$ be obtained at the $e$-th round of Algorithm C_max-F_max, where $e\ge 0$. Let $S=(Q_1,Q_2,\dots ,Q_n)$ be any one in $\mathrm{\Gamma }\left(\mathcal{T},y^{(e)}\right)$. Then:

(1) $l(S^{(e)})\le l(S)$, where $l(S^{(e)})$ and $l(S)$ represent the number of nonempty product-subsequences in $S^{(e)}$ and S respectively;

(2) $B(Q_i^{(e)})\le B(Q_i)$, $i=1,2,\dots ,n$;

(3) $C(Q_i^{(e)})\le C(Q_i)$, $i=1,2,\dots ,n$.

Lemma 6 Let $S^{(e)}$ be obtained at the $e$-th round of Algorithm C_max-F_max, where $e\ge 0$. If $S^{(e)}=\mathrm{\varnothing }$, then $\mathrm{\Gamma }\left(\mathcal{T},y^{(e)}\right)=\mathrm{\varnothing }$. Otherwise, $S^{(e)}$ has minimum makespan in all schedules in $\mathrm{\Gamma }\left(\mathcal{T},y^{(e)}\right)$.

Proof 2 In the implementation of Algorithm C_max-F_max, we will get $S^{(e)}=\mathrm{\varnothing }$ when one of the following two cases occurs: Case (1). Find a product $T_k\in Q_i^{(e-1)}$ such that at least one of its successors has already been moved into $Q_i^{(e-1)}$ and $i=1$. Case (2). Find a product $T_k\in Q_i^{(e-1)}$ where $f_k^{(e-1)}<y^{(e)}$ is violated, and either $i=1$ or $T_k$ is the last product in $Q_i^{(e-1)}$. In Case (1), we know that $T_k$ cannot be scheduled without violating the precedence constraints in any feasible schedule. Therefore, we set $S^{(e)}=\mathrm{\varnothing }$ indicating that $\mathrm{\Gamma }\left(\mathcal{T},y^{(e)}\right)=\mathrm{\varnothing }$. In Case (2), if $i=1$, we know that no feasible schedule can arrange $T_k$ with a cost less than $y^{(e)}$. If $T_k$ is the last product in $Q_i^{(e-1)}$, then there will be an empty product-subsequence between two nonempty product-subsequences. We do not need to consider such a case. Therefore, we also set $S^{(e)}=\mathrm{\varnothing }$ indicating that $\mathrm{\Gamma }\left(\mathcal{T},y^{(e)}\right)=\mathrm{\varnothing }$.

Conversly, if $S^{(e)}\ne \mathrm{\varnothing }$, then by Lemma 5, $S^{(e)}$ has minimum makespan in all schedules in $\mathrm{\Gamma }\left(\mathcal{T},y^{(e)}\right)$.

By integrating the results of Lemmas 1 and 6, we obtain the following result:

Theorem 1 Algorithm C_max-F_max solves problem $1|\prec ,2-subpt,BA|(C_{max},f_{max})$ in $O(n^4)$ time. Moreover, the final schedule generated by the algorithm has the minimum makespan in all optimal schedules for $1|\prec ,2\text{-}subpt,BA|f_{max}$.

To solve $1|⪯,2-subpt,BA|(C_{max},f_{max})$ (the weak precedence constraints), we need to modify Step 1, Step 2.1 and Step 2.2 of Algorithm C_max-F_max slightly. In Step 1, we set the initial schedule $S^{(0)}=(\mathrm{\varnothing },\mathrm{\varnothing },\dots ,\mathrm{\varnothing },\mathcal{T})$, where the common subassemblies of the products in $\mathcal{T}$ are first processed as a batch, followed by the unique subassemblies, which are processed individually according to Lawler’s order while adhering to the precedence constraints. That is, we use the actual Lawler’s algorithm (Lawler, 1973) to schedule the unique subassemblies of the products in $\mathcal{T}$ in the time interval $[\delta +{\mathrm{\Sigma }}_{T_{j\mathrm{\prime }}\in \mathcal{T}}{t}_{j\mathrm{\prime }}^{(1)},\delta +{\mathrm{\Sigma }}_{T_{j\mathrm{\prime }}\in \mathcal{T}}{t}_{j\mathrm{\prime }}^{(1)}+{\mathrm{\Sigma }}_{T_{j\mathrm{\prime }}\in \mathcal{T}}{t}_{j\mathrm{\prime }}^{(2)})$. In Step 2.1, since the common subassemblies of $T_k$ and its successors can be in the same batch, we do not need Case (1). We just need Case (2) to ensure that the predecessors of $T_k$ and $T_k$ obey the weak precedence constraints. In Step 2.2, the unique subassemblies of the products in $Q_i^{(e)}$ must be processed individually, following Lawler’s order and complying with the precedence constraints.

Then we get:

Theorem 2 Modified Algorithm C_max-F_max solves problem $1|⪯,2-subpt,BA|(C_{max},f_{max})$ in $O(n^4)$ time. Moreover, the final schedule generated by the algorithm has the minimum makespan in all optimal schedules for $1|⪯,2-subpt,BA|f_{max}$.

The experiments

In this section, we present experimental results of our Algorithm C_max-F_max. Next, we will compare with algorithms for Pareto scheduling two-subassembly products without precedence constraints. The algorithm, implemented in PyCharm, was tested on randomly generated instances. We varied key factors. The number of jobs $n\in (10,100)$. The processing time for the common subassembly is uniformly distributed over the integer range [1, 5], and the processing time for the unique subassembly is uniformly distributed over the integer range [1, 10]. To implement the algorithm, 10 experiments were conducted for each order of magnitude of the job.

The average and maximum running times of Algorithm 1 in the article are shown in Table 1. In Table 2, we present the running times of the problem $1|2-subpt,BA|(C_{max},f_{max})$. To more effectively demonstrate the variation in average execution time relative to the number of jobs across both experimental conditions, the temporal performance trends are visualized in Figs. 2 and 3. using linear graphical representations.

Figure 2 demonstrates Algorithm C_max-F_max performance With precedence constraints. This figure compares the average and maximum execution times of Algorithm C_max-F_max under precedence constraints. The x-axis represents the number of jobs (ranging from 10 to 100), while the y-axis shows the runtime in seconds. The linear trend demonstrates that the algorithm’s runtime scales polynomially with problem size, as expected from its theoretical $O(n^4)$complexity.

Figure 3 demonstrates Algorithm C_max-F_max performance without precedence constraints. Similar to Fig. 1, this figure plots the runtime of Algorithm 1 but excludes precedence constraints. The steeper slope of the curves indicates that Algorithm C_max-F_max with precendence constraints significantly reduce computational overhead.

The computational efficiency comparison between Algorithm C_max-F_max (with precedence constraints) and Algorithm C_max-F_max (without precedence constraints) is quantified in Fig. 4. This area chart tracks the growing performance gap as job size ( $n$) increases from 10 to 100. Key observations include: At $n=10$, the time difference is minimal (0.0014 s). The gap grows polynomially, reaching 5.03 s at $n=100$. This visualization demonstrates how Algorithm 1’s strategic batch scheduling under precedence constraints consistently outperforms traditional approaches, particularly for $n>50$ where the difference becomes operationally significant in real-world scheduling scenarios.

The significance of algorithm running time extends beyond mere efficiency; it also serves as a quantitative indicator of theoretical solvability, thereby determining whether the model can transition from a theoretical framework to practical implementation.

For real-world instances ( $n\le 100$), $O(n^4)$ensures solvability within seconds. Compared to others, slower algorithms (e.g., $O(n^6)$ for bounded batch scheduling He, Lin & Lin (2015)) become infeasible.

Algorithms for lexicographical scheduling two-subassembly products with precedence constraints

Existing exact methods mostly focus on bi-objective optimization, while this article first achieves three-objective lexicographical optimization ( $f_{\mathrm{m}\mathrm{a}\mathrm{x}},g_{\mathrm{m}\mathrm{a}\mathrm{x}},C_{\mathrm{m}\mathrm{a}\mathrm{x}}$), which is closer to the multi-dimensional optimization needs in practical manufacturing (such as considering delay penalties, resource costs, and makespan simultaneously).

In this section, we focus on presenting an $O(n^4)$-time algorithm designed to solve problem $1|\prec ,2-subpt,BA|Lex(f_{max},g_{max},C_{max})$. Towards the end of this section, we will demonstrate how slight modifications to the algorithm enable it to also solve problem $1|⪯,2-subpt,BA|Lex(f_{max},g_{max},C_{max})$ in $O(n^4)$ time.

Let $S^{\ast }$ represent the final schedule produced by Algorithm C_max-F_max. According to Theorem 1, $S^{\ast }$ achieves the minimum makespan in all optimal schedules for problem $1|\prec ,2-subpt,BA|f_{max}$.

Let $\mathrm{\Gamma }\left(\mathcal{T},f_{max}(S^{\ast })\right)$ denote the set of feasible schedules for $\mathcal{T}$ whose $f_{max}$-values are equal to $f_{max}(S^{\ast })$. It is important to note that Lemma 2 (with “Pareto optimal” replaced by “lexicographically optimal”) and Lemma 3 still apply to $1|\prec ,2-subpt,BA|Lex(f_{max},g_{max},C_{max})$. Therefore, our focus is on the schedules in $\mathrm{\Gamma }\left(\mathcal{T},f_{max}(S^{\ast })\right)$ that exhibit the properties described in Lemmas 2 and 3. Let $\mathrm{\Gamma }\left(\mathcal{T},f_{max}(S^{\ast }),Y\right)$ represent the set of schedules in $\mathrm{\Gamma }\left(\mathcal{T},f_{max}(S^{\ast })\right)$ whose $g_{max}$-values are less than Y. Consequently, we have $\mathrm{\Gamma }\left(\mathcal{T},f_{max}(S^{\ast }),+\mathrm{\infty }\right)=\mathrm{\Gamma }\left(\mathcal{T},f_{max}(S^{\ast })\right)$.

We are ready to present the algorithm for solving $1|\prec ,2-subpt,BA|Lex(f_{max},g_{max},C_{max})$, Algorithm F_max-G_max-C_max (Algorithm 2).

For further details on the cyclic queue data structure and its basic operations, DEQUEUE and ENQUEUE, the reader may refer to Cormen et al. (2022).

Similar to the time complexity analysis of Algorithm C_max-F_max, it can be demonstrated that the running time of Algorithm F_max-G_max-C_max is $O(n^4)$.

We get:

Lemma 7 Let $S^{(e)}=(Q_1^{(e)},Q_2^{(e)},\dots ,Q_n^{(e)})$ be obtained at the $e$-th round of Algorithm F_max-G_max-C_max, where $e\ge 0$. Let $S=(Q_1,Q_2,\dots ,Q_n)$ be any one in $\mathrm{\Gamma }\left(\mathcal{T},f_{max}(S^{\ast }),Y^{(e)}\right)$. Then, ${\cup }_{q=i}^n{Q}_q\subseteq {\cup }_{q=i}^n{Q}_q^{(e)}$, $i=n,n-1,\dots ,1$.

Lemma 8 Let $S^{(e)}=(Q_1^{(e)},Q_2^{(e)},\dots ,Q_n^{(e)})$ be obtained at the $e$-th round of Algorithm F_max-G_max-C_max, where $e\ge 0$. Let $S=(Q_1,Q_2,\dots ,Q_n)$ be any one in $\mathrm{\Gamma }\left(\mathcal{T},f_{max}(S^{\ast }),Y^{(e)}\right)$. Then:

(1) $l(S^{(e)})\le l(S)$, where $l(S^{(e)})$ and $l(S)$ represent the number of nonempty product-subsequences in $S^{(e)}$ and S respectively;

(2) $B(Q_i^{(e)})\le B(Q_i)$, $i=1,2,\dots ,n$;

(3) $C(Q_i^{(e)})\le C(Q_i)$, $i=1,2,\dots ,n$.

Lemma 9 Let $S^{(e)}$ be obtained at the $e$-th round of Algorithm F_max-G_max-C_max, where $e\ge 0$. If $S^{(e)}=\mathrm{\varnothing }$, then $\mathrm{\Gamma }\left(\mathcal{T},f_{max}(S^{\ast }),Y^{(e)}\right)=\mathrm{\varnothing }$. Otherwise, $S^{(e)}$ has minimum makespan in all schedules in $\mathrm{\Gamma }\left(\mathcal{T},f_{max}(S^{\ast }),Y^{(e)}\right)$.

Theorem 3 Algorithm F_max-G_max-C_max solves $1|\prec ,2\text{-}subpt,BA|Lex(f_{max},g_{max},C_{max})$ in $O(n^4)$ time.

To solve $1|⪯,2-subpt,BA|Lex(f_{max},g_{max},C_{max})$, we need to modify Step 1 and Step 2.1 of Algorithm F_max-G_max-C_max slightly. In Step 1, we set the initial schedule $S^{(0)}=S^{\ast }$, where $S^{\ast }$ is the last schedule generated by modified Algorithm C_max-F_max. In Step 2.1, since the common subassemblies of $T_k$ and its successors can be in the same batch, we do not need Case (1). We just need Case (2) to ensure that the predecessors of $T_k$ and $T_k$ obey the weak precedence constraints.