A Novel Genetic Algorithm for the Dual-Resource Flexible Job Shop Scheduling Problem with Partial Resource Allocation

Abstract

This paper proposes a genetic algorithm (GA) for the Dual-Resource Flexible Job Shop Scheduling Problem with Partial Resource Allocation (DRFJSSP-PRA), a particular variant of a dual-resource constrained scheduling problem that has not been fully explored due to its intricate nature. The DRFJSSP-PRA poses a challenging scheduling problem, having several applications in many industries, including food, chemistry and pharmaceutics. The proposed algorithm is applied to real-world scheduling instances in pharmaceutical quality control. The objective function considered is the total completion time. The GA is compared with three state-of-the-art algorithms. For small- and medium-size instances, the proposed algorithm achieves optimal or near optimal results for the majority of the instances tested. For large-sized instances, the proposed GA outperforms all the other algorithms, in all of the tested instances. Thus, the experimental results show that the proposed GA achieves competitive results for any type of instance. The proposed algorithm also has the ability to optimize production processes through scheduling, leading to potential cost savings, increased efficiency, and improved competitiveness.

1. Introduction

Scheduling has made significant progress over time, enabling the creation of increasingly complex systems that can handle more activities and more operations. This is particularly important for managing manufacturing systems that rely on advanced technology and machinery [1]. Manufacturing companies are facing a digital transformation, known as smart manufacturing [2], which has enabled strong interconnectedness between countries, goods, and individuals, resulting in a fast-paced, globalized world. This has led to rapidly changing consumer demands that require fast adaptability from industries to remain competitive and accommodate increased customization. Consequently, the era of mass production has led to a focus on mass customization [3].

Mass customization has become increasingly important in the industrial context due to the growing demand for highly customized products in small batch sizes. This requires manufacturing systems to have modularization, agility, robustness, adaptability, and flexibility to efficiently respond to market demands [4]. To address this, cutting-edge technologies such as the internet of things, machine learning, and artificial intelligence have been introduced to support mass customization [5]. These developments have pushed manufacturing systems to become more flexible and dynamic, requiring innovative solutions that can provide short-term responses, quality, and efficiency to respond to constantly changing markets. As a result, manufacturers are adopting these advanced technologies to satisfy customer preferences, optimize production processes, and design customized products that meet individual customer needs [1].

Scheduling plays a crucial role in the success of mass customization, as it allows manufacturers to efficiently manage and optimize production processes to meet the unique needs and preferences of individual customers [6]. Effective scheduling is essential to ensure that production processes are properly coordinated and that resources are allocated efficiently. For this purpose, it is necessary to develop a detailed plan that outlines the tasks and activities that need to be performed, as well as the resources required to complete them. This plan should be flexible and adaptable to accommodate changes in customer demand and production constraints. These ever-changing customer needs and aspirations are what drives the transition from Industry 4.0 to Industry 5.0 [1], which aims to develop and reinforce its three pillars: human-centricity, sustainability and resilience [7].

Dual-Resource Flexible Job Shop Scheduling (DRFJSSP) has emerged due to the need for flexible and human-centric scheduling. This problem involves scheduling a set of jobs on machines, where both machines and human workers (operators) are considered critical resources. The DRFJSSP has the need to simultaneously allocate dual resources (machines and operators) in a flexible job shop environment, where jobs can be processed on multiple machines with varying characteristics. This flexibility introduces a high degree of complexity into the scheduling process. The addition of Partial Resource Allocation (PRA) comes from the necessity of certain industries to allocate human resources partially (rather than fully) to the manufacturing process. The DRFJSSP-PRA is a challenging scheduling problem that has practical applications in various manufacturing industries, including food, chemistry, and pharmaceutics [8,9].

This paper proposes a modified genetic algorithm to solve the DRFJSSP-PRA. The main contributions of this paper are

• A detailed and interpretable explanation of the DRFJSSP-PRA.
• An improved genetic algorithm to solve the DRFJSSP-PRA.
• Application to real-world instances in the context of quality control for pharmaceutical manufacturing.
• Robustness and scalability of the proposed algorithm to deal with instances of different characteristics.
• Enhanced performance compared to state-of-the-art optimization methods.

The remainder of this paper is organized as follows: Section 2 provides a review of the literature on dual-resource scheduling. Section 3 presents the mathematical formulation of DRFJSSP-PRA and introduces the instances used for the research work. Section 4 presents in detail the proposed genetic algorithm to solve DRFJSSP-PRA. Section 5 desribes the experiments applied in the paper. Section 6 presents the experimental results and discusses the performance of the proposed algorithm. Finally, Section 7 summarizes the contributions of the article and discusses possible future research directions.

2. Literature Review

Job shop scheduling (JSS) is a well-established and extensively explored field [10,11]. However, Dual-Resource Flexible Job Shop Scheduling (DRFJSS) is more specific, but still quite general, and much more complex than JSS. Therefore, it is not explored as much as JSS [12]. The limited availability of publications in DRFJSS emphasizes the early stage of research development in this particular scheduling domain [13].

2.1. Dual-Resource Flexible Job Shop Problem

Genetic algorithms have been used to solve the DRFJSSP at least since 2000, when the problem was formulated with machines set in work-centers of a 2 × 2 formation; see [14].

Flexibility in labor often incurs elevated costs due to the necessity for extensive training. Felan and Fry [15] explored the impact of implementing varying levels of training throughout the workforce, specifically focusing on multi-level heterogeneous flexibility. Their findings demonstrated that a blend of highly flexible workers and those without flexibility outperformed groups with nearly equal levels of flexibility. Later, Yue et al. [16] investigated cross-training policies in which workers were required to learn new skills, as additional parts were added to the system. Moreover, if workers stopped performing a certain job for a significant period of time, a forgetting model would be implemented to simulate the time it would take them to perform it, once they were assigned to that job again. This curve reflected the experience they had gathered and the time they had stopped doing the given work.

When the objective function considered for the DRFJSSP is the makespan, several meta-heuristics have proven to yield quality results in solving DRFJSSP. For instance, Xianzhou and Zhenhe [17] presented a new Immune GA, which proved to have a higher level of convergence when solving the DRFJSSP, by merging immune and genetic algorithms. Another approach proposed by Lei and Guo [18] used a Variable Neighborhood Search (VNS) consisting of two neighborhood search procedures and a restart mechanism. Simulated Annealing (SA) and Vibration Damping Optimization (VDO) algorithms have also been used to minimize the makespan [19].

Beyond makespan, other cost functions have been considered. Isa et al. [20] developed a GA algorithm using indirect chromosome representation with two layers to reduce delays. Another approach was given in [11], where Particle Swarm Optimization (PSO) with a three layer encoding scheme was introduced to reduce the production period and the cost. In [21], the minimization of both the makespan and the total processing cost was considered, which used a branch population GA, based on a compressed time-window scheduling strategy. Further, Andrade-Pineda et al. [22] proposed a solution for an automobile collision repair shop, where re-scheduling needs, including due-date changes, delay in arrival, changes in job processing time and rush jobs, were addressed using MILP and an Iterated Greedy Constructive Heuristic.

Regarding GA improvement, Akbar and Irohara [23] proposed a modified permutation-based GA that performed better than five metaheuristics in the DRFJSSP. Zhang et al. [24] proposed a quantum genetic algorithm for the workshop production process, taking into account different technical levels of workers.

A particular case of studies includes the loading and unloading times of fixtures, considering the influence of resource requirement similarity among different operations, as well as the time to shift workers between assignments. Wu et al. [25] used a similarity-based scheduling algorithm for setup-time reduction and introduced an improved non-dominated sorting genetic algorithm II (NSGA-II) to optimize the DRFJSSP when loading and unloading fixtures.

Vital-Soto et al. [26] also used NSGA-II to effectively balance machine and worker assignments, minimizing make-up, workload, and tardiness, providing a pragmatic solution for industrial scheduling complexities. Yu et al. [27] tackled the distributed hybrid flow shop scheduling problem (DHFSSP) prevalent in modern manufacturing systems, integrating DHFSSP, the assembly shop problem (ASP), and dual-resource constraints to minimize total tardiness. Barak et al. [28] tackled the dual-resource constrained flexible job shop scheduling problem with sequence-dependent setup times using the multi-objective invasive weed optimization (MOIWO) algorithm, enhanced by a fuzzy sorting algorithm for competitive exclusion.

2.2. Partial Resource Allocation

The research work presented in the previous Section 2.1 does not account for the subproblem of Partial Resource Allocation, in which workers can concurrently engage in multiple tasks, while ensuring their presence only during specific time instances on the assigned machine for each job. These time instances correspond to critical phases of quality control in the pharmaceutical industry, such as setup, intermediate tasks, and disassembly or data processing tasks. Additionally, none of the previous studies allow workers to leave the designated machine unattended during task execution.

The DRFJSSP with Partial Resource Allocation was formulated as mixed integer linear programming (MILP) for quality control laboratory scheduling, minimizing the makespan in [29]. Branch-and-cut was used to solve the problem. The obtained solution could only reach the optimum for small instances where the number of jobs considered was equal to or less than three.

To circumvent these problems, another MILP formulation was proposed in [9]. This new problem was solved with a three-level dynamic heuristic, which was compared with a hybrid tabu-search algorithm. The results showed that the three-level heuristic is a better approach for dynamic scenarios due to its computational efficiency.

3. Formulation of Dual-Resource Flexible Job Shop Scheduling with Partial Resource Allocation

The formulation of the DRFJSSP is an extension of the classical FJSS problem and a derivation of the multi-resource constraint FJSS problem, and it includes three subproblems according to [12], namely,

• Assigning operations to machines;
• Assigning operations to workers;
• Sequencing the operations on the machines considering workers in order to optimize the performance measure.

• Beyond this, DRFJSSP-PRA also need to deal with Partial Resource Allocation. It is now necessary to assign a worker in distinct predetermined intervals during the processing time of a machine. Note that this worker is available for interventions in other operations between intervals. Figure 1 presents the problem under study.

3.1. Mathematical Formulation

The mathematical formulation for the DRFJSSP-PRA is based on [9]. In this paper, a simplification is proposed to increase the interpretability of sets, indices, parameters, and variables.

An instance of the DRFJSSP-PRA scheduling problem consists of a set of jobs, $J=\{1,\dots ,j,\dots ,n\}$, with n being the total number of jobs. The set of machines is represented by $K=\{1,\dots ,k,\dots ,m\}$, the set of workers by $W=\{1,\dots ,h,\dots ,w\}$ and the set of operations by $O_j=\{O_{1j},\dots ,O_{ij},\dots ,O_{o_{j}j}\}$ for each job j where the number of operations in job j is $o_j$. $K_{ij}\subset K$ and $W_{ij}\subset W$ are, respectively, the subsets of machines and workers that can process the operation i of the job j. Additionally, each operation can be divided by $N_{ij}$ individual tasks, s, that require a worker present, partially or fully.

Each operation is characterized by its processing time $p_{ij}$, and each worker task by the start time $u_{ijs}$ and the duration time $d_{ijs}$, both relative to the processing time of the operation $p_{ij}$. The machine processing time is always greater than the sum of the duration of the worker tasks.

The main decision variables are the start time of the operation i of job j ($t_{ij}\in R$), the binary assignment of operations ($O_{ij}$) to a machine h ($x_{ijh}\in \{0,1\}$) and to a worker h ($y_{ijh}\in \{0,1\}$). Additionally, sequencing variables are required to avoid overlap between operations or tasks and respect precedences: $a_{ijpq}\in \{0,1\}$ is equal to 1 if $O_{ij}$ is scheduled before $O_{pq}$, and it is 0 otherwise; and $b_{ijspqr}\in \{0,1\}$ is equal to 1 if the task (worker intervention) s of $O_{ij}$ is scheduled before the task r of $O_{pq}$, and it is 0 otherwise. The complete nomenclature can be found in

Table 1. Nomenclature for mathematical formulation.

Sets and Indices
$J=\{1,\dots ,j,\dots ,n\}$	Set of jobs for n jobs
$K=\{1,\dots ,k,\dots ,m\}$	Set of machines for m machines
$W=\{1,\dots ,h,\dots ,w\}$	Set of workers for w workers
$O_j=\{O_{1j},\dots ,O_{ij},\dots ,O_{o_{j}j}\}$	Set of operations of job j and $i=\{1,\dots ,o_j\}$, where $o_j$ is the number of operations in job j
$N_{ij}$ = $\{N_{1j},\dots ,N_{ij},\dots ,N_{o_{j}j}\}$	Set of workers’ interventions s in operation $O_{ij}$
$K_{ij}\subset K$	Subset of machines that can be used to perform operation $O_{ij}$
$W_{ij}\subset W$	Subset of workers that can be used to perform operation $O_{ij}$
Parameters
$p_{ij}$	Processing time of operation $O_{ij}$
$u_{ijs}$	Time after the start of processing operation i of job j where intervention s is requested
$d_{ijs}$	Duration of intervention s in operation i of job j
M	Large number
Decision Variables
$t_{ij}$	Start time of each operation $O_{ij}$
$x_{ijk}$	= $\left\{\begin{array}{c}1,\mathrm{if}\mathrm{operation}{O}_{ij}\mathrm{is}\mathrm{assigned}\mathrm{to}\mathrm{machine}k\hfill \\ 0,\mathrm{otherwise}\hfill \end{array}\right.$
$y_{ijh}$	= $\left\{\begin{array}{c}1,\mathrm{if}\mathrm{operation}{O}_{ij}\mathrm{is}\mathrm{assigned}\mathrm{to}\mathrm{worker}h\hfill \\ 0,\mathrm{otherwise}\hfill \end{array}\right.$
$a_{ijpq}$	= $\left\{\begin{array}{c}1,\mathrm{if}\mathrm{operation}{O}_{ij}\mathrm{is}\mathrm{assigned}\mathrm{before}{O}_{pq}\hfill \\ 0,\mathrm{otherwise}\hfill \end{array}\right.$
$b_{ijspqr}$	= $\left\{\begin{array}{c}1,\begin{array}{c}1 \mathrm{if} \mathrm{worker} \mathrm{intervention} s \mathrm{in} \mathrm{operation} O_{ij}\hfill \\ \mathrm{is} \mathrm{assigned} \mathrm{before} \mathrm{worker} \mathrm{intervention} r \mathrm{in} \mathrm{operation} O_{pq}\hfill \end{array}\hfill \\ 0,\mathrm{otherwise}\hfill \end{array}\right.$
$c_j$	Completion time of job j
$\mathcal{J}$	Total completion time

.

3.1.1. Objective Function

The objective function of the problem is to minimize the total completion time $\mathcal{J}$, where $c_j$ is the completion time of job j, i.e., the time required to complete the operations of that job.

$$\min \mathcal{J}={\displaystyle \sum _{j\in J}}{c}_j$$

(1)

3.1.2. Constraints

The completion time of each job, $c_j$, must be greater than or equal to the completion time of the last operation of that job, i.e.,

$$c_j⩾t_{o_{j}j}+p_{o_{j}j}$$

(2)

Each test can only be assigned to one suitable machine, as in (3), and one suitable worker, as in (4):

$${\displaystyle \sum _{k\in K}}{x}_{ijk}=1,j\in J,i\in O_j,k\in K_{ij}$$

(3)

$${\displaystyle \sum _{h\in W}}{y}_{ijk}=1,j\in J,i\in O_j,h\in W_{ij}$$

(4)

The precedence between operations of the same job must be respected, as guaranteed in

$$t_{ij}⩾t_{(i-1)j}+p_{(i-1)j}$$

(5)

Constraints (6) and (7) ensure that there are no overlapping operations ($x_{ijk}=x_{pqk}=1$) for a machine k. For the sequencing of operations in machines, constraint (6) ensures that the start time ($t_{ij}$) of any operation $O_{ij}$ is greater than or equal to the finish time ($t_{pq}+p_{pq}$) of any distinct operation $O_{pq}$ ($O_{ij}\ne O_{pq}$) that is scheduled before ($a_{ijpq}=0$) in the same machine ($x_{ijk}=x_{pqk}$ = 1).

$$\begin{array}{cc}{t}_{ij}⩾t_{pq}+p_{pq}-(2-x_{ijk}-x_{pqk}+a_{ijpq})\hfill & M,\hfill \\ \hfill j\in & \hfill J,i\in O_j,p\in O_q,O_{ij}\ne O_{pq},k\in K_{ij}\cap K_{pq}\end{array}$$

(6)

Similarly, constraint (7) guarantees that any operation $O_{ij}$ scheduled before ($a_{ijpq}=1$) of any distinct operation $O_{pq}$ on the same machine ($x_{ijk}=x_{pqk}$ = 1) is finished before the latter starts.

$$\begin{array}{cc}{t}_{pq}⩾t_{ij}+p_{ij}-(3-x_{ijk}-x_{pqk}-a_{ijpq})\hfill & M,\hfill \\ \hfill j\in & \hfill J,i\in O_j,p\in O_q,O_{ij}\ne O_{pq},k\in K_{ij}\cap K_{pq}\end{array}$$

(7)

To ensure that there are no overlapping tasks ($y_{ijh}=y_{pqh}=1$) for a worker h, constraints (8) and (9) are defined. For sequencing tasks for workers, constraint (8) ensures that the start time ($t_{ij}+p_{ijs}$) of a worker intervention task (s) in operation $O_{ij}$ is greater than or equal to the completion time ($t_{pq}+u_{pqr}+d_{pqr}$) of any preceding task r that is scheduled before ($b_{ijspqr}=0$) for the same worker ($y_{ijk}=y_{pqk}$ = 1).

$$\begin{array}{cc}{t}_{ij}+u_{ijs}⩾t_{pq}+u_{pqr}+d_{pqr}-(2\hfill & -x_{ijh}-x_{pqh}+b_{ijspqr})M,\hfill \\ \hfill & \hfill j\in J,i\in O_j,p\in O_q,O_{ij}\ne O_{pq},s,r\in N_{ij},h\in W_{ij}\end{array}$$

(8)

Similarly, constraint (9) guarantees that any worker intervention task (s) scheduled before ($b_{ijspqr}=1$) of any distinct task (r) for the same worker ($y_{ijk}=y_{pqk}$ = 1) is finished before the latter starts.

$$\begin{array}{cc}{t}_{pq}+u_{pqr}⩾t_{ij}+u_{ijs}+d_{ijs}-(3\hfill & -x_{ijh}-x_{pqh}-b_{ijspqr})M,\hfill \\ \hfill & \hfill j\in J,i\in O_j,p\in O_q,O_{ij}\ne O_{pq},s,r\in N_{ij},h\in W_{ij}\end{array}$$

(9)

The big M formulation is adopted for constraints (6)–(9) since these are disjunctive constraints.

4. Improved Genetic Algorithm

This paper proposes an improved genetic algorithm to solve the DRFJSSP-PRA. Genetic algorithms (GAs) are the metaheuristics that have been largely applied to the DRFJSSP, as presented in Section 2. Due to their adaptability and their ability to manage dual-resource constraints in an efficient way, GAs excel at finding high-quality solutions, while avoiding local optima due to the good balance between exploration and exploitation. Additionally, GAs can leverage parallel processing, aligning with future efforts to achieve faster convergence, and consistently demonstrate competitive performance across various problem sizes, showcasing their versatility and robustness.

The proposed GA follows the usual steps of genetic algorithms, see, e.g., [30], adding problem-specific implementations to solve the DRFJSSP-PRA. A flow chart of the improved GA is presented in Figure 2, and each step is described in the following sections.

4.1. Initialization of the Population

Three distinct approaches were developed using different algorithms to initialize the population:

• Initial Job Population Randomization (IJPR): The aim of this method is to generate an initial population in the most straightforward way. To achieve this, the first step is to select an available job, and then randomly assign a machine and a worker capable of completing the task. To select each job, a job selection procedure is employed, which combines three distinct methods: random initialization ($w_1$), longest processing time ($w_2$), and a larger number of tests ($w_3$). All three methods can only select from the pool of available tests. To determine which implementation to use, weights ($w_1$, $w_2$, $w_3$) are assigned to each option, reflecting the probability of selecting each selection method, respectively. If multiple jobs meet the same conditions, one of them is randomly chosen.
• Incremental Initial Population Worker Randomization (IIJWR): A worker is assigned to a job and a machine, and this worker is automatically assigned three time instances to that machine. The time in between these time instances is known as the idle gap, and the problem is best solved when this interval is minimized. This means finding a series of jobs that a worker can perform on different machines, where each job fits perfectly into the idle gap of the others. To identify which jobs fit together best, an increment table is calculated, with its results indicating the time that the worker has to wait before starting the next assigned job. In order to select and combine jobs with the least amount of increment time, the algorithm performs the reverse of the previous method, IPJR. It starts by selecting a worker (respecting prohibition conditions) and then choosing a machine where the worker can perform. Afterwards, it obtains a list of available jobs that both the machine and the worker can execute. Depending on the number of times a worker has been selected before, several different ramifications exist, leading to the assignment of the chosen job, which is stored in the worker number. The worker number shows the number of times that a certain worker was already chosen in the assignment cycle, which increases to a maximum of two. Once it surpasses this value, it returns to one, meaning that the initial solution increment cycle is capped at two workers in a row. These parameters are implemented to avoid increasing the complexity of the initial solution, which could lead to a longer computational time and the risk of falling into local optima. The machine and worker routine is a set of condition cycles intended to qualify or disqualify the reason for not having any available machines to be chosen.
• Three–layer heuristic (M-LAST): Following the work in [9], M-LAST is a three-level dynamic heuristic that uses scheduling lists at three different levels: operation, machine, and worker. Resources (machines and workers) are chosen based on dynamic lists that take into account individual resource availability after each scheduling decision. The dynamic heuristic starts by virtually assigning machines to all operations based on a machine selection criterion, e.g., earliest start time. The operation list is then created and an operation is chosen based on an operation selection criterion, e.g., the smallest queue. Finally, the worker list is created for the selected operation, and one is chosen based on worker selection criteria, e.g., earliest start time. This process is repeated until all operations are scheduled.

4.2. Encoding and Decoding

4.2.1. Encoding

According to the characteristics of the DRFJSSP-PRA, a method composed of three layers is used to represent the chromosomes, following the work in [31]. Each layer represents a different resource, and the columns formed within the three layers form a vector representing one operation and the resources in which the operation is allocated. These layers are represented in Figure 3 and are described as follows:

• Layer 1: Jobs Sequencing is done in each operation. Operations are represented by the job number, and as the job is repeated, it represents the order in which the operations of that job are performed.
• Layer 2: Machines Represent the machine in which operation is performed.
• Layer 3: Workers Represent the worker performing the operation.

4.2.2. Decoding

From the three-layer chromosome, it is possible to determine the sequence of all operations and corresponding tasks attributing machines and workers. The start and end times are calculated by the order in which operations appear on the chromosome.

The decoding process is described in the following steps:

• Follow the order of the chromosome.
• Select the job and corresponding operation $O_{ij}$.
• Select the machine and worker for the operation.
• Calculate the minimum start time for the machine $M_s$.
• Calculate the minimum start time for the worker $W_{s1}$, starting the search from machine start time $M_s$.
• Calculate the start time for the operation as the maximum between the start time of the machine and the start time of the worker, $max(M_s,W_{s1})$.
• Calculate the start time and the end time for operations and tasks.
• Repeat for the remaining operations.
• Calculate the value of the objective function.

The novelty compared to [31] is the assignment of tasks for each operation, as there are three tasks with fixed times relative to the operation to be scheduled. A temporal vector representing the time needed for the workers in each operation was introduced. Similarly, a temporal vector with the available times for each worker was also introduced to intersect both vectors and calculate the minimum start time for the worker. The encoding process of vectors and task allocation is exemplified in Figure 4 for two distinct consecutive operations to be scheduled.

Figure 5 represents the three-layer chromosome exemplified in Figure 3. Each color represents a different job, and operations $O_{ij}$ are numbered according to the sequence in the job. Tasks belonging to the same operations are numbered equally. The figure is divided into two different plots for clarity purposes. The first plot is assigned to machine allocation and the second to worker allocation.

4.3. Calculation of the Objective Function

A fitness score is assigned to each chromosome, which is used for the probability of being selected for reproduction. This process consists of performing the decoding for all the individuals in the population to obtain the time that each job has finished. Afterwards, the fitness value can be calculated. In this work, total completion time was chosen for comparison purposes with the state of the art.

4.4. Selection

In this step of the reproduction, the proposed GA uses elitism and tournament selection. Elitism is performed to ensure that the best solutions are retained in the parent population and are not excluded by tournament selection. Elitism is not applied in the first generations to ensure that the space of solutions has been explored before selecting any elite population. This helps remove local optima at the first iterations, when the solutions have inferior fitness values.

Tournament selection selects five random solutions from the main population and chooses the best to be included in the crossover population. This process is repeated until a predetermined number of tournament-winning individuals is reached in the final population. The larger the population chosen for tournaments, the less likely weaker individuals will be chosen. If a weak individual is chosen, there is a higher chance that a stronger individual is also present in that tournament.

Consequently, this implementation primarily selects the best population for the crossover, still giving weaker individuals a chance to be included. The convergence speed of the algorithm decreases when there are weaker individuals in a tournament, resulting in a greater variety of solutions available for crossover.

4.5. Crossover

Three different crossover operations are explored: single-point crossover, double-point crossover and multi-point crossover. Weights are implemented to account for different probabilities of choosing a certain crossover. After each crossover, feasibility and precedence checking is required. In case of infliction, the solution is rebuilt in order to always have feasible solutions. Relative to the types of crossovers, the three are described as follows:

• Single-point crossover: Choose a random point in both parents’ genes. This divides the parents’ chromosomes into two identical sections. Afterwards, the crossover is completed by swapping parents’ chromosomes. The percentage of selecting this type of crossover is given by weight $c_1$.
• Double-point crossover: Choose two different random numbers (in the chromosome length) which correspond to a certain interval gap in the parents’ genes. This middle section is swapped between the two to produce both offspring. The percentage of selecting this type of crossover is given by weight $c_2$.
• Multi–point crossover: According to [32], this type of crossover is used to modify the worker and machine assignment. It involves generating a random binary vector that has the same length as the chromosomes. Depending on the value of the binary vector at a particular gene, either parent can be selected to assemble the offspring by using the machines and workers. The process is as follows: assign the offspring with the same number as the parent and the same job order. From left to right, retrieve the binary value at that position. If the binary vector value is one, parent 1 will assign the machine and worker it has assigned to that job to offspring 2, and the opposite will occur for parent 2 and offspring 1. If the binary vector value is zero, parent 1 will assign the machine and worker it has for that job to the offspring of the same number, and parent 2 will do the same for the second offspring. The percentage of selecting this type crossover is given by weight $c_3$.

4.6. Mutation

The offspring population has a certain chance to mutate. The mutation phase starts with a shift mutation followed by an intelligent mutation based on [18]. Depending on a certain predetermined probability, a worker–machine mutation is performed.

• Shift mutation: The shift mutation resembles the double-point crossover where two different random numbers with the length of the chromosome are firstly obtained. Each number will correspond to a gene (with a job, worker and machine) and will swap positions with the other number position.
• Intelligent mutation: Select one of the operations from the machine with maximum workload and assign it to the least used machine. If the machine is not compatible, no mutation occurs.
• Worker–machine mutation: The same shifted genes as the shift mutation are used to change both machines and workers into a new compatible workforce for the job, and if no compatibility exists, no change is made.

4.7. Variable Neighborhood Search

Variable neighborhood search (VNS) explores neighborhoods of a current incumbent solution. If the new solution proves to fit better than the previous one, then the algorithm selects it as the incumbent solution and explores further neighbor solutions until the termination criteria are achieved. Exploration is performed by operations similar to the ones implemented in the mutation phase in Section 4.6. VNS is implemented in an effort to improve GA slow convergence speed due to unguided mutations.

In the implemented VNS, four neighborhood structures were implemented: exchange, replace, change and intelligent structure. Different search algorithms were implemented as it allows for different neighborhood searches, which can potentially improve the convergence speed of the algorithm, thus reducing the total completion time.

The exchange structure is analogous to the same exact principle as the shift mutation. The change structure is equivalent to the worker and machine mutation, and the intelligent structure follows the same logic as the one with the same name in the mutation phase. The replace mutation consists of selecting two different random numbers within the chromosome length, which consists of two different genes. Subsequently, the gene position that corresponds to the smallest number is placed in the position on the encoding table of the biggest number. The gene in the newly occupied position moves one position backwards, as well as the rest of the genes, until no more overlapping occurs.

4.8. Dynamic Termination Criteria

The termination criteria are implemented in the event the algorithm does not yield any improvements after N iterations. Since this lack of improvement may be related to a local optima, a procedure was implemented to avoid the algorithm being trapped in one. In this case, a counter of the successive non-improving iterations was implemented, such that when it surpasses ${\displaystyle \frac{1}{4}}$ of the termination criteria variable, the percentage of offspring and the mutation percentages increases to $80\%$ and $50\%$, respectively. Also, when the VNS is active, it increases to $30\%$ of the best population. Afterwards, an intelligent mutation is performed on all the population.

If the total completion time of the instance is reduced, this new individual replaces the previous one. If the algorithm improves on the following iterations, it returns to the normal values and the counter is returned to zero. The algorithm may end after a predefined number of non-improving consecutive iterations is reached (termination criteria). The algorithm is also limited to 3 h of total computational time.

5. Description of Experiments

The experiments applied in this study are based on [9], which are characterized by several parameters, including the number of jobs, n, number of machines, m, number of workers w and flexibility (f).

The experiments are designed for 5, 10, and 70 jobs. The smaller instances of 5 jobs are used to evaluate the performance of the proposed algorithm and compare it with the optimal solutions obtained using CPLEX. The medium-sized instances of 10 jobs represent the daily workload of a QC laboratory. Finally, the larger instances of 70 jobs simulate a realistic QC laboratory week scheduling problem. The number of machines is fixed at 7, representing different types of equipment present in laboratories. The number of workers can be set to 2, 3, or 7, representing scenarios that are worker-restricted, balanced, and machine-restricted, respectively.

The developed experiments encompass various configurations of the QC lab scheduling problem. For job generation in each experiment, distributions based on previous studies are employed [33,34]. The instance generation uses the concept of sample type (job type), which directly relates to real QC lab activities. Typically, each combination of product and source (such as raw material or final product) results in a predetermined set of tests (operations) that need to be conducted. As such, jobs are derived from a set of predetermined possible job types, each characterized by a specific number of operations and their processing times.

In all experiments, a total of $l=3$ job types are considered, and for each job type there are several assumptions to describe the problem, namely the following:

• The number of operations is determined using a discrete uniform distribution $DU$, from 1 to 3.
• Each operation has a processing time $p_{ij}$ from 1 to 5 units of time.
• For each operation, worker tasks start at three time points $u_{ijs}$:

  -

  At the start of the operation, $u_{ij1}$;

  -

  At $30\%$ of the operation processing time, $u_{ij2}$;

  -

  At $90\%$ of the operation processing time, $u_{ij3}$.

• For each operation, the durations of the worker tasks $d_{ijs}$ are

  -

  $5\%$ of operation processing time $d_{ij1}$, representing the setup;

  -

  $10\%$ of operation processing time $d_{ij2}$, representing an intermediate step;

  -

  $90\%$ of operation processing time $d_{ij3}$, representing disassembly or data processing tasks.

Figure 6 shows an illustration of a job, operations and worker tasks along with respective operation processing times and worker tasks’ starts and durations.

The flexibility parameter f is used to compute the machines and workers that can perform a certain operation. In the context of quality control in the pharmaceutical industry, each job is a unique combination of analytical tests and the respective necessary machines. This means that only specific machines can perform certain tests, and workers are not trained to do every possible analysis. To represent this, when generating the instance, each of the machines and workers has a probability equal to the flexibility of being eligible to carry out the operation. Experiments are carried out with the flexibility values of $f=30\%$ and $f=60\%$, encompassing cases where machines and workers have less or more general competencies.

For each configuration of job, worker, and flexibility, three different problem instances are generated (replications) to improve the reliability of the simulations. There are a total of 18 experiments for each value of n, taking into account the possible values of m, w, f and r, resulting in a total of 54 distinct experiments for all values of n. The experiment parameters are summarized in

Table 2. Parameters for the designed experiments.

Parameter		Values
Job generation parameters
Job types	l	3
Operations in job	$o_j$	$DU(1,3)$
Operation processing time	$p_{ij}$	$DU(1,5)$
Starting point of worker tasks	$uijs$	$[0,0.3p_{ij},0.9p_{ij}]$
Duration of worker tasks	$dijs$	$[0.05p_{ij},0.1p_{ij},0.1p_{ij}]$
Experiment parameters
Number of jobs	n	$[5,10,70]$
Number of machines	m	7
Number of workers	w	$[2,3,7]$
Flexibility	f	$[0.3,0.6]$
Reproducibility	r	$[0,1,2]$

.

6. Experimental Results

The experimental results are conducted in the instances described in Section 5 and are compared with the benchmark results presented in [9], which proposes a three-level dynamic heuristic (M-LAST) to solve the DRFJSSP-PRA. That paper also compares its results with an exact method (CPLEX) and a hybrid solution (M-LAST+TS) using tabu-search as a post-optimization approach for the proposed dynamic heuristic.

This paper proposes two algorithms: a genetic algorithm (GA) and an improved genetic algorithm (M-LAST+GA) using M-LAST as initialization. The GA and M-LAST+GA parameters used for the DRFJSSP-PRA after a tuning process based on previous works in the literature and empirical validation are available in

Table 3. Parameters used for GA and M-LAST+GA.

Parameter
Objective function	Total completion time
Population size	500
Percentage of offspring (%)	70
Initial population weights	$w_1=90$|$w_2=5$ | $w_3=5$
Incremental initialization?	Yes
M-LAST heuristic?	Yes (M-LAST + GA)/No (GA)
Elitism (%)	5
Elitism start	$s={\displaystyle \frac{1}{8}}$ population size
Crossover weights	$c_1$ = 10 | $c_2$ = 5 | $c_3$ = 85
Mutation percentage (%)	50
Machine–worker mutation probability (%)	$m=5$
Termination criteria	250 iterations or 3 h (big instances)

.

Each algorithm is run five times for each instance, with the exception of CPLEX and M-LAST, which are run only once. In addition, CPLEX has a run-time limit of 24 h if the optimal result is not achieved.

Table 4. Experimental results where J is the number of jobs, W is the number of workers, f is the flexibility and R is the reproducibility. The best results found are in bold. Optimal results are indicated with an *. Some CPLEX solutions only returned the LP relaxation of root node (†) and are omitted from the table.

J	W	F	R	M-LAST	CPLEX	M-LAST + TABU	GA	M-LAST + GA
5	2	0.3	0	43.8	41.3 *	42.3 ± 0.6	41.3 ± 0.0 *	41.3 ± 0.0 *
			1	62.6	54.0 *	56.4 ± 1.0	55.9 ± 0.9	54.9 ± 0.3
			2	25.7	23.6 *	23.6 ± 0.0 *	23.6 ± 0.0 *	23.6 ± 0.0 *
		0.6	0	46.9	41.8 *	42.8 ± 0.7	41.8 ± 0.0 *	42.3 ± 0.4
			1	49.3	44.9 *	46.6 ± 0.3	45.8 ± 0.5	45.8 ± 0.4
			2	23.6	23.4 *	23.6 ± 0.0	23.6 ± 0.0	23.6 ± 0.0
	3	0.3	0	74.3	69.9 *	70.2 ± 0.3	70.2 ± 0.4	70.2 ± 0.1
			1	35.5	34.3 *	34.4 ± 0.1	34.3 ± 0.1 *	34.3 ± 0.0 *
			2	49.6	43.2 *	43.3 ± 0.2	43.2 ± 0.0 *	43.2 ± 0.0 *
		0.6	0	28.7	27.4 *	27.8 ± 0.0	27.4 ± 0.0 *	27.4 ± 0.0 *
			1	28.0	26.7 *	26.7 ± 0.0 *	26.7 ± 0.0 *	26.7 ± 0.0 *
			2	34.7	33.0 *	33.2 ± 0.4	33.0 ± 0.0 *	33.0 ± 0.0 *
	7	0.3	0	30.5	29.7 *	29.8 ± 0.2	29.7 ± 0.0 *	29.7 ± 0.0 *
			1	48.2	46.4 *	48.0 ± 0.6	46.4 ± 0.1 *	46.4 ± 0.0 *
			2	25.3	24.1 *	25.1 ± 0.3	24.1 ± 0.1 *	24.1 ± 0.0 *
		0.6	0	27.0	26.0 *	26.1 ± 0.3	26.0 ± 0.0 *	26.0 ± 0.1 *
			1	46.1	42.1 *	42.8 ± 1.4	42.1 ± 0.0 *	42.1 ± 0.0 *
			2	27.0	27.0 *	27.0 ± 0.0 *	27.0 ± 0.0 *	27.0 ± 0.0 *
10	2	0.3	0	101.4	90.7	93.7 ± 1.2	91.5 ± 0.6	91.5 ± 0.7
			1	244.2	189.5	211.4 ± 5.3	190.2 ± 1.4	189.4 ± 1.5
			2	58.6	54.8	56.7 ± 1.0	55.5 ± 0.9	55.3 ± 0.1
		0.6	0	143.6	125.6	125.4 ± 1.9	120.6 ± 1.5	121.3 ± 1.0
			1	112.7	111.3	109.1 ± 2.4	108.8 ± 2.1	106.7 ± 0.9
			2	130.7	129.3	128.6 ± 0.3	131.3 ± 1.2	129.7 ± 0.0
	3	0.3	0	126.4	108.1 *	111.4 ± 3.1	108.1 ± 0.1 *	108.1 ± 0.1 *
			1	133.7	126.9	126.5 ± 1.4	123.3 ± 0.6	122.7 ± 0.2
			2	108.6	96.0	99.2 ± 1.5	96.3 ± 0.2	96.0 ± 0.1
		0.6	0	77.5	59.9	61.7 ± 1.0	61.6 ± 0.8	60.9 ± 0.2
			1	100.1	90.6	91.1 ± 1.8	91.7 ± 1.9	90.9 ± 1.7
			2	83.3	71.2	75.1 ± 1.8	73.8 ± 1.0	75.8 ± 0.1
	7	0.3	0	112.8	102.5	108.2 ± 1.7	104.7 ± 1.6	102.7 ± 0.1
			1	120.3	119.5	120.3 ± 0.1	120.6 ± 0.9	120.0 ± 0.0
			2	93.3	93.0	93.1 ± 0.1	93.0 ± 0.0	93.0 ± 0.0
		0.6	0	108.4	99.3	104.9 ± 2.7	105.4 ± 1.1	103.5 ± 0.5
			1	97.6	97.1	97.5 ± 0.2	101.4 ± 0.6	97.9 ± 0.0
			2	107.4	82.2	87.3 ± 1.7	85.9 ± 1.0	85.9 ± 1.1
70	2	0.3	0	3930.7	8253.2	3709.1 ± 39.9	3552.9 ± 26.1	3483.6 ± 30.5
			1	5265.0	9966.9	5089.2 ± 31.1	5567.2 ± 97.6	4861.9 ± 50.9
			2	3924.0	7245.8	3616.6 ± 27.2	3522.5 ± 23.2	3514.7 ± 20.8
		0.6	0	4075.5	10,356.3	3355.4 ± 53.6	3629.6 ± 66.1	3258.0 ± 35.7
			1	4374.6	11,392.8	4157.1 ± 36.9	3903.8 ± 51.0	3902.0 ± 67.2
			2	3955.3	9084.5	3536.2 ± 90.3	3985.7 ± 162.1	3370.2 ± 39.7
	3	0.3	0	4183.0	8627.4	3677.7 ± 78.7	3329.1 ± 30.9	3328.2 ± 25.6
			1	8318.2	13,935.7	7110.8 ± 358.7	6323.0 ± 87.0	5956.9 ± 31.1
			2	4442.4	6369.5	4168.0 ± 30.9	4137.8 ± 37.9	4063.6 ± 40.5
		0.6	0	2245.0	6528.2	2240.2 ± 10.2	2597.7 ± 15.4	2211.3 ± 11.7
			1	3262.9	8161.3	2746.1 ± 55.7	2833.5 ± 42.5	2642.2 ± 43.0
			2	1849.5	2916.5	1803.8 ± 18.4	1865.1 ± 8.7	1747.8 ± 19.3
	7	0.3	0	3455.5	8078.1	3323.2 ± 60.3	3148.5 ± 15.6	3174.0 ± 29.2
			1	4630.2	9783.2	4424.8 ± 44.5	4175.7 ± 43.2	4391.1 ± 111.3
			2	2760.9	6068.6	2704.9 ± 32.6	2568.3 ± 24.3	2630.6 ± 37.9
		0.6	0	3352.9	†	3351.3 ± 3.8	3454.9 ± 23.4	3350.3 ± 6.2
			1	1836.3	†	1819.8 ± 3.9	1817.9 ± 9.0	1774.8 ± 22.7
			2	2377.1	†	2377.1 ± 0.0	2524.7 ± 15.6	2367.7 ± 3.82

presents the results using the total completion time as an objective function to all the described instances. The first row of the table presents the different number of jobs J, the number of workers W, the flexibility of workers and machines to perform operations f, and the reproducibility R of each instance given the probability present in f. The number of machines (M) is set to 7.

Nonparametric statistical tests were made to compare all the algorithms. Then, a detailed analysis for each size of the instances is conducted in the following sections, considering the variability of the number of workers and the flexibility of machines and workers to perform operations.

6.1. Nonparametric Statistical Tests

Following the recommendations in [35], the ranks of the Friedman [36], Friedman Aligned [37] and Quade [38] tests are computed for all the algorithms considered. The tests were performed using a statistical toolbox [39].

Table 5. Ranks achieved by the Friedman, Friedman Aligned and Quade tests in the main case of study. The statistics computed and the related p-values are also shown.

Algorithm	Friedman	Friedman Aligned	Quade
M-LAST	4.471	165.46	4.325
CPLEX	2.745	158.08	3.379
M-LAST+Tabu	3.254	121.50	3.072
GA	2.598	101.12	2.544
M-LAST+GA	1.931	93.84	1.678
Statistic	28.078	44.939	21.237
p-value	0.000	0.000	0.000

shows that the algorithm M-LAST+GA is the best performing algorithm with the values of $1.93$, $93.84$ and $1.68$ for the Friedman, Friedman Aligned and Quade tests, respectively. The p-values computed for the statistics of each of the tests considered (0 for all the tests) confirm that the null hypothesis is rejected. This strongly suggests the existence of significant differences between the algorithms considered.

Comparisons of the obtained results are visualized using critical difference (CD) diagrams in Figure 7, which are commonly used to compare the performance of machine learning models. Essentially, the CD diagram reports the results of pairwise statistical tests for comparing model performance for multiple datasets and experimental conditions. The Friedman test is used. After failing to reject the null hypothesis, which indicates that a significant difference among the algorithms is present, Nemenyi is used for post hoc comparisons to determine which pairs of algorithms have significantly different performances. A thick horizontal line connecting the models indicates the lack of a significant difference at a $95\%$ confidence level.

The main drawback of Friedman tests is that they can detect only significant differences throughout the multiple comparison and are unable to establish proper comparisons between some of the algorithms. Multiple tests are performed for comparison considering a control method and a set of algorithms, all related to the control method (M-LAST+GA). Then, the application of the post hoc tests (Bonferroni [40], Holm [41], Finner [42], Hochberg [43] and Li [44]) can lead to obtaining a p-value that determines the degree of rejection of each hypothesis.

Taking into account a significance level of $0.05$, the Friedman test in

Table 6. Adjusted p-values for the Friedman test, where M-LAST+GA is the control method.

Friedman	Bonferroni	Holm	Finner	Hochberg	Li
M-LAST	0.0000	0.0000	0.0000	0.0332	0.0000
CPLEX	0.0001	0.0001	0.0001	0.0332	0.0096
M-LAST+Tabu	0.0374	0.0187	0.0125	0.0332	0.0000
GA	0.133	0.03324	0.0332	0.0332	0.0332

shows a significant improvement of M-LAST+GA over M-LAST, CPLEX and M-LAST+Tabu for all the post hoc procedures considered. M-LAST+GA exceeds GA in all the tests except for the Bonferroni test. The Friedman Aligned test in

Table 7. Adjusted p-values for the Friedman Aligned test; M-LAST+GA is the control method.

Friedman Aligned	Bonferroni	Holm	Finner	Hochberg	Li
M-LAST	0.0000	0.0000	0.0000	0.6185	0.0000
CPLEX	0.0000	0.0000	0.0000	0.6185	0.0000
M-LAST+Tabu	0.2331	0.1166	0.0770	0.6185	0.1325
GA	1.0000	0.6185	0.6185	0.6185	0.6185

confirms the improvement of M-LAST+GA over M-LAST and CPLEX over all post hoc procedures with the exception of the Hochberg test. Finally, the Quade test in

Table 8. Adjusted p-values for the Quade test (M-LAST + GA is the control method).

Quade	Bonferroni	Holm	Finner	Hochberg	Li
M-LAST	0.00000	0.00000	0.00000	0.08886	0.00000
CPLEX	0.00334	0.00251	0.00167	0.08886	0.00092
M-LAST+Tabu	0.02466	0.01233	0.00821	0.08886	0.00672
GA	0.35545	0.08886	0.08886	0.08886	0.08886

confirms the improvement of M-LAST+GA over M-LAST, CPLEX and M-LAST+Tabu. It is possible to conclude with the Quade test that the behavior of M-LAST+GA is similar to the GA in the most difficult problems (large instances). Thus, performance differences are not detected if the relative difficulties of the problem are taken into account.

6.2. Small-Sized Instances

Small-sized instances ($n=5$) represent part of a day’s activities in the quality control laboratory. The GA and M-LAST+GA achieved the optimal solution in 14 and 13 out of 18 experiments, respectively. This performance is only surpassed by CPLEX, which achieves optimal solutions in all experiments. Compared to M-LAST and M-LAST+Tabu, both proposed algorithms outperformed those in all instances.

Figure 8 presents the results for small-sized instances regarding the number of jobs, workers, and flexibility for each approach under study. CPLEX can be used as a baseline for comparison since it consistently achieves an optimal solution for all instances. The GA and M-LAST+GA are able to achieve practically the same level of result quality as CPLEX, even when faced with different variations in the number of workers and flexibility parameters. In terms of computational times, all approaches achieve results quickly, taking less than 1 min to complete.

6.3. Day-Sized (Medium) Instances

For medium instances ($n=10$) that represent the activities of one day, the GA and M-LAST+GA achieve the best solution in 3 and 6 out of 18 experiments, respectively, while CPLEX outperforms both, achieving the best solution in 14 out of 18 experiments.

Figure 9 represents the results for medium-sized instances regarding the number of jobs, workers and flexibility for each approach under study. The quantitative results confirm that CPLEX outperforms the other approaches. However, when the instances are highly constrained, such as with small values for the number of workers ($w=2$) and flexibility ($f=0.3$), M-LAST+GA stands out and produces the best results. As the values for workers ($w=7$) and flexibility ($f=0.6$) increase, performance remains competitive but ultimately presents slightly worse results when compared to CPLEX.

In terms of computational times, M-LAST runs in less than 1 min. The GA takes 3 min to complete, while M-LAST+GA comes third, running in 4 min. CPLEX and M-LAST+Tabu take 1 h to achieve their results.

6.4. Week-Sized (Large) Instances

For large instances ($n=70$) that represent activities to be made in one week, M-LAST+GA achieves the best solution in 15 out of 18 experiments and the GA in 3 out of 18 experiments. In contrast to the previous instances, CPLEX is completely outperformed against the proposed algorithms.

Figure 10 shows the results for large-sized instances regarding the number of jobs, workers and flexibility for each approach under study. In terms of the number of jobs, M-LAST+GA produces the best results overall, followed by M-LAST+Tabu. As the number of workers increases ($w=3$ and $w=7$), M-LAST+GA maintains its superior performance. The GA only surpasses M-LAST+GA when the number of workers is the maximum ($w=7$) and when the instances are more constrained ($f=0.3$).

In terms of computational times, the GA takes around 2 h to complete, while M-LAST stands out as the fastest approach with a running time of just 5 min. CPLEX and M-LAST+Tabu, on the other hand, take 12 and 1 h, respectively, to achieve their results.

Overall, the proposed M-LAST+GA algorithm has the ability to consistently produce competitive results across various problem instance sizes, highlighting its robustness and versatility. This is particularly advantageous for real-world applications, where problem instances can vary significantly in size and complexity. The M-LAST+GA performance in terms of computational time is also a valuable asset, especially for large-scale optimization problems that require significant computing resources. The ability to obtain results quickly can help decision-makers to make informed and timely decisions.

7. Conclusions

This paper proposed an improved genetic algorithm for the Dual-Resource Flexible Job Shop Scheduling Problem with Partial Resource Allocation. The problem is an extension of the dual-resource constrained flexible job shop scheduling problem, consisting in the allocation of both machines and workers to operations of jobs with the objective of minimizing the total completion time. In this paper workers are required at different temporal times during the execution of an operation, which constitutes an extra degree of complexity.

Based on the experimental results, it was observed that the proposed algorithm (M-LAST+GA) demonstrated versatility by achieving competitive results in all instance sizes compared to the benchmark results. The proposed algorithm stands out particularly for large instances.

The practical implications of these results are significant for manufacturing industries. The proposed algorithm can lead to substantial cost savings and efficiency improvements. By optimizing the allocation of machines and workers, manufacturers can reduce idle times and improve productivity. This optimization can also lead to better utilization of resources, minimizing the need for additional machinery or workers, which translates into direct cost savings. Furthermore, improved scheduling efficiency can result in shorter lead times, allowing companies to respond faster to market demands and reduce time to market for their products. This responsiveness can provide a competitive edge in industries where time is a critical factor.

The proposed M-LAST+GA algorithm not only advances the theoretical framework of the DRFJSSP-PRA but also offers practical benefits that can drive economic gains and operational efficiency in a real-world manufacturing scenario.

Future work will contain several lines of research. The proposed algorithm is most often evaluated in static environments. Future work could address real-time and dynamic events, such as machine failures, high-priority orders, worker absence, maintenance, etc. Another possible development is to address other objectives, such as sustainability (including, e.g., energy consumption or carbon emissions), labor costs, or workload balance in a multi-objective framework. Further, future research can deal with uncertainty and robust scheduling, including fuzzy variables, e.g., fuzzy processing times, uncertain machine availability or robust optimization frameworks. Finally, reinforcement learning is increasingly being used for scheduling [45]. Recent examples are the application of graph reinforcement learning in forced periodic optimal scheduling [46] and the application of reinforcement learning to dual-resource constrained scheduling [47]. Therefore, reinforcement learning for complex scheduling problems needs further research.