Enhanced Optimization Strategies for No-Wait Flow Shop Scheduling with Sequence-Dependent Setup Times: A Hybrid NEH-GRASP Approach for Minimizing the Total Weighted Flow Time and Energy Cost

Abstract

Efficient production scheduling is a key challenge in industrial operations and continues to attract significant interest within the field of operations research. This paper investigates a range of methodological approaches designed to solve the permutation flow shop scheduling problem (PFSP) with sequence-dependent setup times (SDST). The main objective is to minimize the total weighted flow time (TWFT) while ensuring a no-wait production environment. The proposed solution strategy is based on using algorithms with a mixed integer linear programming (MILP) formulation, heuristics, and their combination. The heuristics utilized in this paper include an advanced greedy randomized adaptive search procedure (GRASP) based on a priority rule and Hybrid-GRASP-NEH (HGRASP), where Nawaz-Enscore-Ham (NEH) takes place to initiate solutions, based on iterative global and local search methods to refine exploration capabilities and improve solution quality. These approaches were validated using a comprehensive set of experiments across diverse instance sizes that proved the efficiency of HGRASP, with the results showing a high-performance level that closely matched that of the exact MILP approach. Statistical analysis via the Friedman test (χ² = 46.75, p = 7.04 × 10⁻¹¹) confirmed significant performance differences among MILP, GRASP, and HGRASP. While MILP guarantees theoretical optimality, its practical effectiveness was limited by imposed computational time constraints, and HGRASP consistently achieved near-optimal solutions with superior computational efficiency, as demonstrated across diverse instance sizes.

1. Introduction

In the context of increasing globalization and competition, industries are under constant pressure to maximize productivity, satisfy customer demand, and improve operational efficiency. Achieving these objectives relies heavily on the optimization of production scheduling, which plays a critical role in minimizing delays, reducing costs, and enhancing throughput. Depending on the type of production system, whether continuous or discontinuous, various scheduling models can be applied and have been studied in multiple papers. In our case, we focus on manufacturing processes involving machines organized in series, whose production order stays unchanged, which defines the PFSP [1]. The resolution of this matter requires taking into account all relevant constraints, regardless of the industry type, including machine preparation and the removal of jobs waiting between machines during their processing. Machine preparation refers to the time spent during the setup or adjustment of the machine for processing each new manufacturing batch job. The setup time may vary depending on the job’s position in the sequence. This constraint is referred to as SDST and has been addressed in previous studies [2]. Conversely, when the setup time is independent of the job sequence, this is called Sequence-Independent Setup Time (SIST) [3]. The removal of jobs waiting between machines during their processing requires eliminating the buffer waiting time that occurs when a job is transferred from one machine to the next. This requirement is typically implemented to avoid job quality degradation; it is commonly used in the plastics industry, in metal manufacturing, etc. By assembling previous constraints, a no-wait permutation flow shop problem under sequence-dependent setup times (NWPFSP-SDST) is designated. Since the PFSP cannot be fixed optimally within polynomial time for more than two machines, it is considered an NP-Hard problem. Therefore, it is crucial to develop approximate methods to solve it that include aspects such as heuristics and meta-heuristics [4]. These methods are appropriate for solving optimization scheduling problems such NWPFSP-SDST, on which we will focus in this study, aiming to minimize the TWFT and economic cost criteria in scheduling in the production industry under dynamic electricity pricing.

Many studies have been conducted that applied the same constraints to achieve multiple objectives, i.e., minimizing both the makespan and maximum tardiness [5]. Some worked on minimizing the TWFT [6], and others took into account the same constraints but had the objective of minimizing the makespan criterion [7]. The objective of our contribution is to ameliorate the GRASP approach and to implement a novel strategy using hybrid algorithms. These solution strategies aim to resolve an NWPFSP-SDST optimization scheduling problem.

The flow shop problem describes a kind of production system in which jobs move through a group of m machines in a fixed order, where each machine can process one job at a time and requires significant storage. As illustrated in Figure 1, all $n$ jobs were readily available before the problem’s starting time, with each job being processed across all $m$ machines, starting at machine ${\mathit{M}}_1$ and finishing at machine ${\mathit{M}}_m$. The sequence could be modified to satisfy the customer’s or the producer’s priorities relative to each job. The best way to integrate this option was to modify the first objective function term related to the total flow time (TFT) by assigning a weighting coefficient to each term. According to our research, this objective function has not been addressed in the previous studies on the NWPFSP-SDST problem, especially the second objective function term, whose value is relative to energy cost minimization. Regarding the no-wait constraint, this has been leveraged in previous studies to achieve different goals, such as makespan minimization, using several algorithms. Indeed, Fire Hawk Optimization (FHO) and Beluga Whale Optimization (BWO) were investigated and their results compared to those for the Campbell Dudek Smith (CDS) algorithm [8]. Likewise, in [9], the objective was also makespan minimization, this time by using a new dispatching rule: Principal Component Analysis (PCA-AS). The latter outperformed the first-in-first-out (FIFO) rules in terms of achieving the shortest processing time (SPT). Concerning the SDST constraint, this has already been integrated in various PFSP studies.

In [10], the authors focused on minimizing the makespan for the PFSP under SDST. They demonstrated that the proposed novel biogeography-based optimization (NBBO) algorithm effectively solved this problem by maintaining a balance between exploration and exploitation neighborhoods. This performance was achieved through modified insertion methods for both products and jobs, and a local search method based on SDST. This constraint was also incorporated [11] in a Green Hybrid Flow Shop Scheduling Problem. In that optimization problem, transport time was considered to simultaneously minimize both the maximum completion time and the total energy consumption through an improved memetic algorithm. Several studies have incorporated both constraints, i.e., the no-wait and SDST, to enhance the accuracy and applicability of scheduling models. In particular, in [12], the authors investigated the no-wait flow shop group scheduling problems with SDST constraint to minimize setup and waiting times in advanced production systems. The study demonstrated that the proposed revised multi-start simulated annealing (RMSA) algorithm consistently outperformed several Particle Swarm Optimization (PSO) and Variable Neighborhood Search (VNS) algorithms, particularly when addressing large-scale flow shop scheduling problems.

The authors of [13] applied these constraints to solve the NWPFSP-SDST and demonstrated that the population-based iterated greedy algorithm enhanced by the NEH procedure (PIG-NEH) outperformed seven population-based metaheuristic algorithms. Motivated by industrial needs to optimize both the TWFT criterion and energy cost, we have explored a variety of approaches to solve the NWPFSP-SDST problem, especially under Dynamic Electricity Pricing, in order to address this complex scheduling optimization problem. Our contribution involves the development of heuristics and combining them with mathematical formulation methods to enhance solution quality. These methods are widely used in scheduling optimization. In [14], the authors compared GRASP with the NEH heuristic for makespan minimization in permutation flow shop scheduling and demonstrated its superior performance.

This paper is structured as follows: Section 2 reviews relevant literature on the research problem. Section 3 introduces the mathematical formulation and modeling of our problem. Section 4 describes the proposed solution approaches. Section 5 presents and analyzes the numerical simulation results, and Section 6 summarizes the key contributions and outlines future research directions.

2. Literature Review

Scheduling problems, especially within complex industrial and computational ecosystems, are frequently classified as NP-complete. These problems highlight the computational challenges inherent in finding optimal solutions, particularly when the problem scale increases [15]. Within this domain, the NWPFSP-SDST emerges as a significant challenge which requires advanced algorithmic approaches and comprehensive study [16]. In Ref. [17], the authors addressed the flow shop scheduling problem under no-wait constraint by developing two genetic algorithms (GA) for makespan optimization. In ref. [7], the authors demonstrated that integrating flexible preventive maintenance (PM) scheduling with no-wait and SDST constraints yielded better makespan optimization than traditional approaches. Their study revealed that both the Li, Wang, and Wu heuristic (LWW) [18], which uses the Traveling Salesman Problem (TSP)-inspired Cheapest Insertion strategy, and the Fast Composite Heuristic (FCH) [19], which combines NEH-based construction, local search (RZ method), and backward swap improvement, outperformed MILP solutions, particularly for large problem instances. Furthermore, in [20], the authors modeled the NWPFSP-SDST with job release dates as an Asymmetric Traveling Salesman Problem with Ready Times (ATSP-RT), proving through comparative analysis that their Best Insertion Heuristic (BIH) was more effective than the Best Adding Heuristic (BAH) for makespan minimization.

The minimization of energy costs in Flow Shop and Flexible Flow Shop production scheduling has become increasingly critical in modern manufacturing. This objective now represents a key strategic priority for industrial enterprises, driven by both economic and ecological considerations. In such production systems, task scheduling directly impacts energy consumption in manufacturing workshops, particularly due to machine idle times during stoppages or setup periods [21]. Consequently, the challenge of producing more with less energy consumption makes machine scheduling significantly more complex [22]. This complexity arises from various factors including variable or constant operating speeds and peak energy demands. Energy optimization not only reduces operational costs but also enhances environmental sustainability [23], which is a crucial consideration for industries facing stringent regulations or seeking to improve their social responsibility. Practical implementations demonstrate that strategic production sequencing, such as avoiding concurrent startups of energy-intensive equipment, can yield substantial electricity cost savings.

In modern production workshops, manufacturing systems employ heterogeneous machine resources where tasks can be processed across multiple alternative machines, leading to more pronounced energy impacts. This increased flexibility [22] enables the selection of less energy-intensive machines or those better suited to specific workloads but requires sophisticated scheduling algorithms [24] to simultaneously achieve energy efficiency and meet production deadlines. The scheduling complexity is further compounded by specific job constraints such as no-wait requirements, which significantly challenge effective energy management in machine operations. Manufacturing systems often feature variable-speed machines, where selecting optimal production speeds becomes crucial, as inappropriate speed choices may lead to substantial energy waste [25]. Recent research demonstrated that advanced approaches like variable-speed scheduling (speed scaling) and strategic utilization of off-peak energy periods (green energy time slots) can yield considerable energy savings. Consequently, incorporating energy consumption as an optimization criterion has emerged as a strategic competitive advantage, as evidenced by practical implementations in energy-intensive industries such as automotive and aerospace manufacturing [24].

This work proposes a novel bi-objective optimization approach to simultaneously minimize TWFT and energy costs in NWPFSP_SDST. Ref. [13] addressed the same NWPFSP-SDST constraints under a mono-objective framework targeting TWFT minimization through the use of a hybrid differential evolution algorithm and developed eight population-based meta-heuristics: Population-based iterated greedy algorithm enhanced by the NEH procedure (PIG-NEH), population-based iterated greedy algorithm enhanced by the GRASP procedure (PIG-GRASP), population-based iterative local search algorithm enhanced by the NEH procedure (PILS-NEH), population-based iterative local search algorithm enhanced by the GRASP procedure (PILS-GRASP), migratory bird optimization enhanced by the NEH procedure (MBO-NEH), migratory bird optimization enhanced by the GRASP procedure (MBO-GRASP), artificial bee colony enhanced by the NEH procedure (ABC-NEH), and artificial bee colony enhanced by the GRASP procedure (ABC-GRASP). Our study extends this foundation by introducing a bi-objective perspective which optimizes both TWFT and energy cost, thus bridging production efficiency with sustainability goals, by employing MILP, GRASP, and an HGRASP which outperforms other methods. To our knowledge, this represents the first study to address this specific problem combination, thereby contributing new insights to the field. The bi-objective optimization problem has become increasingly critical as industries strive to balance production efficiency with environmental sustainability [26]. This dual-criteria optimization combines production-related performance metrics with energy consumption considerations [27] and creates complex trade-offs that require careful analysis. Previous research has demonstrated the inherent conflict between these objectives: Reducing flow time often requires increased machine speeds, which elevates energy consumption, while energy-saving strategies may extend processing times [28]. To address this trade-off, metaheuristic approaches such as the non-dominated sorting genetic algorithm II (NSGA-II) and multiobjective evolutionary algorithm based on decomposition (MOEA/D) have been employed to generate optimal Pareto fronts [29]. For instance, in [30], the authors implemented variable-speed machine (VSM) models to dynamically adjust energy usage while maintaining schedule feasibility. In recent studies, those authors further highlighted how practical constraints, including maintenance requirements and no-wait conditions, significantly impact optimization outcomes, particularly in energy-intensive industries like automotive manufacturing [31].

3. Formulation and Mathematical Representation of the Problem

3.1. Problem Statement

This problem consists of a set of machines in series: $M_1, M_2,\dots .M_m$. A batch of jobs $J=\{J_1,J_2, ...J_n$} is processed in a process starting with $M_1$ and ending its production cycle with $M_m$. Each job $J_j$ has an operating time ${ pr}_{ji}$ in a machine $M_i$. In this industrial context, jobs are constrained by a sequence-dependent setup time called ${ST}_{jki}$. If the job is first in its machine, the setup time is called ${ST}_{jji}$. Our problem consists of finding a sequence $\beta = \left[{\beta }_1, {\beta }_2,\dots ,{\beta }_n\right]$ whose aim is to minimize the TWFT in the first scenario and to minimize both TWFT and economic cost in the second scenario, under the constraint of no waiting.

Table 1. Notation used in the problem formulation.

Notation	Description
$\left\{M_1,M_2, M_3,\dots ,M_m\right\}$	The set of machines
$\left\{J_1{,J}_2, J_3,\dots ,J_n\right\}$	The batch of jobs
$\mathrm{N}=\left\{1,2,\dots ,\mathrm{n}\right\}$	Set of n jobs
j, k	Job’s index, j = 1, …, n, k = 1, …, n
i	Machine’s index, i = 1, …, m
${ST}_{jki}$	The setup time required on machine i when job j immediately precedes job k
${ST}_{jji}$	The setup time required on machine i when job j is the first in the sequence
$\mathsf{\beta }=\left[{\beta }_1, {\beta }_2,\dots ,{\beta }_n\right]$	The scheduling sequence
$X_{jk}$	Binary decision variable that equals 1 when job k is processed immediately following job j on the same machine, otherwise it is equal to 0
$C_{ji}$	Completion time of job j on machine i
$C_{jm}$	Completion time of job j on the last machine m
inf	Large value
${\xi }_j$	Weight (priority) of job j
${\omega }_1$	Weight (priority) associated with the TWFT
${\omega }_2$	Weight (priority) associated with the energy cost
${{Job}_{-}Position}_j$	Index of job j in the processing sequence
${cost}_j$	Unit cost of electricity for job
$e_j$	Energy consumption of job j
DEP ${ pr}_{ji}$	Dynamic_Electricity_Pricing Processing time of job j in machine i
${{Time}_{-}Diff}_{{\beta }_{t-1}{\beta }_t }$	Difference of times between two adjacent jobs

presents the notation of all parameters and variables used in this study.

The present study focuses on the resolution of the NWPFSP-SDST scheduling problem with the aim of minimizing the TWFT criterion and the energy cost, using the notation represented in Table 1, which is employed to express TWFT as follows:

$$\mathrm{T}\mathrm{W}\mathrm{F}\mathrm{T}= \sum _{j=1}^n{\mathcal{\xi }}_j\times C_{jm}$$

(1)

The TWFT is expressed as a weighted sum that incorporates the prioritization of urgent or critical jobs $j$ within the scheduling process, thereby enhancing the responsiveness of the system to high-priority tasks. The total energy cost is formulated as follows:

$${\mathrm{E}\mathrm{n}\mathrm{e}\mathrm{r}\mathrm{g}\mathrm{y}}_{-}\mathrm{C}\mathrm{o}\mathrm{s}\mathrm{t}=\sum _{\mathrm{j}=1}^{\mathrm{n}}{\mathrm{c}\mathrm{o}\mathrm{s}\mathrm{t}}_{\mathrm{j}}\times {\mathrm{e}}_{\mathrm{j}}\times {\mathrm{J}\mathrm{o}{\mathrm{b}}_{-}\mathrm{P}\mathrm{o}\mathrm{s}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}}_{\mathrm{j}}$$

(2)

Energy_Cost is expressed as a weighted summation that accounts for each job’s position in the processing sequence, its energy consumption, and the electricity cost per unit. This formulation reflects the temporal dimension of energy pricing by penalizing jobs placed later in the schedule, especially when electricity costs vary over time.

In order to simultaneously account for both scheduling efficiency and energy consumption, a composite objective function is constructed by integrating the TWFT and the total energy cost into a single expression:

$$\mathrm{O}\mathrm{b}\mathrm{j}\mathrm{e}\mathrm{c}\mathrm{t}\mathrm{i}\mathrm{v}\mathrm{e}\_\mathrm{F}\mathrm{u}\mathrm{n}\mathrm{c}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}={\mathsf{\omega }}_1\times \mathrm{T}\mathrm{W}\mathrm{F}\mathrm{T}\times {\mathsf{\omega }}_2\times \mathrm{E}\mathrm{n}\mathrm{e}\mathrm{r}\mathrm{g}\mathrm{y}\_\mathrm{C}\mathrm{o}\mathrm{s}\mathrm{t}$$

(3)

The constraints considered in the problem are presented as follows:

$$\sum _{j=1,j\ne k}^n{X}_{jk}=1, k=1,\dots$$

(4)

$$\sum _{k=0,j\ne k}^n{X}_{jk}\le 1, j=1,\dots ,n$$

(5)

$$X_{jk}+X_{kj}\le 1,\hspace{1em}\hspace{1em}\mathrm{j} =1,2,\dots , (\mathrm{n}-1); \mathrm{k}>\mathrm{j}$$

(6)

$$\begin{gathered} C_{ji}+{ pr}_{ki}+{\mathrm{S}\mathrm{T}}_{\mathrm{j}\mathrm{k}\mathrm{i}}+\mathit{inf}\times \left(X_{jk}-1\right) \le C_{ki}, \\ j=1,...,n; k=1,...,n; i=1,..,m; j\ne k \end{gathered}$$

(7)

$$C_{ji}=C_{j\left(i-1\right)}+{ pr}_{ji},\hspace{1em}\hspace{1em}j=1,...,n; i=1,...,m$$

(8)

$$C_{ji} \ge 0,\hspace{1em}\hspace{1em} j=1,...,n; i=1,...,m$$

(9)

$${ X}_{jk} \in \left\{0, 1\right\}, j=1,...,n; k=1,...,n; j\ne k$$

(10)

$${\mathsf{\omega }}_1 + {\mathsf{\omega }}_2 = 1,, {\mathsf{\omega }}_1,{\mathsf{\omega }}_2\in [0, 1]$$

(11)

Constraints (4) and (5) control the sequencing by ensuring that every job, except the first in the sequence, has precisely one direct predecessor and one direct successor, and conversely for immediate successors. Constraint (6) limits the total number of jobs that can act as a single successor to one, except for the last job in the sequence. On the other hand, Constraint (7) represents the disjunctive scheduling rule that controls the assignment rule of two tasks sharing the same machine. Constraint (8) enforces the no-wait condition between successive machines, which is a fundamental requirement in the NWPFSP_SDST. Equations (9) and (10) impose the non-negativity of limits for the completion times of the jobs and the binary nature of the assignment decision variables, respectively. Finally, Equation (11) enforces the constraint ${\omega }_1 + {\omega }_2 = 1$, with both weights bounded between 0 and 1, to ensure a normalized and controlled balance between the two optimization objectives.

In the context of the no-wait flow shop scheduling problem, we considered a set $\mathit{N} =\left\{1, 2,\dots ,n\right\}$ comprising n jobs that had to undergo processing across series-configured set $\mathit{M} =\left\{1, 2,\dots ,m\right\}$ of m machines. Each job $j \in N$ required a predetermined and deterministic treatment duration on each machine of the set $M$, denoted by ${pr}_{ji}$. The key feature of this problem class was the continuity constraint, i.e., once a job started processing on the first machine $M_1$, it had to proceed through all subsequent machines $\left\{M_2, M_3,\dots ,M_m\right\}$ without interruption or waiting time. Since the problem is a PFSP, all jobs had to be processed in the same machine order. According to the setup time, this depended on the sequence; in other words, it depended on the two adjacent jobs. For example, if two successive jobs, indexed $j$ and $k$, were processed on machine $i$, the setup occurred after completing job $j$ and before starting the job $k$; this is denoted as ${ST}_{jki}$. A setup could also take place immediately before processing the first job in order to prepare the machine. For instance, if the sequence started with the job $J_k$ on machine $i$, the setup time was denoted ${ST}_{kki}$. Furthermore, the completion time of job $J_k$ on machine $M_i$ was formally denoted as $C_{ki}.$

To optimize the NWPFSP-SDST, we integrated the following equation, which was used to calculate the time difference, $Time\_Diff$, between two adjacent jobs in a sequence β, as in [13], where $\beta = \left[{\beta }_1, {\beta }_2,\dots ,{\beta }_n\right]$. This process is defined as follows:

$${{Time}_{-}Diff}_{{\beta }_{(t-1)}{\beta }_t }=\underset{i=1,\dots ,m}{max}\left\{\delta \left(i, {\beta }_{(t-1)}, {\beta }_t\right)\right\}$$

(12)

where:

$$\delta \left(i,{\beta }_{(t-1)},{\beta }_t\right)={pr}_{{\beta }_{(t-1)}i}+\left(\sum _{k=i}^m({pr}_{{\beta }_{t}k}-{pr}_{{\beta }_{(t-1)}k})\right)+{ST}_{ {\beta }_{t-1}{\beta }_{t}k}$$

(13)

$${{Time}_{-}Diff}_{{\beta }_0{\beta }_1}=\underset{i=1, \dots , m}{max}\left\{{ST}_{{\beta }_1{\beta }_{1}i}+\sum _{k=i}^m\left({pr}_{{\beta }_{1}k}\right) \right\}$$

(14)

Equation (15) calculates the completion time of the first job in the last machine.

$${CT}_{{\beta }_{1}m }={{Time}_{-}Diff}_{{\beta }_0{\beta }_1}$$

(15)

The completion times of the remaining jobs on the last machine m were determined based on their dependency to the first job. Specifically, the completion time of the second job on machine m exceeded the ${Time\_Diff}_{{\beta }_0{\beta }_1}$ with the completion time of the first job on the last machine m, and similarly for subsequent jobs. The equation is given as follows:

$${CT}_{{\beta }_{t}m}={{Time}_{-}Diff}_{{\beta }_{t-1}{\beta }_t}+{CT}_{{\beta }_{t-1}m} h=2,\dots ,n$$

(16)

As previously noted, this paper aims to minimize two criteria: TWFT and the energy cost. The TWFT is expressed as follows:

$$TWFT=\sum _{j=1}^n{\xi }_j\times C_{jm}$$

(17)

The TWFT criterion was based on a weighted sum that incorporates the priority coefficients ${\xi }_j$ and the completion times of jobs on the last machine $C_{jm}$. These priority coefficients were critical, as they aligned with customer requirements, contributed to the optimization of jobs sequence across machines, and consequently enhanced operational efficiency. The minimization of the energy cost has also become a critical objective, particularly in modern industrial environments that implement dynamic electricity pricing applied by the electricity providers, which is based on differentiating energy costs during the day. They distinguish between off-peak hours, during which electricity is cheaper, and peak hours, when demand and thus cost is significantly higher. A program was implemented to account for this dynamic electricity cost, as defined in Equation (18):

$${Energy}_{-}Cost=\sum _{j=1}^n{cost}_j\times {Jo{b}_{-}Position}_j\times e_j$$

(18)

This equation assumes that the cost increases linearly with the job’s position in the sequence. Consequently, jobs scheduled later were more likely to incur higher electricity costs, particularly under dynamic energy pricing schemes, where rates increase during peak hours. The product of unit cost and energy consumption captured each job’s intrinsic economic impact. Hence, scheduling high-cost and high-consumption jobs later in the sequence disproportionately increased the total energy cost. This formulation assumed that $Energy\_Cost$ would increase linearly with the job’s position in the sequence, reflecting the tendency for later time slots to coincide with higher tariffs under dynamic pricing schemes. Consequently, it encouraged scheduling energy-intensive jobs earlier, when electricity rates were generally lower.

To ensure effective scheduling while maintaining energy efficiency, we propose a unified objective function combining TWFT and total energy cost:

$$Objectiv{e}_{\_}Function={\omega }_1\times TWFT+{\omega }_2\times Energy\_Cost$$

(19)

This Formulation (19) allowed for flexibility in decision-making by capturing the trade-off between timely production and sustainable energy use, making the model adaptable to a wide range of industrial settings. The weights ${\omega }_1$ and ${\omega }_2$ are non-negative and represent the relative importance assigned to each criterion. These weights could be adjusted according to operational needs or strategic priorities. To illustrate the problem, an example is provided where the weighting coefficients are set to ${\omega }_1=0.6$ and ${\omega }_2=0.4$, reflecting a 60% emphasis on scheduling performance and a 40% emphasis on energy cost. This choice reflects the common industrial priority of timely job completion to accommodate demand fluctuations, justifying a higher weight for TWFT. The values of weights can be modified to represent different relative priorities. While energy cost was also considered, it was secondary to ensuring smooth production flows.

3.2. Numerical Example of the NWPFSP-SDST with Four Jobs and Three Machines

In this subsection, we provide a detailed illustration of the considered NWPFSP-SDST through a simplified scheduling example involving four jobs processed on three machines across three factories. The processing times, denoted by ${pr}_{ji}$, the sequence-dependent setup times, ${ST}_{jki}$, and the energy costs represented by the matrices for all jobs transitions, are presented below.

$${\left[{pr}_{ji}\right]}_{4\times 3}=\left[\begin{array}{ccc}3& 2& 3\\ 11& 20& 10\\ 4& 8& 10\\ 15& 1& 9\end{array}\right]; {ST}_{jk1}= \left[\begin{array}{cccc}10& 8& 1& 4\\ 10& 2& 8& 8\\ 7& 10& 7& 4\\ 10& 5& 7& 3\end{array}\right]$$

$${ST}_{jk2}= \left[\begin{array}{cccc}9& 2& 4& 2\\ 7& 2& 9& 5\\ 5& 2& 7& 7\\ 8& 1& 7& 10\end{array}\right]; {ST}_{jk3}= \left[\begin{array}{cccc}5& 4& 9& 3\\ 7& 6& 5& 7\\ 3& 8& 4& 9\\ 1& 1& 8& 4\end{array}\right]$$

The weights of the jobs used in this example are ${\mathcal{\xi }}_1=1;{\mathcal{\xi }}_2=3;{\mathcal{\xi }}_3=3;{\mathcal{\xi }}_4=1.$ To provide a more concrete representation of the problem, a GANTT diagram was constructed by using MATLAB R2025a, as shown in Figure 2, to clearly illustrate the No-Wait constraint and visualize the SDST in the sequence: $\beta =\left[{\beta }_3,{\beta }_2,{\beta }_4,{\beta }_1\right]$. Consequently, the TWFT was calculated as follows:

$$TWFT={\mathcal{\xi }}_1\times C_{1m}+{\mathcal{\xi }}_2\times C_{3m}+{\mathcal{\xi }}_3\times C_{2m}+{\mathcal{\xi }}_4\times C_{4m}=1\times 29+3\times 62+3\times 78+1\times 82=531$$

4. The Proposed Methods to Solve the Problem

Employing heuristic methods to solve optimization problems in scheduling is widely recognized as a computationally efficient approach for obtaining high-quality solutions within a reasonable time limits. Numerous studies have demonstrated the effectiveness of such methods, particularly the NEH and GRASP heuristics. Motivated by these results, we implemented an enhanced GRASP method and a HGRASP approach that combined GRASP with NEH. This hybridization significantly improved the efficiency and robustness of scheduling solutions, making it particularly suitable for complex flow shop environments. Specifically, the NEH heuristic provided a strong initial solution by constructing a sequence based on job processing times and applying insertion-based refinements, while GRASP introduced randomization and adaptive local search to enhance solution diversity and mitigate the risk of being trapped in local optima.

Numerous studies have proposed enhancements to the NEH heuristic for solving flow shop problems, such as [32], which introduced a variant of the NEH heuristic that integrated the PMS (Processing time with Setup) measure, the ABS (Absolute-based) sorting indicator, and the D criterion (a specific tie-breaking or selection rule), NEHV({PMS,ABS,D}). This approach outperformed both the classical NEH algorithm and other NEH-based variants, making it one of the most effective heuristics for the PFSP.

Addressing the NWPFSP-SDST requires the implementation of both exact and approximate solution methods. For the exact approach, we adopted a MILP-based-formulation, while for the approximate approaches, we relied on heuristic methods and their hybridization in order to achieve high-quality solutions efficiently.

In this study, we investigate two heuristic algorithms developed within a constructive framework, specifically tailored to address the distributed permutation flow shop problem (DPFSP). Among them the GRASP method has proven to be a particularly effective heuristic approach for tackling complex combinatorial optimization problems, especially in flow shop scheduling contexts. Its efficiency has been widely demonstrated in several studies, such as [33]. Motivated by these results, we employed GRASP to determine the optimal jobs sequence under two different scenarios. In the first scenario, the implementation focused solely on minimizing the TWFT by applying Algorithm 1. In the second scenario, the approach was extended to a multi-objective context, aiming to simultaneously minimize both TWFT and energy cost through the application of Algorithm 2.

In most cases, particularly in PFSP, solution methodologies relied on priority-based rules to generate an initial job sequence. Among these approaches, one of the most widely adopted heuristics is the NEH algorithm, originally proposed by Nawaz, Enscore, and Ham. This heuristic is well known for its ability to construct high-quality schedules, particularly with the objective of minimizing the makespan. The classical NEH procedure operates by first ranking jobs in decreasing order of their total processing times and then progressively inserting each job into the position within the partial sequence that produces the best improvement in the objective function.

In this study, the NEH heuristic was adapted to our problem context in order to generate the initial solution by modifying both the priority rule and the optimization objective. Specifically, we computed a weighted total processing time of job j. The jobs were then sorted in descending order according to this measure, and each job was sequentially inserted into the position that minimized the TWFT instead of the makespan criterion.

Another widely adopted approach is GRASP, a multi-start metaheuristic composed of two main phases: A construction phase and a local search phase. In its general form, GRASP iteratively generates solutions by applying randomized greedy selection criteria within a Restricted Candidate List (RCL), followed by a neighborhood-based local search that refines each solution to enhance the objective value.

In our implementation, GRASP was further tailored to the specifics of the NWPFSP-SDST. The construction phase began with the sequence generated by the weighted NEH heuristic, and new candidate sequences were iteratively built by inserting remaining jobs based on TWFT or a composite cost function. At each step, an RCL was formed using threshold values derived from the range of evaluated candidates. During the local search phase, a pairwise exchange strategy was employed to explore neighboring solutions and refine the objective function. Furthermore, an adaptive mechanism was integrated to dynamically adjust the alpha parameter in cases of stagnation, thereby enhancing both solution quality and convergence stability.

These two methods, although different in nature, are complementary. The NEH heuristic provided a strong and consistent initial solution by constructing a sequence through job sorting and partial insertion, thereby acting as an intensification mechanism that rapidly converged toward promising regions of the solution space. In contrast, GRASP introduced diversification by generating multiple randomized solutions and refining them through local search. The hybridization leverages the strengths of both: NEH mitigated the randomness of GRASP by guiding the initial construction phase, while GRASP compensated for the deterministic nature of NEH by exploring alternative high-quality regions of the solution space. This synergy enabled the proposed HGRASP method to produce more robust and effective solutions, particularly in complex scheduling environments such as the no-wait PFSP with SDST.

Building on this, and in line with the first-case algorithm, we adopted the GRASP framework by repeatedly generating randomized sequences and refining them through local search. As an initialization step, a priority rule was applied which sorted the jobs in descending order of their weighted total processing time across all machines. This measure, denoted by the index ${\phi }_j$, is defined as:

$${\phi }_j= {\omega }_j\times \sum _{i=1}^m{pr}_{ji}$$

(20)

The enhanced GRASP procedure is presented in Algorithm 1. It began by fixing the first job according to the Longest Processing Time Weighted (LPTW) rule. This baseline was further refined by integrating a global search mechanism, embedded within the main loop. For each GRASP iteration (up to a defined maximum, maxit = 50), the algorithm constructed partial sequences by iteratively adding jobs. For every partial sequence, all possible job insertions were evaluated based on their TWFT, ensuring a broad exploration of the solution space. The candidate sequences were filtered through the RCL, which retained a subset of promising solutions. The RCL was determined dynamically using a threshold-based mechanism, controlled by the parameter $alpha$, which took values in the range of [0, 1]. In this study, we set alpha = 0.6. This iterative construction process enhanced the robustness of the search, reducing the likelihood of premature convergence and enhancing solution quality. The TWFT was evaluated at each iteration and compared to its previous value to retain the minimum. To illustrate this adaptation, we considered a flow shop scheduling problem involving six jobs and three machines.

Table 2. Summary of Job Data (processing time-weight-${\phi }_j-$ Job order).

Instances	${\mathit{M}}_1$	${\mathit{M}}_2$	${\mathit{M}}_3$	Weight	${\mathit{\phi }}_{\mathit{j}}$	Job Order
$J_1$	5	3	4	3	36	3
$J_2$	2	6	3	2	22	4
$J_3$	4	5	4	4	52	2
$J_4$	3	4	2	1	9	6
$J_5$	6	3	5	5	70	1
$J_6$	4	2	3	2	18	5

summarizes the job data, including processing times, weights, and the computed ${\phi }_j$ for each job. The corresponding setup times are provided in

Table 3. Setup times in machine 1.

Instances	${\mathit{J}}_1$	${\mathit{J}}_2$	${\mathit{J}}_3$	${\mathit{J}}_4$	${\mathit{J}}_5$	${\mathit{J}}_6$
$J_1$	1	3	2	3	3	3
$J_2$	2	1	3	2	2	2
$J_3$	1	3	1	1	2	2
$J_4$	3	1	2	1	1	3
$J_5$	2	3	2	3	1	1
$J_6$	2	2	3	2	1	1

,

Table 4. Setup times in machine 2.

Instances	${\mathit{J}}_1$	${\mathit{J}}_2$	${\mathit{J}}_3$	${\mathit{J}}_4$	${\mathit{J}}_5$	${\mathit{J}}_6$
$J_1$	3	1	2	3	1	3
$J_2$	2	2	3	2	2	2
$J_3$	1	1	1	1	2	1
$J_4$	3	1	2	1	1	3
$J_5$	2	3	1	3	1	1
$J_6$	1	2	3	2	1	2

and

Table 5. Setup times in machine 3.

Instances	${\mathit{J}}_1$	${\mathit{J}}_2$	${\mathit{J}}_3$	${\mathit{J}}_4$	${\mathit{J}}_5$	${\mathit{J}}_6$
$J_1$	2	3	2	1	3	1
$J_2$	1	1	3	2	2	2
$J_3$	1	3	1	1	2	2
$J_4$	3	1	2	3	2	3
$J_5$	2	3	2	3	1	1
$J_6$	1	3	3	2	1	1

. The job priority index ${\phi }_j$ was first computed as reported in Table 2.

Algorithm 1: GRASP method for minimizing TWFT

input:   1. pr: A matrix [m × n], representing the processing times of n jobs on m machines.

2. ST: A 3D array [n × n × m], representing the SDST

3. weights: A vector [1 × n], containing the job weights.   4. alpha: A parameter controlling the Restricted Candidate List (RCL), 0 ≤ α ≤ 1.   5. maxit: The maximum number of GRASP iterations.   6. Compute the initial sequence τ based on classifying jobs in descendant order    by this rule:

${\phi }_j={\omega }_j\times {\displaystyle \sum _{i=1}^m}{pr}_{ji}$

7. //Constructing the GRASP solution iteratively   8. for t = 1:maxit

9. $\hspace{1em} \mathbf{for} \mathrm{i} =1:(n-1)$

10.   Generate the set $\gamma = \left\{{\gamma }_K,\hspace{1em}K=\left\{1,\dots ,n-1\right\}\right\}$ of all possible sub-     sequences by adding each remaining job to the first job of the predefined         sequence τ and determining their TWFT to build the RCL and select         a random sequence from the RCL, where: $\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}RCL= \left\{{\gamma }_K,\hspace{1em}TWFT\left({\gamma }_K\right) ϵ \left[\epsilon , \vartheta \right]\right\}\hspace{1em}$ $$\begin{gathered} \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\epsilon =min\left(TWFT\left({\gamma }_K\right)\right) \\ \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\vartheta = min\left(\right(TWFT\left({\gamma }_K\right)+alpha\times \left[max\left(TWFT\left({\gamma }_K\right)\right)-min\left(TWFT\left({\gamma }_K\right)\right)\right] \end{gathered}$$

11.  end         Calculate the TWFT of the actual iteration’s sequence and compare it          to its previous value to select the optimal one

12. end     Output:

13. grasp_solution: The best sequence found

14. twft_best: The optimal TWFT value associated with grasp_solution

Based on the obtained values, the descending priority list was derived as: $\left\{J_5, J_3, J_1, J_2, J_6, J_4\right\}$. This ordered list defined the base sequence τ, which served as the starting point for the GRASP construction phase. The iterative solution-building process for the first GRASP iteration is illustrated in Figure 3.

Starting with the first job $J_5$, all possible insertions of the remaining jobs were evaluated to compute the corresponding TWFT for each partial sequence. For instance, inserting $J_3$ after $J_5$ yielded the sequence $\left\{J_5, J_3\right\}$ with $TWFT = 163$, while $\left\{J_5, J_1\right\}$ resulted in $TWFT = 138$, $\left\{J_5, J_2\right\}$ in $TWFT = 119$, $\left\{J_5, J_6\right\}$ in $TWFT = 113$ and $\left\{J_5, J_4\right\}$ in $TWFT = 95$. The RCL was then constructed. The lower bound $\epsilon$ was set to the minimum TWFT value, i.e., $\epsilon =$95, and the threshold $\vartheta$ was determined as: $\vartheta =min\left\{\left(95+0.6\times \left(163-95\right)\right)\right\} = 134.6$. Therefore, the $RCL= \left\{\left\{J_5, J_4\right\} , \left\{J_5, J_6\right\}, \left\{J_5, J_2\right\}\right\}$. A subsequence was then randomly selected from the RCL. Assuming $\left\{J_5, J_6\right\}$ was chosen, the procedure was repeated by successively inserting each of the remaining jobs $\left\{ J_3, J_1, J_2, J_4\right\}$. The RCL was reconstructed at each step until all six jobs had been sequenced, resulting in the sequence: $\left\{J_5, J_6, J_2, J_1, J_4, J_3\right\}$, with a total $TWFT = 492$. This construction procedure was repeated for a predefined number of iterations ($maxit = 50$). In each iteration, the generated sequence and its corresponding TWFT were recorded. After completing all iterations, the best solution, i.e., the sequence with the lowest TWFT, was retained as the final output of the GRASP algorithm.

Algorithm 2 focused on minimizing a bi-objective function that simultaneously reduced both TWFT and energy cost. To achieve this, an enhanced GRASP-based approach was implemented, following the general procedure of the first scenario. Initially, jobs were sorted in descending order according to the priority rule defined in Equation (20). The method combined global and local searches, employing an iterative looping mechanism that expanded the solution space by dynamically updating the RCL across multiple iterations. Each potential job sequence was systematically evaluated, with the first job in each sequence being selected according to the predefined priority rule to compute the corresponding TWFT. Subsequent jobs were added by iteratively updating the RCL, as detailed in Algorithm 2. Each global exploration introduced variability through the random selection of candidates, while a local search process embedded within the Restricted Candidate List (RCL) mechanism further refined the solutions. Additionally, the greediness parameter alpha was set to 0.6, achieving a balance between exploitation and diversification. This strategic approach enabled the construction of improved scheduling solutions that effectively optimize both objectives while maintaining computational efficiency.

Algorithm 2: GRASP method for minimizing TWFT and energy cost

input:   1. processing_times: A matrix [m × n], representing the processing times of n jobs         on m machines.

2. setup_times: A 3D array [n × n × m], representing the sequence-dependent setup        times.

3. weights: A vector [1 × n], containing the job weights.   4. cost_per_unit_time: Cost incurred per unit time for processing.   5. energy_usage: Energy consumption associated with job processing.   6. w1,w2: Weighting coefficients for TWFT and economic cost in the objective function   7. alpha: A parameter controlling the Restricted Candidate List (RCL), 0 ≤ α ≤ 1.   8. maxit: The maximum number of GRASP iterations.   9. Compute the initial sequence τ based on classifying jobs in descendant order    by this rule:

${\mathit{\phi }}_{\mathit{j}}={\mathit{\omega }}_{\mathit{j}}\times {\displaystyle \sum _{\mathit{i}=1}^{\mathit{m}}}{\mathit{p}\mathit{r}}_{\mathit{j}\mathit{i}}$

10. // Iterative GRASP Solution Construction (For each iterationmaxit)   11. for t = 1:maxit

12.  for i = 1:(n − 1)        Generate the set ${\varsigma }_1$ of all possible sub-sequences by adding each         remaining job to the first job of the predefined sequence τ and         calculating their TWFT and economic_cost to build the RCL and         select a random sequence from the RCL, where:         $\mathit{R}\mathit{C}\mathit{L}=\left\{{\mathit{\varsigma }}_{\mathit{K}},\mathit{T}\mathit{W}\mathit{F}\mathit{T}\left({\mathit{\varsigma }}_{\mathit{K}}\right)\mathit{ϵ}\left[\mathit{\epsilon }1,\mathit{\vartheta }1\right]\right\}$ $\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}{\mathit{f}}_{\mathit{k}}=\mathit{\omega }\times \mathit{T}\mathit{W}\mathit{F}\mathit{T}\left({\mathit{\varsigma }}_{\mathit{k}}\right)+\mathit{\psi }\times \mathit{C}\mathit{O}\mathit{S}\mathit{T}\left({\mathit{\varsigma }}_{\mathit{k}}\right)$ $\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\mathit{\epsilon }1=\mathit{m}\mathit{i}\mathit{n}\left({\mathit{f}}_{\mathit{K}}\right)$ $\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\mathit{\vartheta }1=\mathit{min}\left({\mathit{f}}_{\mathit{k}}\right)+\mathit{a}\mathit{l}\mathit{p}\mathit{h}\mathit{a} \times \left[\mathit{max}\left({\mathit{f}}_{\mathit{k}}\right)- \mathit{min}\left({\mathit{f}}_{\mathit{k}}\right)\right]$   13. end   14.  Calculate the TWFT of the actual iteration’s sequence and compare it      to its previous value to select the optimal one   15. end Output:   16. grasp_solution: The best sequence found   17. twft_best: The optimal TWFT value associated with grasp_solution   18. best_economic_cost: The best economic cost

To enhance solution quality and achieve a more effective minimization of the Weighted sum of TFT and energy cost, this study adopted a hybrid NEH-GRASP approach, whose main steps are presented in Algorithm 3.

Algorithm 3: HGRASP for minimizing TWFT and energy cost

input:  1. processing_times: A matrix [m × n], representing the processing times of n jobs             on m machines.

2. setup_times: A 3D array [n × n × m], representing the sequence-dependent setup            times.

3. weights: A vector [1 × n], containing the job weights.  4. cost_per_unit_time: Cost incurred per unit time for processing.  5. energy_usage: Energy consumption associated with job processing.  6. w1,w2: Weighting coefficients for TWFT and economic cost in the objective         function  7. alpha: A parameter controlling the Restricted Candidate List (RCL), 0 ≤ α ≤ 1.  8. maxit: The maximum number of GRASP iterations.  9. Generate an initial sequence τ using the NEH heuristic

10. // Iterative GRASP Solution Construction (For each iteration maxit)  11. for t = 1:maxit

12.    for i = 1:(n − 1)  13.     Generate the set ${\theta }_K$ of all possible sub-sequences by adding each           remaining job to the first job of the predefined sequence τ and           calculating their objective function:           $\mathit{o}\mathit{b}\mathit{j}={\mathit{w}}_1\times \mathit{T}\mathit{W}\mathit{F}\mathit{T}\left({\mathit{\theta }}_{\mathit{K}}\right)+{\mathit{w}}_2\times \mathit{C}\mathit{O}\mathit{S}\mathit{T}\left({\mathit{\theta }}_{\mathit{K}}\right)$;           To build the RCL and select a random sequence from the RCL, where:           $\mathit{R}\mathit{C}\mathit{L}= \left\{{\mathit{\theta }}_{\mathit{K}}, \mathit{T}\mathit{W}\mathit{F}\mathit{T}\left({\mathit{\theta }}_{\mathit{K}}\right) \mathit{ϵ} \left[\mathit{\epsilon }2, \mathit{\vartheta }2\right]\right\}$           $\mathit{\epsilon }2=\mathit{m}\mathit{i}\mathit{n}\left(\mathit{o}\mathit{b}\mathit{j}\right)$          $\mathit{\vartheta }2=\mathit{min}\left(\mathit{o}\mathit{b}\mathit{j}\right)+\mathit{a}\mathit{l}\mathit{p}\mathit{h}\mathit{a} \times \left[\mathit{m}\mathit{a}\mathit{x}\left(\mathit{o}\mathit{b}\mathit{j}\right)-\mathit{m}\mathit{i}\mathit{n}\left(\mathit{o}\mathit{b}\mathit{j}\right)\right]$  14.  end  15.  Apply pairwise exchange movement to improve the sequence, where we     swap two jobs in the sequence and compute the new objective function, if     improved, we accept the move  16.  if t > 1 &$\left|({\mathit{b}\mathit{e}\mathit{s}\mathit{t}}_{-}\mathit{o}\mathit{b}\mathit{j}\mathit{e}\mathit{c}\mathit{t}\mathit{i}\mathit{v}\mathit{e}\_\mathit{v}\mathit{a}\mathit{l}\mathit{u}\mathit{e}\left(\mathit{t}\right)-{\mathit{b}\mathit{e}\mathit{s}\mathit{t}}_{-}\mathit{o}\mathit{b}\mathit{j}\mathit{e}\mathit{c}\mathit{t}\mathit{i}\mathit{v}\mathit{e}\_\mathit{v}\mathit{a}\mathit{l}\mathit{u}\mathit{e}\left(\mathit{t}-1\right)\right|<$       $\mathit{s}\mathit{t}\mathit{a}\mathit{g}\mathit{n}\mathit{a}\mathit{t}\mathit{i}\mathit{o}\mathit{n}\_\mathit{t}\mathit{h}\mathit{r}\mathit{e}\mathit{s}\mathit{h}\mathit{o}\mathit{l}\mathit{d}$        $\mathit{a}\mathit{l}\mathit{p}\mathit{h}\mathit{a}=\mathit{a}\mathit{l}\mathit{p}\mathit{h}\mathit{a} \times 0.9$  17.  end  18. end  19. if the newly found sequence has a better total objective function, we update the best    solution  Output:  20. best_objective_value: Minimum TWFT and cost achieved  21. hgrasp_solution: The best sequence found

In this hybridization, the NEH heuristic was first applied to construct an initial high-quality solution by leveraging its efficient sequencing strategy and computing the combined objective value (TWFT and cost). To generate this initial solution, a weighted variant of the NEH heuristic was employed. Specifically, the total processing time of each job was multiplied by its corresponding weight, and jobs were then sorted in decreasing order of their weighted total processing times. To illustrate this, we provide an example based on the input data presented in Table 2, Table 3, Table 4 and Table 5, which detail the processing times, the sequence-dependent setup times for each machine, and the job weights.

As illustrated in Figure 4, the construction process began with the highest-priority job $\left\{J_5\right\}$. Job $J_3$ was then considered and inserted in all possible positions, resulting in two sequences: $\left\{J_5, J_3\right\}$ with $TWFT = 163$, and $\left\{J_3, J_5\right\}$ with $TWFT = 161$. Since the latter yielded a lower TWFT, the updated sub-sequence became $\left\{J_3, J_5\right\}$. The same insertion mechanism was then applied to job $J_1$, which was tested in all possible positions: $\left\{J_1, J_3, J_5\right\}$ with $TWFT = 263$, $\left\{J_3, J_1, J_5\right\}$ with $TWFT = 258$ and $\left\{J_3, J_5, J_1\right\}$ with $TWFT = 242$. Since the last sequence provided the minimum, it was selected as the best sequence in this stage, yielding $\left\{J_3, J_5, J_1\right\}$. This insertion procedure was repeated iteratively for each remaining job in the priority list, where, at every step, the position that minimized TWFT was selected. The final constructed sequence was $\left\{J_3, J_5, J_1, J_6, J_2, J_4\right\}$.

Subsequently, the GRASP method was applied to further explore and refine the solution space. This phase began with a global search implemented through the main loop, which generated a wide range of random sequences to be considered in the GRASP phase. Within this loop, each remaining job was sequentially combined with the current partial solution, forming subsequences of the type [current_solution, remaining_jobs], whose objective function values, denoted as ‘candidate_obj’, were computed. These subsequences constituted the RCL used in the local search, from which a job was randomly selected to be added to the current solution. To systematically explore the solution space and enhance optimization, an iterative search strategy was adopted. The local search was further reinforced by a pairwise exchange mechanism, where two jobs in the sequence were swapped. If the resulting sequence yielded an improved objective function, the move was accepted. To strengthen the search capability and avoid premature convergence, a perturbation function was integrated. This function was triggered when stagnation was detected, defined as an absolute change in the objective function smaller than a predefined threshold (stagnation_threshold= 1 × 10⁻³) between two successive iterations. In such cases, the value of the greediness parameter alpha was decreased, making the method more exploitative and thereby refining the best solutions. Overall, this hybrid methodology substantially improved solution quality, providing more effective minimization of both TWFT and energy cost in the flow shop scheduling problem.

5. Experimental Results

In this section, we present and analyze the computational results used to assess the performance of the proposed approaches. The comparison involves the exact method, represented by the MILP model, and two heuristic-based strategies developed for solving the PFSP. The first heuristic relied on a GRASP framework, where the NEH heuristic was employed to generate the initial solution. The second was a hybrid approach that integrated NEH with GRASP, further reinforced by a combination of global and local search procedures, as well as a perturbation mechanism, to enhance global exploration and improve solution quality.

For each of these methods, two problem formulations were examined. The first corresponded to a single-objective optimization problem, where the objective was to minimize the TWFT. The second formulation was bi-objective, simultaneously minimizing TWFT and energy consumption costs, thereby aligning with sustainable production considerations. Both formulations were tested across different problem sizes.

The problem instances were generated by using uniformly distributed random numbers for job processing times, setup times, weights, costs per unit time and energy usage, taking into account the interdependent relationships among these parameters and the substantial size of the considered instances. Processing times were drawn from a normal distribution within the range [3, 20], setup times in [1, 7], weights in [1, 5], costs per unit time in [1, 5], and energy usage in [5, 20]. The problem instances analyzed spanned a machine m count ranging from 2 to 6 and a job j count ranging from 4 to 16 for small sizes, as presented in

Table 6. The combined objective results for small-sized instances obtained by the MILP, GRASP, and HGRASP approaches in the with cost scenario.

Instances	MILP_with_Cost	CPU	GRASP_with_Cost	CPU	HGRASP_with_Cost	CPU
4 × 2	128	0.483497	157.6	0.004922	128	0.01424
4 × 4	149	0.827362	170.2	0.007685	149	0.024937
4 × 6	183.6	0.84384	233.4	0.010318	183.6	0.033093
6 × 2	231.2	0.857981	249.4	0.011505	231.2	0.047537
6 × 4	252.6	0.913436	343.6	0.01939	252.6	0.08199
6 × 6	324.8	0.866577	343.6	0.02547	324.8	0.134714
8 × 2	453.8	5.545385	577.6	0.024181	453.8	0.22337
8 × 4	364	5.197911	438	0.039558	364	0.256669
8 × 6	568.8	5.572337	719.2	0.056631	568.8	0.376332
9 × 2	512.8	73.24164	604	0.039393	512.8	0.263522
10 × 2	463	682.565	631.6	0.041984	463	0.288285
10 × 4	870.6	8038.059	1083.8	0.113576	864.6	0.979387
10 × 6	710.8	1545.224	889	0.237046	710.8	1.658513
11 × 2	604.4	8448.69	762.8	0.059704	604	0.45758
11 × 4	834.2	8693.227	979	0.161247	831.4	0.915944
11 × 6	773.6	8962.248	1078.6	0.263086	769.4	2.500102
12 × 2	694.8	8221.32	744	0.285	694.6	1.756422
12 × 4	744	8024.56	1037.6	0.364791	739.8	1.5741
12 × 6	1026.6	8791.96	1312.8	0.46432	1026.6	2.98532
14 × 2	1055.6	8409.229	1372.4	0.212815	1055.6	1.556125
14 × 4	1104	8825.33	1497	0.334586	1102.2	3.263511
14 × 6	1320	8814.981	1760	0.490678	1311	4.12376
15 × 2	1339	8731.47	1714.2	0.15312	1337.8	1.214194
15 × 4	1408.8	8310.07	1932.6	0.271819	1397.6	1037.376
15 × 6	1435	7784.16	1846	0.307384	1433.6	2.806979
16 × 2	1432.8	8105.865	2003.4	0.32089	1430	3.904076
16 × 4	1332.2	8875.07	1705	0.424214	1321.8	4.419143
16 × 6	1617.8	8706.346	2057.8	0.373705	1607.6	929.5851

and

Table 7. The TWFT results for small-sized instances obtained by the MILP, GRASP, and HGRASP approaches in the without cost scenario.

Instances	MILP_No_Cost	CPU	GRASP_No_Cost	CPU	HGRASP_No_Cost	CPU
4 × 2	72	0.551485	88	0.003894	72	0.01607
4 × 4	122	0.809368	155	0.007995	122	0.024026
4 × 6	183	0.882297	217	0.009107	183	0.043652
6 × 2	219	0.863523	236	0.010178	219	0.0515
6 × 4	218	0.936554	311	0.017959	218	0.076174
6 × 6	305	0.790023	405	0.024188	305	0.11144
8 × 2	247	5.26622	332	0.021184	247	0.137919
8 × 4	300	4.267917	352	0.036658	300	0.235371
8 × 6	428	5.397961	553	0.054272	428	0.266795
9 × 2	265	51.20794	352	0.034081	266	0.199902
10 × 2	312	700.3466	459	0.037256	312	0.251838
10 × 4	510	8065.949	759	0.104095	511	0.719208
10 × 6	661	8001.486	883	0.235092	662	1.376684
11 × 2	478	8336.556	679	0.0626	480	0.334268
11 × 4	605	8523.4	846	0.168437	608	0.970616
11 × 6	603	8582.25	784	0.300346	608	1.866979
12 × 2	527	8894.34	744	0.285314	526	2.73268
12 × 4	480	8064.35	558	0.15963	476	2.97325
12 × 6	898.99	8257.89	1186	0.21468	895	3.05235
14 × 2	662	7770.98	950	0.26096	655	1.439907
14 × 4	760	8172.11	1092	0.392174	755	2.776949
14 × 6	1064	8353.24	1424	0.587429	1062	4.307518
15 × 2	729	8869.72	1093	0.147948	728	1.080163
15 × 4	968	8028.84	1453	0.304946	974	2.270592
15 × 6	1221	8899.254	1730	0.299482	1207	2.690989
16 × 2	753	8105.865	1056	0.294249	748	3.704076
16 × 4	1107	8885.763	1631	0.43923	1101	949.2269
16 × 6	1283	8354.98	1818	0.353004	1283	3.813457

, with and without cost scenario. For medium sizes, as presented in

Table 8. The TWFT results for medium-sized instances obtained by the GRASP and HGRASP approaches in the with cost scenario.

Instances	GRASP_with_Cost	CPU	HGRASP_with_Cost	CPU
10 × 5	880.6	0.188309	716.2	1.194389
10 × 10	964.8	0.192859	787.8	1.30806
10 × 20	1686.6	0.497709	1466.4	1039.795
20 × 5	3162.2	0.751539	2253.4	914.451
20 × 10	3696	1.321405	2598	14.75127
20 × 20	3949.4	3.13167	3152.6	38.10523
30 × 5	7115.4	2.688724	5378.6	34.67269
30 × 10	7667.6	6.789231	5756.2	85.31424
30 × 20	8892.2	19.05765	6410.2	271.5585
40 × 5	12,025	10.38459	8528.8	176.7961
40 × 10	14,347.8	18.54274	10,202.6	257.1368
40 × 20	16,486.4	28.28212	12,246.6	465.6983
50 × 5	19,500.2	15.08431	13,785.6	228.4902
50 × 10	21,366.4	28.79833	15,603.2	437.4322
50 × 20	26,731.6	81.68128	19,301.4	1209.424
60 × 5	27,207.8	27.13161	19,929.8	423.5531
60 × 10	27,979.8	80.37015	20,010.6	1123.819
60 × 20	36,391.8	83.54909	25,966.6	1366.723
70 × 5	38,488.8	66.16749	27,270.4	899.648
70 × 10	40,060	93.59539	27,767.6	1616.044
70 × 20	43,623	173.7876	32,038.4	9404.215
80 × 5	46,045.2	73.92481	32,966.4	7564.451
80 × 10	54,373.8	121.7197	37,524.8	2945.994
80 × 20	63,102.4	168.8341	44,349.4	3520.409
90 × 5	60,713.8	88.84981	41,778.6	2099.712
90 × 10	66,856.8	6716.684	44,973.8	2833.419
90 × 20	84,356	333.5044	58,237.2	4395.582

and

Table 9. The TWFT results for medium-sized instances obtained by the GRASP and HGRASP approaches in the without cost scenario.

Instances	GRASP_Without_Cost	CPU	HGRASP_Without_Cost	CPU
10 × 5	926	0.176382	612	1.733054
10 × 10	886	0.162359	731	1.093812
10 × 20	1847	0.388907	1578	4.029038
20 × 5	2493	0.669454	1604	1047.307
20 × 10	3420	1.331791	2356	13.46942
20 × 20	4611	3.268619	3404	32.92203
30 × 5	5836	2.648866	3708	35.43584
30 × 10	7763	7.71572	4816	81.70542
30 × 20	9080	17.24935	6014	203.5624
40 × 5	9436	11.04125	5875	132.3552
40 × 10	13,681	20.75188	9085	257.4249
40 × 20	17,596	24.67426	11,289	363.3522
50 × 5	16,501	15.91151	9555	202.0321
50 × 10	18,955	30.37962	11,751	379.8803
50 × 20	26,353	57.97886	16,824	1115.603
60 × 5	23,084	24.25255	13,642	406.6576
60 × 10	28,309	44.58684	17,082	1046.904
60 × 20	37,793	143.5776	23,085	2056.246
70 × 5	29,549	51.64724	17,350	881.3786
70 × 10	34,509	92.87961	20,121	1740.666
70 × 20	45,243	159.5702	26,892	2313.605
80 × 5	37,697	53.30514	21,489	856.9849
80 × 10	48,958	171.6785	28,875	2611.741
80 × 20	60,889	330.2226	35,022	4392.28
90 × 5	44,724	126.8858	26,521	1701.633
90 × 10	59,498	138.6461	33,933	2491.929
90 × 20	78,684	388.4105	45,721	12,646.3

, the job number was chosen from 10 to 90 and machine m counting from 5 to 20, and we chose large size instances, as presented in

Table 10. The combined objective results for big-sized instances obtained by the GRASP and HGRASP approaches in the with cost scenario.

Instances	GRASP_with_Cost	CPU	HGRASP_with_Cost	CPU
100 × 10	79,657.8	293.8451	56,516.4	9750.367
100 × 20	97,721.2	17,039	66,982.6	52,725.08
150 × 10	177,235.4	1346.159	119,727	85,368.56
150 × 20	213,535.6	2378.814	148,581.4	272,275
200 × 10	330,066	3865.77	226,082	277,537.2
200 × 20	5.3273 × 105	5465.933	3.7039 × 105	936,854.013
250 × 10	6.7145 × 105	3597.398	4.7466 × 105	1,069,524.945
250 × 20	7.4051 × 105	4696.030	5.3248 × 105	1,460,002.578
300 × 10	9.6098 × 105	5141.800	6.8893 × 105	5,617,537.53
300 × 20	1.0985 × 106	60,968.76	7.6364 × 105	3,963,558.035

and

Table 11. The TWFT results for big-sized instances obtained by the GRASP and HGRASP approaches in the without cost scenario.

Instances	GRASP_Without_Cost	CPU	HGRASP_Without_Cost	CPU
100 × 10	73,605	119.5234	42,994	4476.029
100 × 20	100,539	407.2744	55,615	27,445.84
150 × 10	165,864	768.3784	89,122	95,728.93
150 × 20	206,702	1597.958	111,719	178,592
200 × 10	292,628	1016.7105	155,357	196,407
200 × 20	4.9816 × 105	1359.0271	3.1394 × 105	14,862,687.07
250 × 10	5.8482 × 105	3394.8423	3.6326 × 105	130,521,021.3
250 × 20	7.5386 × 105	3662.2220	4.3873 × 105	1,195,036,049.4
300 × 10	8.5693 × 105	57,811.2246	5.2336 × 105	11,004,799,807.8
300 × 20	1.0655 × 106	64,417.9917	6.447 × 105	21,976,406,020.4

, i.e., j ∈ [100, 300], and m ∈ [10, 20], using Python 3.13.3 and calling CPLEX. This process was carried out on a MacBook Air 10.1, M1, 2020, 8Go (Apple Inc., Cupertino, CA, USA).

We began by comparing the results of each method for the single objective minimization in small sized instances, as shown in Table 6. For these small instances, the MILP model served as the reference benchmark to assess the quality of the heuristic and metaheuristic solutions, with the execution time limited to 8000 s.

The results highlighted the robustness and effectiveness of the proposed hybrid method in solving the single-objective optimization problem. This robustness was confirmed by the strong consistency of its outcomes with those of the MILP approach, which was used as a benchmark for optimality. In contrast, the solutions obtained by the GRASP-based NEH method deviated significantly, underscoring its limitations in identifying optimal solutions.

To further evaluate the statistical significance of the performance differences between our proposed HGRASP method and the benchmark methods (GRASP and MILP), we applied the Wilcoxon signed-rank test. This test was performed on the small-sized instances, as reported in

Table 12. Friedman test results including mean ranks and statistical values for the compared methods.

Method	Mean Rank—Objective Function Value	Mean Rank—Computational Time
MILP	1.55	3
GRASP	3	1
HGRASP	1.44	2
N	24	24
Chi-Square	46.75	56
Df	2	2
p-value	7.04 × 10−11	6.91 × 10−13

. Since MILP provides optimal values for small instances, it served as a reliable reference for comparison.

Table 12 presents the results of the Friedman test applied to the 14 benchmark instances, showing the mean ranks of the compared methods and the associated statistical measures used to assess the significance of their performance differences.

The p-value was well below 0.05, indicating that the differences among the three methods were statistically significant. Although MILP was theoretically the most accurate approach due to its exact nature, its average rank was slightly lower than that of HGRASP. This discrepancy was mainly attributable to the 8000-s time limit imposed on MILP executions to prevent excessive computational time. For some medium-sized instances, MILP was unable to reach the optimal solution within this limit, which reduced its relative performance compared to HGRASP, which consistently produced high-quality solutions in significantly shorter times.

To provide a more tangible comparison between the methods, we selected the 10 × 4 instance as a representative case to visualize the scheduling outcomes of MILP, GRASP, and HGRASP using Gantt charts. This instance was specifically chosen because it belongs to the small-size category, for which the MILP model remains computationally feasible. As such, it served as a valuable reference for assessing the accuracy and reliability of the proposed heuristic and hybrid methods.

To illustrate the differences in schedules produced by the three methods and provide visual confirmation of the numerical results, particularly under the no-wait and SDST constraints, we used the data reported in

Table 13. Processing Times of 10 jobs on four machines in the illustrative example.

Instances	${\mathit{M}}_1$	${\mathit{M}}_2$	${\mathit{M}}_3$	${\mathit{M}}_4$
$J_1$	8	6	6	8
$J_2$	9	8	8	9
$J_3$	6	7	9	8
$J_4$	6	8	8	8
$J_5$	7	9	7	9
$J_6$	5	6	6	5
$J_7$	8	7	7	9
$J_8$	5	8	7	9
$J_9$	5	7	6	7
$J_{10}$	9	5	6	5

,

Table 14. Setup Times of 10 Jobs on the first machine in the illustrative example.

Instances	${\mathit{J}}_1$	${\mathit{J}}_2$	${\mathit{J}}_3$	${\mathit{J}}_4$	${\mathit{J}}_5$	${\mathit{J}}_6$	${\mathit{J}}_7$	${\mathit{J}}_8$	${\mathit{J}}_9$	${\mathit{J}}_{10}$
$J_1$	3	4	1	2	1	1	2	2	2	2
$J_2$	1	2	2	2	2	2	1	2	2	2
$J_3$	2	2	2	1	1	1	3	1	1	1
$J_4$	1	1	1	2	2	3	2	2	1	4
$J_5$	2	2	2	2	1	1	2	2	1	1
$J_6$	2	2	1	1	1	2	2	1	2	2
$J_7$	1	2	2	1	1	2	1	2	1	1
$J_8$	2	1	2	1	2	1	1	2	2	1
$J_9$	1	1	1	1	2	1	2	2	2	2
$J_{10}$	1	2	2	2	2	1	2	2	2	2

,

Table 15. Setup Times of 10 Jobs on the second machine in the illustrative example.

Instances	${\mathit{J}}_1$	${\mathit{J}}_2$	${\mathit{J}}_3$	${\mathit{J}}_4$	${\mathit{J}}_5$	${\mathit{J}}_6$	${\mathit{J}}_7$	${\mathit{J}}_8$	${\mathit{J}}_9$	${\mathit{J}}_{10}$
$J_1$	4	3	2	1	1	2	1	1	1	2
$J_2$	1	2	1	1	1	2	1	1	1	2
$J_3$	1	1	2	2	2	1	4	1	2	1
$J_4$	2	1	1	2	3	1	2	1	1	5
$J_5$	1	1	1	1	2	1	2	1	1	1
$J_6$	1	1	1	1	1	2	1	2	1	2
$J_7$	1	1	2	1	1	2	1	2	1	1
$J_8$	1	2	1	1	2	2	1	2	2	2
$J_9$	1	1	2	1	1	2	2	1	2	1
$J_{10}$	2	2	2	2	1	1	1	1	2	1

,

Table 16. Setup Times of 10 Jobs on the third machine in the illustrative example.

Instances	${\mathit{J}}_1$	${\mathit{J}}_2$	${\mathit{J}}_3$	${\mathit{J}}_4$	${\mathit{J}}_5$	${\mathit{J}}_6$	${\mathit{J}}_7$	${\mathit{J}}_8$	${\mathit{J}}_9$	${\mathit{J}}_{10}$
$J_1$	3	5	1	2	1	1	2	2	1	1
$J_2$	1	1	1	1	2	2	1	2	1	1
$J_3$	2	2	1	2	2	2	3	1	1	2
$J_4$	2	2	2	2	1	4	1	1	2	4
$J_5$	1	2	2	1	1	1	2	1	2	2
$J_6$	2	1	1	2	2	2	1	1	1	2
$J_7$	1	1	1	1	2	2	1	1	2	2
$J_8$	2	2	2	2	1	1	2	2	2	2
$J_9$	1	1	1	1	2	1	2	2	1	1
$J_{10}$	1	2	1	2	2	1	1	1	1	1

and

Table 17. Setup Times of 10 Jobs on the fourth machine in the illustrative example.

Instances	${\mathit{J}}_1$	${\mathit{J}}_2$	${\mathit{J}}_3$	${\mathit{J}}_4$	${\mathit{J}}_5$	${\mathit{J}}_6$	${\mathit{J}}_7$	${\mathit{J}}_8$	${\mathit{J}}_9$	${\mathit{J}}_{10}$
$J_1$	5	3	1	2	1	1	1	1	1	2
$J_2$	1	2	1	1	1	2	2	2	1	2
$J_3$	1	1	1	1	1	2	4	1	2	2
$J_4$	1	1	1	1	1	3	2	1	1	3
$J_5$	1	1	1	1	1	2	2	1	2	1
$J_6$	2	2	2	1	1	2	2	2	2	1
$J_7$	1	2	2	1	2	1	2	2	2	1
$J_8$	1	2	2	2	1	1	1	1	1	1
$J_9$	2	2	1	2	2	1	2	2	2	2
$J_{10}$	2	1	1	2	1	1	2	2	2	1

. Each job was characterized by a specific weight, cost per unit time, and energy consumption, as follows: $weights =[3, 4, 4, 4, 3, 2, 1, 4, 4, 1]$, $cost\_per\_unit\_time = [4, 2, 4, 3, 3, 2, 3, 3, 4, 2]$ and $energy consumption = [10, 10, 9, 9, 9, 6, 10, 10, 8, 8]$.

The Gantt charts presented in Figure 5, Figure 6, Figure 7, Figure 8, Figure 9 and Figure 10 clearly illustrate the differences in schedules produced by the three methods and provide a visual confirmation of the numerical results, particularly under the no-wait and SDST constraints. The job sequences obtained by each method were as follows: MILP-No-Cost: [${J_9,J_8,J}_2, J_3, J_5, J_4, J_1, J_6, J_{10}, J_7$], HGRASP-No-Cost: ${J_9,J_4,J}_8, J_2, J_3, J_5, J_1, J_6, J_{10}, J_7$, GRASP-No-Cost: [${J_2,J_7,J}_{10}, J_6, J_5, J_1, J_9, J_4, J_8, J_3$], and MILP-With-Cost: [${J_9,J_1,J}_8, J_3, J_4, J_2, J_5, J_7, J_6, J_{10}$], HGRASP-With-Cost: [${J_9,J_4,J}_8, J_2, J_3, J_5, J_1, J_6, J_{10}, J_7]$, and GRASP-With-Cost: [${J_2,J_7,J}_{10}, J_6, J_5, J_1, J_9, J_4, J_8, J_3$].

The corresponding TWFT and combined objective values (TWFT + energy cost) may be summarized as follows:

• MILP: TWFT = 1889, Combined objective = 1674.8
• HGRASP: TWFT = 1890, Combined objective = 1674.8
• GRASP: TWFT = 2599, Combined objective = 2200

The results illustrated by these Gantt charts further demonstrate the effectiveness of the HGRASP method, which produced schedules that matched or closely approximated the objective function values obtained by the MILP model, which is a method widely recognized for its accuracy on small-sized instances. This visual alignment highlights the high quality of the solutions delivered by HGRASP in terms of schedule structure, TWFT and overall objective function value, while achieving these results in a significantly shorter computational time compared to MILP.

This improvement can be attributed to several key enhancements integrated into the HGRASP_with_cost algorithm. Unlike the standard GRASP, which initializes the search using a priority rule based on weighted processing times, HGRASP_with_cost employs the NEH heuristic to construct the initial sequence, a strategy well-known for generating near-optimal permutations in flow shop environments. Consequently, HGRASP starts each GRASP iteration from a higher quality solution, which accelerates convergence and reduces the risk of becoming trapped in low-quality regions of the solution space. Additionally, HGRASP incorporates a pairwise exchange local search after selecting a random sequence from the RCL, refining the solution through job swaps that improve the overall objective. Finally, to enhance search diversification, HGRASP dynamically adjusts the greediness parameter (alpha) based on a stagnation threshold, which is absent in the standard GRASP. This feature enables HGRASP to escape local optima and explore new regions of the solution space when progress stalls.

To support and visualize the results obtained for different instances obtained using the MILP, GRASP, and HGRASP approaches in both the with and without cost scenario, boxplots were employed, as illustrated in Figure 11 and Figure 12, to depict the distribution of objective function values across multiple executions. These visualizations offer comparative insights into the performance of the three approaches in both mono-objective and bi-objective contexts. The data used to construct these boxplots correspond to the experimental results summarized in Table 2, Table 3, Table 4 and Table 5, ensuring a consistent and integrated analysis. In the mono-objective case, the boxplots indicate that HGRASP consistently outperformed the standard GRASP method and aligned closely with the MILP results.

Similarly, in the bi-objective scenario, the hybrid approach consistently attained optimal objective values, as evidenced by a lower median and a narrower interquartile range. These observations underscore the effectiveness of incorporating the NEH heuristic to guide the initial solution construction, alongside the integrated local and global search mechanisms and the perturbation strategy to enhance exploration. Consequently, the boxplots not only confirm the superiority of the hybrid method but also highlight the benefits of combining intensification and diversification strategies within the GRASP framework for addressing complex flow shop scheduling problems.

For the two heuristic methods, as specified in their respective algorithms, multiple executions were carried out for each instance. This repetition was intended to explore a broad range of possible job sequences and to enhance the robustness of the solution process. For each run, a convergence curve was plotted based on the best solution obtained, enabling a detailed examination of the evolution of the objective function throughout the algorithm’s progression. This approach provides deeper insight into the performance dynamics of the method and ensures that the final solution is not only optimal within a single run but consistently effective across multiple iterations, thereby reinforcing the reliability of the results.

6. Conclusions

In this paper, a GRASP was developed and enhanced through the integration of a priority rule, leading to improved solution quality in both scenarios, i.e., with and without cost, where the objective was to minimize TWFT and energy consumption, thereby promoting more sustainable and energy-aware production systems.

Additionally, a hybrid approach was proposed, combining an initial solution generated by the NEH heuristic with a GRASP-driven development phase. This hybrid framework incorporated both local and global search mechanisms, which play a crucial role in exploring the solution space, avoiding local optima, and significantly strengthening the algorithm’s exploratory capacity. Consequently, the obtained solutions proved to be quasi-optimal, as validated by their correspondence with those derived from the exact MILP method, both in the single-objective case (minimizing TWFT), and in the bi-objective context (minimizing both TWFT and economic cost simultaneously).

While the current energy cost model assumes a linear increase with job position, reflecting typical machine degradation and rising industrial energy costs. Future work could generalize this formulation by incorporating time-dependent cost functions. Such an extension would allow more flexible and realistic pricing structures, for instance, peak/off-peak time-of-use tariffs.

Future research will aim to extend this work by designing new metaheuristics, such as NSGA-II and MOEA/D, for flow shop scheduling that target the minimization of multi-objective functions under additional constraints, including machine unavailability, with particular emphasis on TWFT and energy cost optimization. This will contribute to the development of more sustainable and energy-efficient production systems.