Graph Knowledge-Enhanced Iterated Greedy Algorithm for Hybrid Flowshop Scheduling Problem

Abstract

This study presents a graph knowledge-enhanced iterated greedy algorithm that incorporates dual directional decoding strategies, disjunctive graphs, neighborhood structures, and a rapid evaluation method to demonstrate its superior performance for the hybrid flowshop scheduling problem (HFSP). The proposed algorithm addresses the trade-off between the finite solution space corresponding to solution representation and the search space for the optimal solution, as well as constructs a decision mechanism to determine which search operator should be used in different search stages to minimize the occurrence of futile searching and the low computational efficiency caused by individuals conducting unordered neighborhood searches. The algorithm employs dual decoding with a novel disturbance operation to generate initial solutions and expand the search space. The derivation of the critical path and the design of neighborhood structures based on it provide a clear direction for identifying and prioritizing operations that have a significant impact on the objective. The use of a disjunctive graph provides a clear depiction of the detailed changes in the job sequence both before and after the neighborhood searches, providing a comprehensive view of the operational sequence transformations. By integrating the rapid evaluation technique, it becomes feasible to identify promising regions within a constrained timeframe. The numerical evaluation with well-known benchmarks verifies that the performance of the graph knowledge-enhanced algorithm is superior to that of a prior algorithm, and seeks new best solutions for 183 hard instances.

1. Introduction

Shop scheduling involves creating a rational problem model and developing scheduling optimization methods aimed at enhancing manufacturing efficiency and reducing production costs, which are crucial for modern manufacturing systems. The hybrid flowshop scheduling problem (HFSP) is a prevalent issue within the realm of shop scheduling. Initially introduced by Salvador in the context of synthetic fiber processing [1], the HFSP has since been a subject of interest. In a hybrid flow shop, there are multiple machines available for at least one stage of the process. This setup integrates the two fundamental models of flow shop [2] and parallel machine problems to effectively boost productivity. However, this complex shop model introduces a higher level of complexity and difficulty in decision-making compared to the simpler models. The HFSP continues to be a focus of research due to its extensive practical applications within industrial production systems [3], as shown in Figure 1. Industrial processes such as automotive welding are typical examples of hybrid flowshop processes.

In an HFSP, there is a set J with n jobs and a set M of m stages, where each stage i is composed of $m_i$ identical parallel machines, ${\forall }_i\in M$. All jobs are required to complete the same series of processes on m stages. Figure 2 illustrates a hybrid flowshop layout. The HFSP then consists in finding a schedule (i.e., a set of starting times for each job on each machine) that minimizes the makespan or maximum completion time among the jobs, i.e., $C_{max}$. $\mathit{min}{C}_{max}$ means higher machine utilization, lower inventory of Work-In-Process, and higher customer satisfaction. This study aims to optimize the $\mathit{min}{C}_{max}$ by determining the processing sequence of jobs and machine allocation at each stage.

The HFSP is recognized as a strongly NP-hard problem due to its intricate nature [4]; traditional exact methods are only capable of yielding optimal solutions for a limited number of small-scale issues. These methods prove to be ineffective when scaled up [5]. Approximate algorithms are always used to address this complex optimization problem, while they also struggle to find optimal solutions for certain hard instances, often due to a lack of knowledge-driven learning strategies [3,4,5]. On the one hand, the representation of solutions, as one of the cores of approximate algorithms, has its limitations. The commonly used single-stage encoding based on job sequences (which provides the job sequence for the first stage, with the jobs in subsequent stages being sorted according to scheduling variables based on certain rules) and complete encoding (which determines the machine assignment and the processing order between all operations to represent all solutions), respectively, have the problems of narrowing the algorithm’s search space and having low search efficiency in large-scale issues [6]. Therefore, this study applies an initial solution generation method using dual permutation-based encoding and a novel perturbation strategy in the decoding process to expand the search space.

On the other hand, these algorithms often employ random neighborhood search operators, such as multi-point random insertion and two-point random swapping or mutation. Random and unstructured movements fail to achieve efficient neighborhood search [7]. It is worth noting that single-stage encoding cannot intuitively represent the operation movement of the neighborhood search because changing the job sequence in the initial stage will alter the sequences in other stages. Therefore, this encoding method cannot fully depict the sequence after the move. This study aims to optimize the $\mathit{min}{C}_{max}$ by determining the processing sequence of jobs and machine allocation at each stage. Therefore, this study combines the complete encoding method of the disjunctive graph model and designs a graph knowledge-enhanced strategy to mine domain knowledge of the HFSP, which in turn guides the design of efficient neighborhood search operators.

This study introduces a knowledge-driven enhanced iterative greedy algorithm tailored for the HFSP. The IG algorithm, a prominent metaheuristic, has demonstrated robust performance in addressing a variety of scheduling challenges, including HFSP [8], the flowshop scheduling problem [9], and the distributed scheduling problem [10]. The IG algorithm presented in this paper incorporates a local search that leverages a knowledge-driven neighborhood structure to produce new feasible solutions.

To assess the quality of a neighborhood solution, it is necessary to re-decode the new scheduling plan to obtain the fitness value of the neighborhood solution. However, a neighborhood move only adjusts a small portion of the operations on certain machines, and the processing order on most machines remains unchanged. Decoding the entire schedule multiple times would consume a significant amount of computational time. There is a dearth of research on rapid evaluation methods for neighborhood solutions. This study proposes a novel rapid evaluation method designed to locate promising areas within a limited timeframe. Current research on the aforementioned key issues is very limited. Therefore, this study aims to design a novel scheduling method capable of tackling certain hard instances present in existing benchmarks. The main contributions of this study can be summarized as follows:

• An initial solution generation method that utilizes dual permutation-based encoding and a decoding technique with a novel perturbation strategy to broaden the search space.
• A graph knowledge-enhanced IG algorithm with a knowledge-based neighborhood structure and rapid evaluation method for solving the HFSP.
• The proposed graph knowledge-enhanced IG algorithm seeks new best solutions for 183 hard instances.

The structure of this paper is organized as follows. Section 2 summarizes recent literature about the HFSP. Section 3 describes the details of the enhanced IG algorithm. Section 4 investigates the effectiveness of the dual directional decoding strategy and knowledge-based neighborhood search strategy, and verifies the performance of IG. Finally, Section 5 gives the conclusion and future work.

2. Related Work

In the HFSP and its variants, many scheduling methods have been developed, which can be broadly categorized into exact methods, scheduling rules, metaheuristic algorithms, and learning-based algorithms. Initially, research efforts were concentrated on exact methods for tackling small-scale HFSPs using traditional mathematical programming techniques and their subsequent algorithmic derivations. For instance, He et al. [11] proposed a polynomial-time algorithm for the two-stage HFSP with machine constraints of batch processing. Sun et al. [12] propose a branch-and-bound method and mathematical programming for minimizing makespan. As the scale of the problem increases, the complexity of the problem increases exponentially, resulting in a dramatic increase in the search space. This has prompted researchers to develop scheduling rules that assign jobs to machines in a rational manner at each stage, yielding feasible solutions. Examples of such rules include the Johnson rule, the Nawaz-Enscore-Ham method, the shortest processing time rule, and the first available machine approach. Paterina et al. [13] designed machine selection rules based on the identification of bottleneck phases.

Distinct from the previous two methods, the metaheuristic algorithm integrates stochastic factors and utilizes them to perform multiple iterations and guided searches on the problem solution, which makes the algorithm produce a better solution in multiple iterations. Metaheuristic algorithms are praised for their simplicity and efficacy, prompting extensive research on their design and enhancement. Scholars have dedicated efforts to this field, with applications that span a wide array of practical uses in various industries, as well as serving as a benchmark for solution updates [8]. Lin et al. [14] proposed an improved simulated annealing algorithm with a chaos-enhanced annealing mechanism to solve the Jose benchmark instances and successfully updated 137 of 240 problems. Fan et al. [5] combined forward and backward decoding methods to expand the search space, and applied a disjunctive graph to represent each solution, which clearly shows its critical path. Huang et al. [15] applied discrete differential evolution with two-stage stochastic programming to solve the HFSP. Safari et al. [16] designed the leader and follower agents to decompose the HFSP and afterwards, the optimal solution is obtained by a co-evolutionary genetic algorithm for each sub-problem; the effects of the designed methods are validated on the tire manufacturing industry. For the HFSP with reentrant constraints and limited buffer, Lin et al. [17] proposed a hybrid harmony search and GA to minimize the makespan and flowtime. Ozsoydan and Sagir [18] solved an HFSP with machine setup times under a learning IG algorithm. Luan et al. [19] proposed a low-carbon HFSP and discrete whale optimization algorithm to minimize completion time cost and energy consumption cost. Some of the metaheuristic algorithms for solving distributed HFSP include IG [20,21], GA [22], the artificial bee colony algorithm [23,24], the nested variable neighborhood descent algorithm [25], and so on.

The efficacy of metaheuristic algorithms hinges on solution representation and neighborhood search. Early encoding methods, such as permutation-based encoding in the first stage, confined search within the limited solution space, potentially excluding optimal solutions. With AI advancements, learning-based algorithms have been applied to the HFSP [26], integrating agent systems and machine learning. Li et al. [27] proposed a bilevel scheduler with a constrained Markov decision process for initial global sequence identification and partial sequence refinements through Deep Q and graph pointer networks.

In recent years, HFSP research has increasingly integrated graph structures and learning algorithms, showing promising prospects. Wang et al. [28] proposed a mandatory operation acceleration mechanism in graph space, which reduces insertion positions by analyzing critical paths in the graph, thereby significantly lowering the computational cost of neighborhood search. This provides a theoretical foundation for designing efficient graph-guided search strategies. In the field of reinforcement learning, Liu et al. [29] proposed a PPO-GAT algorithm, combining graph attention networks with a difference reward mechanism to effectively handle delayed optimization in dynamic HFSP scenarios. Furthermore, Wan et al. [30] and Huang et al. [31], respectively, introduced a multi-agent graph reinforcement learning model and a multiexpert graph neural network approach, both enhancing the representational capacity and generalization ability in complex scheduling states.

Although these studies have made considerable progress in intelligent decision-making and scheduling modeling, they often suffer from uncontrollable structural operations and weak interpretability in the search process. In contrast, this study proposes a graph-augmented iterative greedy algorithm that leverages graph-based neighborhood perturbation and fast evaluation strategies, aiming to improve both the interpretability and efficiency of the search process, thereby addressing key limitations in existing literature.

The IG algorithm, with its flexibility in accommodating various scheduling problem constraints, has been further developed. Pan et al. [32] considered the due windows constraint and proposed a hybrid IG and greedy local search algorithm through an optimal idle time insertion operator to balance the earliness and tardiness. Öztop et al. [33] proposed four different IG algorithms to optimize the total flow time by combining the variable batch insertion heuristic. To clarify the research progress in this field, this paper provides a comparative summary of relevant literature in

Table 1. Literature Summary.

Reference	Problem Type	Domain Knowledge	Memory Structure	Fast Evaluation	Main Algorithm
Sun et al. [12]	Two-machine flow shop	Dominance rules	None	None	Branch-and-bound
Lin et al. [14]	HFSP	Chaos annealing	None	None	Improved simulated annealing
Huang et al. [15]	HFSP-TSP	Scenario tree	None	None	Pointer-based discrete DE
Safari et al. [16]	Competitive HFSP	Game theory	None	None	Co-evolutionary genetic algorithm
Lin et al. [17]	Reentrant HFSP	None	Centralized buffer	None	Hybrid harmony search GA
Luan et al. [19]	Low-carbon FJSP	None	None	None	Discrete whale optimization
Ying et al. [20]	Distributed HFSP	Cocktail decoding	None	None	Self-tuning iterated greedy
Cui et al. [22]	Distributed heterogeneous HFSP	Greedy insertion neighborhood	Multi-population	None	Improved multi-population GA
Li et al. [23]	Distributed HFSP	Two-level encoding	None	None	Discrete artificial bee colony
Jia et al. [26]	Distributed assembly HFSP	None	Q-learning memory	None	Q-learning multi-population memetic
Li et al. [27]	Large-scale FFSP	Sliding window sampling	Bilevel learning	None	Double DQN + Graph pointer network
Wang et al. [28]	HFSP	Critical path	None	Yes	Mandatory operations accelerated IG
Liu et al. [29]	Dynamic HFSP	Graph attention	Graph memory	None	PPO-GAT algorithm
Wan et al. [30]	FJSP	Graph attention	Multi-agent memory	None	Multi-agent graph RL
Huang et al. [31]	FJSP	Mixture of experts	Multiexpert structure	None	Multiexpert graph neural network
Pan et al. [32]	HFSP	Idle time insertion	None	None	Iterated greedy + local search
Öztop et al. [33]	HFSP	NEH heuristic	None	None	Iterated greedy variants
This paper	HFSP	Critical path, disjunctive graph, dual decoding	Graph knowledge	Yes	Graph knowledge-enhanced IG

.

Through the evolution of algorithms, this paper concludes that the IG algorithm demonstrates significant advantages in solving the HFSP, yet there are also shortcomings in its design that require attention. However, despite its effectiveness, the algorithm still has areas that can be improved upon: (1) it lacks domain-specific knowledge of the problem, leading to a heavy reliance on specialized local searches; (2) there is no memory storage structure within the IG, meaning that a vast number of historical solutions are discarded during the evolution of the solution; and (3) the number of heuristic methods is relatively limited, which leads to a lack of diversity in the solutions. Therefore, this paper seeks to address the deficiencies in the current literature regarding IG algorithm design.

3. The Enhanced IG Algorithm for the HFSP

This section encompasses nine distinct parts, delving into the operational design under the IG algorithm framework. It highlights the representation of problem solutions, the derivation of critical paths for the HFSP, and the crafting of neighborhood structures predicated on these critical paths.

3.1. The Encoding and Decoding Disruption Mechanism

The enhanced IG algorithm employs a permutation-based encoding method. The encoding method is one of the core aspects of algorithm design. An excellent encoding scheme effectively covers the solution space, ensuring the search efficiency of the algorithm. Encoding based on job sequences has been proven to be the most optimal. In this section, the encoded vector, comprised of real numbers, signifies the job sequence at the initial stage. Subsequent stages of job sequencing and machine scheduling are determined based on this encoded vector. The job sequence is governed by the First Come First Served (FCFS) rule, while the First Available Machine (FAM) rule dictates the machine assignment. The rigidity of the FCFS and FAM decoding rules confines the search within a restricted space.

To transcend this limitation and enhance diversity in scheduling schemes, this paper introduces a decoding perturbation mechanism that probabilistically adjusts the job sequence of the current stage for refinement. The fine-tuning operation consists of two steps: The initial step involves arranging a group of jobs in non-descending order according to their completion times from the previous stage. In the second step, the completion times of two consecutive jobs are compared to determine whether their positions need to be swapped.

Furthermore, to fully improve the quality of the solution, this section also applies a hybrid approach combining forward and backward decoding techniques. This technique employs two distinct decoding approaches. In forward decoding, jobs are scheduled for the earliest possible start times, with the encoding vector dictating the initial job sequence. Subsequent stages adhere to the FCFS rule, scheduling new job sequences based on the release order from the previous stage. Machine allocation follows the FAM rule. Conversely, backward decoding schedules jobs for the latest possible start times, with the encoding vector representing the final stage job sequence. Remaining stages schedule jobs based on the start times of the following phase, with machine allocation also adhering to the FAM rule. In the proposed enhanced IG algorithm, an initial solution is randomly generated to optimize the utilization of the designed local search. This solution is decoded using a hybrid forward and backward decoding technique, further enhanced by a decoding perturbation mechanism.

3.2. Scheduling Scheme of HFSP Represented by a Disjunctive Graph

The permutation-based encoding method is unable to express such movements intuitively, as alterations to the initial job sequence will result in changes to the subsequent stages. Consequently, the encoding method cannot fully represent these sequences after the movements have occurred. This paper proposes the use of a disjunctive graph as a means of representing the scheduling plans for the HFSP, as this allows for the depiction of such plans in a manner that is both concise and accurate.

A disjunctive graph consists of a set of nodes and a set of arcs. A node represents an operation, and an arc indicates the relationship between two adjacent operations within a given job, or two consecutive operations on the same machine. This work introduces a pair of dummy nodes, which are defined as follows: O_begin and O_end represent the beginning and end of the schedule, respectively. If an operation is the first operation for a job or machine, its predecessor should be the dummy node O_begin. The node O_end can be connected to the current operation without a subsequent job or machine operation. In Figure 3, the Gantt chart on the left (a) and the disjunctive graph on the right (b) represent two different ways of presenting a solution for the 5 × 3 scale instance. Within the Gantt chart, the red solid line signifies a critical path. The disjunctive graph of a solution, where connecting arcs link two consecutive operations of the same job, and separating arcs match two consecutive operations processed on the same machine. The red solid arcs represent the three adjacent operations of Jobs. The green dashed arcs indicate two consecutive operations on the same machine, with the arrow pointing to indicate the order of operations on the same machine.

In the disjunctive diagram, the longest distance between operations O_i,j and O_h,g is denoted as L(O_i,j, O_h,g), and hence, the makespan can be expressed as L(O_begin, O_end). To clearly delineate the proposed neighborhood structure based on the disjunctive graph, the head length and tail length of operation O_i,j are defined as $R_{O_{i,j}}$ and $Q_{O_{i,j}}$, respectively. The recursive computation for these lengths is detailed in Equations (1) to (2), where $J{P}_{O_{i,j}}$ and $M{P}_{O_{i,j}}$ denote the job predecessor operation and machine predecessor operation of the operation O_i,j, and $J{S}_{O_{i,j}}$ and $M{S}_{O_{i,j}}$ denote the job successor operation and machine successor operation of the operation O_i,j, respectively.

$$R_{O_{\mathit{begin}}}=Q_{O_{end}}=0$$

(1)

$$R_{O_{i,j}}=\max \{R_{J{P}_{O_{i,j}}}+p_{J{P}_{O_{i,j}}},R_{M{P}_{O_{i,j}}}+p_{M{P}_{O_{i,j}}}\}$$

(2)

$$Q_{O_{i,j}}=\max \{Q_{J{S}_{O_{i,j}}}+p_{J{S}_{O_{i,j}}},Q_{M{S}_{O_{i,j}}}+p_{M{S}_{O_{i,j}}}\}$$

(3)

3.3. The Critical Path of HFSP and Its Neighborhood Structure

The critical path is the longest in the disjunctive graph from the O_begin to O_end, and operations included in the critical path are defined as critical operations. This paper constructs two theorems and their proofs are shown as follows:

Theorem 1.

The sum of the head length, tail length, and processing time of the operations on the critical path is equal to the longest path, i.e., $R_{O_{i,j}}+p_{O_{i,j}}+Q_{O_{i,j}}=L\left(O_{begin},O_{end}\right)$, where O_i,j is a critical operation and $p_{O_{i,j}}$ is the processing time of O_i,j.

Proof. 

Assume O_i,j is any operation on the critical path; then the critical path is the longest path in the disjunctive graph from the head node O_begin to the tail node O_end, and the length of the critical path is $C_{\max }=\max \left\{C_{O_{i,j}}\right\}$. Operation O_i,j on the critical path, so the length of the longest path from the head node to the tail node passing through O_i,j is $C_{\max }=\max \left\{C_{O_{i,j}}\right\}$. $R_{O_{i,j}}$ is the longest distance from the head node to O_i,j; $Q_{O_{i,j}}$ is the longest distance from O_i,j to the tail node, which means $R_{O_{i,j}}+p_{O_{i,j}}+Q_{O_{i,j}}$ is the length of the longest path from the head node to the tail node passing through O_i,j, i.e., C_max. □

Theorem 2.

From the perspective of disjunctive graphs, if the disjunctive graph length from a non-first operation in any critical path block to the end of the entire sequence is greater than or equal to the disjunctive graph length from the last operation in that critical path block to the end of the entire sequence, then inserting this operation after the last operation for processing will not improve the solution.

Proof. 

As shown in Figure 4, let operations u and v be within a certain critical path block, with u being the first operation in the block and v being the last operation. Let w be an operation between u and v; js(w) is the successor of operation w on the same job; js(v) is the successor of operation v on the same job; mp(w) is the predecessor of operation w on the same machine; and ms(w) is the successor of operation w on the same machine. Let L[u,v] denote the disjunctive graph length from operation u to operation v. If the processing order of operations is not changed, the total completion time is C = L[s,mp(w)] + L[w,v] + L[sj(v),e]. When operation w is inserted after operation v for processing, the total completion time is given by C^* = max{L[s,mp(w)] + L[ms(w),w] + L[sj(w),e], L[s,mp(w)] + L[ms(w),v] + L[sj(v),e]}. It is easy to see that the disjunctive graph length L[w,v] when the processing sequence is not changed is equal to the disjunctive graph length L[ms(w),w] after changing the processing sequence, i.e., L[w,v] = L[ms(w),w]. When the disjunctive graph length from the successor of a non-first operation in the critical path block to the end of the entire sequence is greater than or equal to the disjunctive graph length from the successor of the last operation in that critical path block to the end of the entire sequence, i.e., $L\left[sj\left(w\right),e\right]\ge L\left[sj\left(v\right),e\right]$.

Therefore, $C=L\left[s,mp\left(w\right)\right]+L\left[w,v\right]+L\left[sj\left(v\right),e\right]\le L\left[s,mp\left(w\right)\right]+L\left[ms\left(w\right),w\right]+L\left[sj\left(w\right),e\right]$, and $C^{\prime }\ge L\left[s,mp\left(w\right)\right]+L\left[ms\left(w\right),w\right]+L\left[sj\left(w\right),e\right]$, therefore $C^{\prime }\ge C$. Theorem 2 is thus proven. □

3.4. The Local Search Based on the Critical Path

This section introduces two neighborhood structures, N7 [34] and k-insertion [35], which are proposed to address the flexible job shop scheduling problem (FJSP). These structures are categorized under insertion operations and have demonstrated significant efficacy across various algorithmic approaches. Based on the N7 and k-insertion, three critical path-based neighborhood structures are used randomly. The selected neighborhood structure is used to perform a neighborhood search on the current solution, and the best solution in the neighborhood solutions is selected. If the solution is better than the current solution, then the search proceeds to the next stage and continues. The pseudo code is shown in Algorithm 1.

Algorithm 1. The proposed local search

Input: Current solution π Output: Improved solution π* 1: getCriticalPath(π*);// Get critical path of current solution 2: do { 3:        switch (rand(1, 4)) { 4:              case (1): //Randomly select one neighborhood operation 5:                    choose one of {N7, k-insertion, k-swap}; 6:                    update π*; // Apply selected neighborhood operation to update solution 7:                    break; 8:              case (2): // Randomly select two neighborhood operations 9:                    choose two of {N7, k-insertion, k-swap}; 10:                  update π*; // Apply two neighborhood operations sequentially 11:                  break; 12:            case (3): // Randomly select three neighborhood operations 13:                  choose three of {N7, k-insertion, k-swap}; 14:                  update π*; // Apply all three neighborhood operations sequentially 15:                  break; 16:        } 17: } while (!terminationCondition); // Repeat until termination condition is met 18: return π*;

3.5. The Two-Step Insertion Neighborhood Operation

Both N7 and k-insertion utilize a one-step insertion operation on the current solution to produce a neighboring solution, subsequently selecting the optimal solution for the subsequent insertion step. However, due to the predefined decoding rules, this one-step insertion operation restricts the potential for a suboptimal solution to evolve into a superior one after the next insertion. To overcome this limitation, this paper extends the one-step operation to a two-step operation. This approach accepts initially inferior neighborhood solutions that may improve in the second step. A novel neighborhood structure incorporating a two-step neighborhood operation is thus designed.

As depicted in Figure 5, the job swap between machines within the same stage exemplifies the two-step neighborhood operation. It is crucial to emphasize that the stage decoding rule of the HFSP ensures that movement operations do not result in infeasible solutions. The newly proposed neighborhood structure maintains the feasibility of movement operations for the HFSP.

A 5 × 3 instance is given to demonstrate the efficacy of the proposed neighborhood structure.

Table 2. Processing time of the 5 × 3 instance.

Stage	Machines	Processing Time
		Job1	Job2	Job3	Job4	Job5
1	3	2	4	5	1	6
2	2	7	8	3	6	3
3	3	5	9	4	7	2

gives the processing information of the 5 × 3 instance. A feasible solution to this instance is optimized by the two-step neighborhood operation. The initial job sequence for the first stage is denoted as {J_3,1, J_5,1, J_2,1, J_4,1, J_1,1}. The Gantt chart is generated by decoding rules, as shown in the left diagram of Figure 6. A new solution is obtained by exchanging the J_4,1 on machine M₄ with J_5,1 on machine M₃, and the Gantt chart is depicted in the right diagram of Figure 4. Upon comparing, it is observed that the objective value has improved from 26 to 22, showing the optimization achieved through the two-step neighborhood operation.

3.6. The Destruction and Construction

The process of destruction can be categorized into two primary types: single-point and multi-point destruction. Single-point destruction involves the removal of a randomly selected job sequence position within the encoding vector. In contrast, multi-point destruction entails the random selection of multiple, non-repeating positions in the encoding vector for deletion. Following the application of either destruction method, a destroyed job sequence and a list of all deleted jobs are created. Subsequently, a construction operation is executed through greedy insertion, where the deleted jobs are individually inserted into the optimal position within the current destroyed job sequence.

The single-point destruction and construction speeds up the search, but the consistent search reduces the probability of finding the optimal solution. The multi-point destruction increases the search time of construction when the number of deleted jobs is too high. Therefore, the proposed enhanced IG algorithm selects the number of deleted jobs dynamically within a certain range. The operation is shown in Algorithm 2.

Algorithm 2. Destruction and construction

Input: Current solution π, destruction size x Output: Reconstructed solution π* 1: for i = 0 to x do // Destruction phase: remove x jobs 2:        place = rand(0, length of Seq); // Randomly select removal position 3:        Seq -> erase(Seq_place); // Remove job from current sequence 4:        Del_Seq -> insert(Seq_place); // Add removed job to deletion list 5: End for 6: π*->Seq = Del_Seq; / Update current sequence to post-destruction sequence 7: for i = 0 to x do // Construction phase: reinsert deleted jobs 8:        job = Del_Seq_i; //Get the i-th deleted job 9:        π*1->Seq = insert job to the first of π*->Seq;// Insert job at beginning as baseline 10:      for j = 1 to (length of π*->Seq) do // Try all possible insertion positions 11:             π*2->Seq = insert job to the j-th place of π*->Seq; // Insert at j-th position 12:             if (makespan(π*2) < makespan(π*1))// Compare makespan values 13:                   π*1 = π*2 // Update to better solution 14:             end if 15:      end for 16:      π* = π*1// Confirm best insertion position for current job 17: end for 18: π = π*; // Update final solution 19: return π; // Return reconstructed solution

3.7. The Update Mechanism of Poor-Quality Solutions

Since the IG algorithm is a greedy local search algorithm, the proposed enhanced IG algorithm introduces a simulated annealing strategy to prevent the algorithm from falling into a local optimum. Some of the poor-quality solutions are accepted with a certain probability to avoid a local optimum. The acceptance rule depends on the probability value g(x), which is calculated as follows:

$$g_{(x)}=a\ast \exp ^((f_1-f_2)/T)$$

(4)

The current solution and neighborhood solution are denoted by $f_1$ and $f_2$, respectively. The fitness value is calculated by Equation (1). If the value of $f_2$ is less than a random number between [0, 1], then $f_1$ is replaced with $f_2$; otherwise, it is not replaced.

3.8. A Novel Rapid Evaluation Method

The quality of a neighborhood solution is ascertained through re-decoding the new scheduling scheme. However, a neighborhood search typically modifies only the local job sequence on a few machines, leaving the majority of job sequences unchanged. Conducting numerous neighborhood searches with full decoding can be computationally expensive. While there is a fast approximate evaluation method for the FJSP that can effectively assess the quality of neighborhood solutions, it does not guarantee 100% accuracy and is not directly applicable to the proposed two-step neighborhood structure of the critical path. Consequently, this paper introduces a rapid evaluation method for neighborhood solutions, leveraging the stage-based decoding rule of the HFSP.

The rapid evaluation method divides the scheduling into three parts. If the current neighborhood operation is for stage a, then from 0 to the a stage is the first part, a is the second part, and from the a stage to the s stage is the third part. Before the neighborhood operation, the starting time and completion time of each operation O are denoted by s and t, respectively. After the neighborhood operation, the starting time and completion time are denoted by s⁻ and t⁻, respectively. The machine predecessor and successor of operation are expressed as MP and MS. P_ij represents the processing time of job j at stage i. After performing a neighborhood move, the second part will adjust part of the job sequence on machines and the job sequence will remain unchanged in the first and the second parts. The first part always satisfies s = s⁻, and the second part always satisfies t = t⁻.

There is always a critical path through the operation O_{a j} from the beginning to the end of the process, so $makespan=\mathit{max}\{j\in J|s_{O_{aj}}^{-}+t_{O_{aj}}^{-}+P_{O_{aj}}^{-}\}$

where,

$$s_{O_{a,j}}^{-}=max\left\{s_{O_{a,j-1}}^{-}+P_{O_{a,j-1}}^{-},s_{O_{a,j\to MP}}^{-}+P_{O_{a,j\to MP}}^{-}\right\}=max\left\{s_{O_{a,j-1}}+P_{O_{a,j-1}}^{-},s_{O_{a,j\to MP}}+P_{O_{a,j\to MP}}^{-}\right\}$$

(5)

$$t_{O_{a,j}}^{-}=max\left\{t_{O_{a,j+1}}^{-}+P_{O_{a,j+1}}^{-},t_{O_{a,j\to MS}}^{-}+P_{O_{a,j\to MS}}^{-}\right\}=max\left\{t_{O_{a,j+1}}+P_{O_{a,j+1}}^{-},t_{O_{a,j\to MS}}+P_{O_{a,j\to MS}}^{-}\right\}$$

(6)

And then,

$$\begin{array}{l}makespan=max\left\{j\in J\left|P_{O_{a,j}}^{-}+max\left\{s_{O_{a,j-1}}+P_{O_{a,j-1}}^{-},s_{O_{a,j\to MP}}+P_{O_{a,j\to MP}}^{-}\right\}\right.\right\}+\\ max\left\{t_{O_{a,j+1}}+P_{O_{a,j+1}}^{-},t_{O_{a,j\to MS}}+P_{O_{a,j\to MS}}^{-}\right\}\end{array}$$

(7)

When the number of stages is zero, s = 0; When the number of stages is S, t = 0. This evaluation obtains the longest path from the beginning to the end of processing. In other words, the proposed method is equal to the actual objective value through full decoding. The conventional evaluation method requires recalculating all jobs across S stages, resulting in a time complexity of O_(n×S). In contrast, the proposed rapid evaluation method divides the scheduling process into three parts: the first part remains unchanged and requires no recalculation; the second part involves only the re-evaluation of jobs affected by the neighborhood operation at stage a; and the third part is updated recursively based on the results of the second part. This approach reduces the overall computational complexity to O_(2n), and it can be further reduced when applied to single-machine job sequences. The proposed method maintains 100% accuracy by preserving the complete temporal dependencies in the schedule while avoiding redundant computations. By adopting this stage-wise local update strategy, the computational efficiency is significantly improved. As the number of stages increases, the acceleration ratio can reach approximately S/2, enabling the evaluation of a larger number of neighborhood solutions within a limited time and facilitating more effective exploration of promising search regions. The detailed procedure of this method is presented in Algorithm 3.

Algorithm 3. Rapid Evaluation Method

Input: Solution π, changed stage a Output: Updated makespan 1: affected_ops = GetAffectedOperations(move, stage_a); // Identify operations in stage a 2: s_new = π->start_times; // Copy current start times 3: t_new = π->completion_times; // Copy current completion times 4: // Part 1: stages 0 to (a-1) remain unchanged (s = s−) 5: // Part 3: stages (a+1) to S remain unchanged (t = t−) 6: for each operation O[i,a] in affected_ops do // Part 2: update stage a only 7:        job_pred_time = t_new[i][a − 1] + P[i][a − 1]; // Job predecessor constraint 8:        machine_pred = GetMachinePredecessor(O[i,a], move); // Get machine predecessor 9:        if (machine_pred ≠ NULL) 10:           machine_pred_time = t_new[machine_pred] + P[machine_pred]; 11:       else machine_pred_time = 0; 12:       end if 13:       s_new[i][a] = max(job_pred_time, machine_pred_time); // Equation (5) 14:       t_new[i][a] = s_new[i][a] + P[i][a]; // Update completion time (6) 15: end for 16: new_makespan = 0; // Initialize makespan calculation 17: for each job j ∈ J do // Apply Equation (7) 18:        path_length = s_new[j][a] + P[j][a] + max(t_new[j][a+1] + P[j][a+1], t_new[machine_successor]); 19:        new_makespan = max(new_makespan, path_length); // Update maximum 20: end for 21: return new_makespan;

3.9. Procedure of the Graph Knowledge-Enhanced IG Algorithm

The essence of the enhanced IG algorithm lies in conducting a methodical and sustained exploration of the neighborhood solution within the solution space. The proposed IG algorithm is structured around four distinct phases: initialization, destruction, construction, and local search. The process begins with the generation of an initial solution, which then undergoes a series of searches through the destruction and construction phases, steering towards more promising regions within the solution space. To balance exploration and exploitation during the search process, the total runtime is divided into two phases by introducing a strategy-switching threshold at 30% of the total StopTime. In the first phase (0–30% of runtime), the algorithm emphasizes global exploration using destruction and reconstruction operations to enhance solution diversity. After this point, the search intensifies through critical-path-based neighborhood structures, focusing on local exploitation and fine-tuning of promising areas. The choice of 0.3 *StopTime follows a widely used empirical rule in metaheuristic design, where a 30/70 runtime allocation is commonly adopted to achieve a practical trade-off between diversification and intensification. The destruction and construction process introduces a disturbance to the current solution. As the algorithm approaches convergence, local search is initiated during the iterations to broaden the search space and facilitate further enhancements. These phases are iteratively executed until the termination criterion is satisfied. The workflow of the enhanced IG algorithm is depicted in Figure 7.

4. Experimental Study

To test the proposed enhanced IG algorithm, three groups of experiments are shown, including Calier 77 instances [36], Liao 10 instances [37], and 240 small-scale instances [8]. These benchmarks and results were adopted from other published papers. Before the start of the three experiments, we needed to carry out the parameter experiment of the enhanced IG algorithm. The proposed enhanced IG algorithm is implemented in C++(Visual studio 2019) on a computer with an Inter(R) Core i7 processor, 3.5 GHz, RAM 32 GB, and tested on three types of HFSP benchmarks. To evaluate the quality of the solutions, the relative percent deviation (DEV) is adopted for each instance of the HFSP.

$$DEV={\displaystyle \frac{makespan-LB}{LB}}\times 100\%$$

(8)

where LB means the low bound of each instance.

4.1. Evaluation of the Rapid Evaluation Methods

To test the effectiveness of the rapid evaluation methods, the comparative experiments are designed to compare the enhanced IG algorithm without the rapid evaluation method through 24 small-scale instances and 24 large-scale instances. A total of 48 different instances are generated with n {10, 20, 30, 40, 60, 80, 100, 120}, and s {5, 10, 15, 20, 30, 40}. The number of machines and processing times of machines per stage are uniformly distributed according to [1, 3] and [1, 30], respectively. Each instance runs five times for forward decoding and backward decoding independently. The proposed evaluation strategy and full decoding method are run 20 times for each instance. Each time it executes 100,000 times. The full decoding is used to compare the longest time-consuming part in the rapid evaluation, which is a situation where all calculations are performed on the second part of the job. Figure 8a,b show the average of 10 run times for rapid evaluation and full decoding, and the horizontal and vertical axes, respectively, indicate the number of stages and the time required for one decoding.

The experimental results show that the computational speed of rapid evaluation is faster than that of the full decoding method. When the number of jobs is constant, the computational speed of the rapid evaluation is not affected by the change in the number of stages, while the running time of the full decoding method increases with the increase in the number of stages. In Figure 8c, the horizontal axis represents the number of processing stages, and the vertical axis represents the ratio of the full decoding time to the rapid evaluation time. When the number of stages increases, the computational time for rapid evaluation is much smaller than that for full decoding. As the number of stages increases, the proposed method becomes more effective.

4.2. Experiment 1—Carlier Benchmark

Experiment 1 contains 77 instances, which were adopted from the well-known Carlier benchmark, in which the problem size and No. of all instances can be identified by its name. “j10c5a2” means 10 jobs, 5 stages, and the second instance. The proposed enhanced IG algorithm is compared with algorithms, which have achieved good results in the literature: the branch-and-bound (B&B) algorithm [38], the artificial immune system (AIS) algorithm [39], the particle swarm optimization (PSO) algorithm [37], and LABC [40]. These algorithms used 1600s as the StopTime. The StopTime of the enhanced IG algorithm is reduced to 60s with limited computational costs, and the optimal solution is recorded by 20 independently run times. In

Table 3. Computational results of the Carlier benchmark.

Instance	LB	B&B		AIS		PSO		LABC		Enhanced IG		%Deviation
		MINC	MINT	MINC	MINT	MINC	MINT	MINC	MINT	MINC	MINT	B&B	AIS	PSO	LABC	EIG
j10c5a2	88	88	13	88	1	88	0.002	88	0	88	0	0.00	0.00	0.00	0.00	0.00
j10c5a3	117	117	7	117	1	117	0.002	117	0.02	117	0	0.00	0.00	0.00	0.00	0.00
j10c5a4	121	121	6	121	1	121	0.003	121	0	121	0	0.00	0.00	0.00	0.00	0.00
j10c5a5	122	122	11	122	1	122	0.013	122	0.02	122	0	0.00	0.00	0.00	0.00	0.00
j10c5a6	110	110	6	110	4	110	0.174	110	0.12	110	0.001	0.00	0.00	0.00	0.00	0.00
j10c5b1	130	130	13	130	1	130	0.003	130	0	130	0	0.00	0.00	0.00	0.00	0.00
j10c5b2	107	107	6	107	1	107	0.003	107	0	107	0	0.00	0.00	0.00	0.00	0.00
j10c5b3	109	109	9	109	1	109	0.012	109	0	109	0	0.00	0.00	0.00	0.00	0.00
j10c5b4	122	122	6	122	2	122	0.025	122	0	122	0	0.00	0.00	0.00	0.00	0.00
j10c5b5	153	153	6	153	1	153	0.001	153	0	153	0	0.00	0.00	0.00	0.00	0.00
j10c5b6	115	115	11	115	1	115	0.001	115	0	115	0	0.00	0.00	0.00	0.00	0.00
j10c5c1	68	68	28	68	32	68	0.332	68	0.08	68	0.031	0.00	0.00	0.00	0.00	0.00
j10c5c2	74	74	19	74	4	74	0.535	74	2.8	74	0.045	0.00	0.00	0.00	0.00	0.00
j10c5c3	71	71	240	72	-	71	36.997	72	-	71	0.182	0.00	1.41	0.00	1.41	0.00
j10c5c4	66	66	1017	66	3	66	0.215	66	0.15	66	0.022	0.00	0.00	0.00	0.00	0.00
j10c5c5	78	78	42	78	14	78	0.122	78	0.08	78	0.01	0.00	0.00	0.00	0.00	0.00
j10c5c6	69	69	4865	69	12	69	0.405	69	0.37	69	0.016	0.00	0.00	0.00	0.00	0.00
j10c5d1	66	66	6490	66	5	66	0.185	66	0.1	66	0.001	0.00	0.00	0.00	0.00	0.00
j10c5d2	73	73	2617	73	31	73	1.158	73	0.13	73	0.017	0.00	0.00	0.00	0.00	0.00
j10c5d3	64	64	481	64	15	64	0.098	64	0.02	64	0.033	0.00	0.00	0.00	0.00	0.00
j10c5d4	70	70	493	70	5	70	0.337	70	0.1	70	0.005	0.00	0.00	0.00	0.00	0.00
j10c5d5	66	66	393	66	1446	66	0.515	66	0.44	66	0.867	0.00	0.00	0.00	0.00	0.00
j10c5d6	62	62	1627	62	8	62	0.383	62	0.07	62	0.01	0.00	0.00	0.00	0.00	0.00
j10c10a1	139	139	6861	139	1	139	0.055	139	0.02	139	0.007	0.00	0.00	0.00	0.00	0.00
j10c10a2	158	158	41	158	18	158	0.87	158	0.22	158	0.009	0.00	0.00	0.00	0.00	0.00
j10c10a3	148	148	21	148	1	148	0.017	148	0.05	148	0.004	0.00	0.00	0.00	0.00	0.00
j10c10a4	149	149	58	149	2	149	0.085	149	0	149	0	0.00	0.00	0.00	0.00	0.00
j10c10a5	148	148	21	148	1	148	0.102	148	0	148	0.004	0.00	0.00	0.00	0.00	0.00
j10c10a6	146	146	36	146	4	146	0.239	146	0.03	146	0.01	0.00	0.00	0.00	0.00	0.00
j10c10b1	163	163	20	163	1	163	0.013	163	0	163	0	0.00	0.00	0.00	0.00	0.00
j10c10b2	157	157	36	157	1	157	0.221	157	0	157	0.004	0.00	0.00	0.00	0.00	0.00
j10c10b3	169	169	66	169	1	169	0.014	169	0	169	0	0.00	0.00	0.00	0.00	0.00
j10c10b4	159	159	19	159	1	159	0.021	159	0	159	0	0.00	0.00	0.00	0.00	0.00
j10c10b5	165	165	20	165	1	165	0.037	165	0	165	0	0.00	0.00	0.00	0.00	0.00
j10c10b6	165	165	33	165	1	165	0.056	165	0	165	0	0.00	0.00	0.00	0.00	0.00
j10c10c1	113	127	34	115	-	115	-	115	-	114	-	12.39	1.77	1.77	1.77	0.88
j10c10c2	116	116	-	119	-	117	-	119	-	116	0.997	0.00	2.59	0.86	2.59	0.00
j10c10c3	98	133	1100	116	-	116	-	116	-	116	-	35.71	18.37	18.37	18.37	18.37
j10c10c4	103	135	-	120	-	120	-	120	-	119	-	31.07	16.50	16.50	16.50	15.53
j10c10c5	121	145	-	126	-	125	-	125	-	125	-	19.83	4.13	3.31	3.31	3.31
j10c10c6	97	112	-	106	-	106	-	106	-	105	-	15.46	9.28	9.28	9.28	8.25
j15c5a1	178	178	18	178	1	178	0.06	178	0	178	0	0.00	0.00	0.00	0.00	0.00
j15c5a2	165	165	35	165	1	165	0.005	165	0.03	165	0	0.00	0.00	0.00	0.00	0.00
j15c5a3	130	130	34	130	1	130	0.006	130	0.02	130	0	0.00	0.00	0.00	0.00	0.00
j15c5a4	156	156	21	156	2	156	0.013	156	0.02	156	0.002	0.00	0.00	0.00	0.00	0.00
j15c5a5	164	164	34	164	1	164	0.004	164	0	164	0	0.00	0.00	0.00	0.00	0.00
j15c5a6	178	178	38	178	1	178	0.006	178	0	178	0.002	0.00	0.00	0.00	0.00	0.00
j15c5b1	170	170	16	170	1	170	0.003	170	0	170	0	0.00	0.00	0.00	0.00	0.00
j15c5b2	152	152	25	152	1	152	0.005	152	0	152	0	0.00	0.00	0.00	0.00	0.00
j15c5b3	157	157	15	157	1	157	0.03	157	0	157	0	0.00	0.00	0.00	0.00	0.00
j15c5b4	147	147	37	147	1	147	0	147	0	147	0.001	0.00	0.00	0.00	0.00	0.00
j15c5b5	166	166	20	166	2	166	0.086	166	0	166	0.002	0.00	0.00	0.00	0.00	0.00
j15c5b6	175	175	23	175	1	175	0.016	175	0	175	0	0.00	0.00	0.00	0.00	0.00
j15c5c1	85	85	2131	85	774	85	4.205	85	4.47	85	2.264	0.00	0.00	0.00	0.00	0.00
j15c5c2	90	90	184	91	-	90	1198	90	3.24	90	0.308	0.00	1.11	0.00	0.00	0.00
j15c5c3	87	87	202	87	16	87	2.398	87	1.16	87	0.22	0.00	0.00	0.00	0.00	0.00
j15c5c4	89	90	-	89	317	89	2.208	89	6.85	89	0.133	1.12	0.00	0.00	0.00	0.00
j15c5c5	73	84	-	74	-	74	-	74	-	74	-	15.07	1.37	1.37	1.37	1.37
j15c5c6	91	91	57	91	19	91	0.191	91	0.16	91	0.015	0.00	0.00	0.00	0.00	0.00
j15c5d1	167	167	24	167	1	167	0	167	0	167	0	0.00	0.00	0.00	0.00	0.00
j15c5d2	82	85	-	84	-	84	-	84	-	84	-	3.66	2.44	2.44	2.44	2.44
j15c5d3	77	96	-	83	-	82	-	82	-	82	-	24.68	7.79	6.49	6.49	6.49
j15c5d4	61	101	-	84	-	84	-	84	-	84	-	65.57	37.70	37.70	37.70	37.70
j15c5d5	67	97	-	80	-	79	-	79	-	79	-	44.78	19.40	17.91	17.91	17.91
j15c5d6	79	87	-	81	-	81	-	81	-	81	-	10.13	2.53	2.53	2.53	2.53
j15c10a1	236	236	40	236	1	236	0.018	236	0	236	0	0.00	0.00	0.00	0.00	0.00
j15c10a2	200	200	154	200	30	200	0.214	200	0	200	0.008	0.00	0.00	0.00	0.00	0.00
j15c10a3	198	198	45	198	4	198	0.171	198	0	198	0	0.00	0.00	0.00	0.00	0.00
j15c10a4	225	225	78	225	12	225	0.072	225	0	225	0.004	0.00	0.00	0.00	0.00	0.00
j15c10a5	182	183	-	182	2	182	0.509	182	0	182	0	0.55	0.00	0.00	0.00	0.00
j15c10a6	200	200	44	200	2	200	0.468	200	0	200	0	0.00	0.00	0.00	0.00	0.00
j15c10b1	222	222	70	222	3	222	0.017	222	0	222	0.001	0.00	0.00	0.00	0.00	0.00
j15c10b2	187	187	80	187	1	187	0.012	187	0.09	187	0.003	0.00	0.00	0.00	0.00	0.00
j15c10b3	222	222	80	222	1	222	0.007	222	0	222	0	0.00	0.00	0.00	0.00	0.00
j15c10b4	221	221	84	221	1	221	0.007	221	0	221	0	0.00	0.00	0.00	0.00	0.00
j15c10b5	200	200	84	200	1	200	0.135	200	0.1	200	0.002	0.00	0.00	0.00	0.00	0.00
j15c10b6	219	219	67	219	1	219	0.006	219	0	219	0.005	0.00	0.00	0.00	0.00	0.00
mean value			469.42		44.81		19.26		0.33		0.08	3.64	1.64	1.54	1.58	1.49

LB: upper bounds; MINC: the minimum makespan of all results MINT: the time to get the minimum makespan.

, experimental results show that the enhanced IG algorithm obtains optimal solutions for the given 77 instances, such as the good results of “j10c10c” (114), “j10c10a4” (119), and “j10c10e6” (105). In terms of the deviation of the values obtained by these algorithms, the deviation between the proposed enhanced IG algorithm and the lower bound is merely 1.49%; however, the lowest deviation of the four compared algorithms is 1.54%. In terms of the running time to obtain the optimal solution, the average time of the proposed algorithm is only 0.08 for all 77 instances, while the lowest average time of the other compared algorithms is 0.33. It can be seen from the experimental results that the proposed enhanced IG algorithm has better search speed and efficiency.

4.3. Experiment 2—Liao Benchmark

Regarding the well-known Liao benchmark, the termination condition is 1600s, and each instance is run 10 times to record the optimal solution and the time taken to obtain the optimal solution.

Table 4. Computational results of Liao benchmark.

Instance	PSO		IBBO		LABC		IGT		Enhanced IG		%Deviation
	MINC	MINT	MINC	MINT	MINC	MINT	MINC	MINT	MINC	MINT	PSO	IBBO	LABC	IGT	EIG
j30c5e1	471	96.16	474	152.3	467	58.54	462	14.94	462	252.58	1.95	2.60	1.08	0.00	0.00
j30c5e2	616	55.28	616	146.8	616	19.66	616	0.21	616	2.51	0.00	0.00	0.00	0.00	0.00
j30c5e3	602	64.56	610	170.1	596	64.04	593	22.69	593	370.65	1.52	2.87	0.51	0.00	0.00
j30c5e4	575	86.98	577	149.4	571	54.75	563	19.4	564	100.62	2.13	2.49	1.42	0.00	0.18
j30c5e5	605	79.84	609	168.3	603	42.93	600	22.6	600	121.38	0.83	1.50	0.50	0.00	0.00
j30c5e6	605	0.996	615	144.2	607	47.38	600	12.45	600	126.65	0.83	2.50	1.17	0.00	0.00
j30c5e7	629	87.18	629	150.6	626	37.17	626	1.58	626	3.18	0.48	0.48	0.00	0.00	0.00
j30c5e8	678	97.67	685	186.9	678	88.02	674	7.07	674	5.05	0.59	1.63	0.59	0.00	0.00
j30c5e9	651	83.8	654	177.3	646	82	642	15.9	642	88.44	1.40	1.87	0.62	0.00	0.00
j30c5e10	594	77.46	596	189.5	580	88.57	573	23.92	571	113.81	4.03	4.38	1.58	0.35	0.00
mean value	602.60	72.99	606.50	163.54	599.00	58.31	594.90	14.08	594.80	118.49	1.38	2.03	0.75	0.04	0.02

MINC: the minimum makespan of all results; MINT: the time to get the minimum makespan.

compares the experimental results of the proposed enhanced IG algorithm with the current superior algorithms: PSO [37], LABC [40], IBBO [41], and IGT [33]. The “MINC” and “MINT” in the table indicate the minimum makespan of all results and the corresponding run time. Among the whole of 10 instances, the proposed enhanced IG algorithm and IGT can obtain the best solution in 9 instances, LABC can obtain 2 instances, while PSO and IBBO merely obtain 1 instance. The proposed enhanced IG algorithm obtains the new optimal solution (571) of “j30c5e10”. About the deviation of the values, the deviation between the proposed enhanced IG algorithm and the lower bound is merely 0.02%; however, the lowest deviation of the four comparing algorithms is 0.04%. It is verified that the introduced critical path can improve the quality of the algorithm.

4.4. Experiment 3—Jose Benchmark

The 240 instances are adopted from the Jose benchmark [8], where n {10, 15, 20, 25, 30, 35}, and s {5, 10, 15, 20}. The name of each instance indicates the scale of the problem. Notably, “10 × 5 × 1” means the first problem with 10 jobs and 5 stages. Fernandez and Framinan [8] used an IG algorithm to solve these 240 instances and set an upper bound with the designed StopTime = 50 × (the number of jobs^3) × (the number of stages). In this paper, the termination time is reduced by 25 times (StopTime = 2 × (job number^3) × (stage number)). The optimal solution and its running time are recorded by running 10 times independently. The results are compared with the given upper bound, and related comparison results are shown in

Table 5. Computational results of Jose benchmark.

Instance		Enhanced IG		Instance		Enhanced IG		Instance		Enhanced IG
	UB	MINC	MINT		UB	MINC	MINT		UB	MINC	MINT
10 × 5 × 1	410	408	0.02	20 × 5 × 1	660	660	1.796	30 × 5 × 1	649	649	49.432
10 × 5 × 2	394	384	0.51	20 × 5 × 2	587	584	3.626	30 × 5 × 2	789	789	0.108
10 × 5 × 3	453	453	0.012	20 × 5 × 3	559	558	11.774	30 × 5 × 3	793	792	114.571
10 × 5 × 4	452	452	0.015	20 × 5 × 4	552	550	18.525	30 × 5 × 4	680	680	131.298
10 × 5 × 5	389	389	0.02	20 × 5 × 5	526	526	1.559	30 × 5 × 5	698	695	40.53
10 × 5 × 6	360	357	0.022	20 × 5 × 6	513	511	76.458	30 × 5 × 6	661	660	105.725
10 × 5 × 7	443	437	0.283	20 × 5 × 7	678	676	44.786	30 × 5 × 7	575	572	117.615
10 × 5 × 8	436	433	0.081	20 × 5 × 8	517	515	63.985	30 × 5 × 8	805	803	135.638
10 × 5 × 9	409	406	0.017	20 × 5 × 9	681	679	13.472	30 × 5 × 9	821	820	83.351
10 × 5 × 10	373	373	0.004	20 × 5 × 10	525	524	37.494	30 × 5 × 10	762	759	78.509
10 × 10 × 1	806	799	0.47	20 × 10 × 1	797	794	15.753	30 × 10 × 1	1057	1057	99.627
10 × 10 × 2	785	785	0.011	20 × 10 × 2	844	839	118.236	30 × 10 × 2	930	931	50.322
10 × 10 × 3	755	755	0.058	20 × 10 × 3	858	852	81.621	30 × 10 × 3	1126	1126	146.122
10 × 10 × 4	922	917	0.021	20 × 10 × 4	1015	1013	50.054	30 × 10 × 4	1095	1090	433.476
10 × 10 × 5	969	957	0.025	20 × 10 × 5	973	973	144.35	30 × 10 × 5	944	942	267.769
10 × 10 × 6	1001	1001	0.014	20 × 10 × 6	796	793	118.739	30 × 10 × 6	972	976	233.728
10 × 10 × 7	947	942	0.058	20 × 10 × 7	771	768	8.953	30 × 10 × 7	977	980	150.051
10 × 10 × 8	545	543	0.139	20 × 10 × 8	950	948	49.658	30 × 10 × 8	1010	1006	320.229
10 × 10 × 9	516	511	7.534	20 × 10 × 9	953	951	9.715	30 × 10 × 9	909	902	83.447
10 × 10 × 10	684	684	0.026	20 × 10 × 10	866	865	53.697	30 × 10 × 10	1098	1099	43.633
10 × 15 × 1	959	959	0.008	20 × 15 × 1	1067	1064	40.746	30 × 15 × 1	1205	1202	296.344
10 × 15 × 2	1290	1290	0.085	20 × 15 × 2	1333	1324	112.894	30 × 15 × 2	1271	1277	291.569
10 × 15 × 3	1091	1091	0.029	20 × 15 × 3	1295	1293	31.654	30 × 15 × 3	1209	1208	503.331
10 × 15 × 4	875	866	0.577	20 × 15 × 4	1031	1026	62.144	30 × 15 × 4	1530	1526	449.351
10 × 15 × 5	883	879	12.384	20 × 15 × 5	1015	1015	81.662	30 × 15 × 5	1138	1142	778.377
10 × 15 × 6	843	836	0.011	20 × 15 × 6	1277	1277	8.435	30 × 15 × 6	1436	1437	397.775
10 × 15 × 7	912	904	6.45	20 × 15 × 7	1274	1272	118.414	30 × 15 × 7	1455	1449	750.599
10 × 15 × 8	770	765	0.041	20 × 15 × 8	1261	1259	50.641	30 × 15 × 8	1438	1430	542.952
10 × 15 × 9	764	751	1.167	20 × 15 × 9	1748	1732	34.746	30 × 15 × 9	2019	2019	46.02
10 × 15 × 10	866	849	5.537	20 × 15 × 10	967	966	50.644	30 × 15 × 10	1258	1262	796.534
10 × 20 × 1	1353	1345	0.393	20 × 20 × 1	1332	1329	41.898	30 × 20 × 1	1488	1489	910.785
10 × 20 × 2	1156	1155	0.064	20 × 20 × 2	1325	1323	76.604	30 × 20 × 2	1598	1602	135.08
10 × 20 × 3	1503	1503	0.007	20 × 20 × 3	1324	1316	281.628	30 × 20 × 3	1572	1563	624.561
10 × 20 × 4	1483	1459	0.299	20 × 20 × 4	1580	1576	260.773	30 × 20 × 4	1544	1545	539.408
10 × 20 × 5	1505	1494	21.595	20 × 20 × 5	1320	1317	301.935	30 × 20 × 5	1626	1626	419.98
10 × 20 × 6	1309	1302	5.347	20 × 20 × 6	1284	1282	17.335	30 × 20 × 6	1499	1499	528.826
10 × 20 × 7	1420	1412	0.867	20 × 20 × 7	1632	1630	79.079	30 × 20 × 7	1531	1530	1009.76
10 × 20 × 8	1522	1517	14.298	20 × 20 × 8	1847	1846	312.697	30 × 20 × 8	1823	1838	177.356
10 × 20 × 9	902	884	2.336	20 × 20 × 9	1302	1300	162.103	30 × 20 × 9	2362	2367	423.745
10 × 20 × 10	1099	1088	8.649	20 × 20 × 10	1202	1200	73.632	30 × 20 × 10	2391	2402	987.849
15 × 5 × 1	486	482	2.007	25 × 5 × 1	774	774	0.068	35 × 5 × 1	1080	1080	0.24
15 × 5 × 2	423	422	2.852	25 × 5 × 2	696	696	0.132	35 × 5 × 2	1074	1074	0.088
15 × 5 × 3	504	503	0.274	25 × 5 × 3	707	706	52.723	35 × 5 × 3	888	888	7.724
15 × 5 × 4	440	436	24.745	25 × 5 × 4	790	790	56.863	35 × 5 × 4	863	862	96.401
15 × 5 × 5	420	418	1.749	25 × 5 × 5	603	599	63.693	35 × 5 × 5	887	884	180.531
15 × 5 × 6	414	411	0.204	25 × 5 × 6	704	703	122.766	35 × 5 × 6	895	889	249.473
15 × 5 × 7	484	484	0.665	25 × 5 × 7	692	691	19.286	35 × 5 × 7	669	666	133.477
15 × 5 × 8	525	520	2.391	25 × 5 × 8	694	692	75.448	35 × 5 × 8	716	714	241.015
15 × 5 × 9	557	554	4.278	25 × 5 × 9	668	668	51.303	35 × 5 × 9	845	843	130.4
15 × 5 × 10	443	442	0.287	25 × 5 × 10	646	646	0.239	35 × 5 × 10	948	946	164.397
15 × 10 × 1	757	752	14.896	25 × 10 × 1	862	861	183.72	35 × 10 × 1	1085	1085	0.624
15 × 10 × 2	704	699	7.313	25 × 10 × 2	974	974	0.475	35 × 10 × 2	1247	1247	1.735
15 × 10 × 3	853	853	0.071	25 × 10 × 3	911	911	128.314	35 × 10 × 3	1061	1061	0.774
15 × 10 × 4	886	884	2.197	25 × 10 × 4	994	994	3.078	35 × 10 × 4	1092	1092	9.347
15 × 10 × 5	1087	1084	0.12	25 × 10 × 5	942	940	63.494	35 × 10 × 5	1268	1270	676.615
15 × 10 × 6	1042	1038	5.431	25 × 10 × 6	995	995	158.132	35 × 10 × 6	1165	1163	810.119
15 × 10 × 7	1020	1020	0.017	25 × 10 × 7	879	875	73.173	35 × 10 × 7	1015	1013	602.434
15 × 10 × 8	1011	1011	27.019	25 × 10 × 8	836	837	79.193	35 × 10 × 8	991	995	327.622
15 × 10 × 9	659	646	56.824	25 × 10 × 9	1061	1060	49.376	35 × 10 × 9	1143	1147	611.077
15 × 10 × 10	736	734	9.91	25 × 10 × 10	919	922	195.629	35 × 10 × 10	2115	2105	16.263
15 × 15 × 1	1029	1027	9.018	25 × 15 × 1	1205	1213	209.358	35 × 15 × 1	1372	1378	155.04
15 × 15 × 2	1059	1058	47.473	25 × 15 × 2	1143	1141	34.116	35 × 15 × 2	1352	1350	825.419
15 × 15 × 3	1151	1144	65.998	25 × 15 × 3	1222	1222	203.434	35 × 15 × 3	1599	1605	509.558
15 × 15 × 4	1173	1166	10.886	25 × 15 × 4	1354	1354	279.457	35 × 15 × 4	1539	1537	1153.27
15 × 15 × 5	1190	1186	43.112	25 × 15 × 5	1350	1353	121.543	35 × 15 × 5	1247	1249	537.357
15 × 15 × 6	1168	1165	9.207	25 × 15 × 6	1153	1156	186.795	35 × 15 × 6	1337	1337	389.042
15 × 15 × 7	1570	1556	12.315	25 × 15 × 7	1059	1062	235.406	35 × 15 × 7	1532	1534	789.701
15 × 15 × 8	943	940	5.885	25 × 15 × 8	1110	1113	352.432	35 × 15 × 8	1494	1494	830.902
15 × 15 × 9	909	897	42.96	25 × 15 × 9	1148	1152	206.269	35 × 15 × 9	2236	2236	0.927
15 × 15 × 10	876	875	44.792	25 × 15 × 10	1165	1164	170.259	35 × 15 × 10	1312	1314	367.28
15 × 20 × 1	1264	1262	23.558	25 × 20 × 1	1449	1448	153.373	35 × 20 × 1	1569	1567	1085.53
15 × 20 × 2	1564	1564	0.114	25 × 20 × 2	1353	1353	208.027	35 × 20 × 2	1701	1699	675.721
15 × 20 × 3	1213	1206	9.085	25 × 20 × 3	1430	1433	99.779	35 × 20 × 3	1572	1569	682.232
15 × 20 × 4	1557	1557	0.101	25 × 20 × 4	1410	1410	441.399	35 × 20 × 4	1912	1914	1667.38
15 × 20 × 5	1558	1539	40.22	25 × 20 × 5	1407	1405	277.592	35 × 20 × 5	1856	1857	1610.45
15 × 20 × 6	1692	1686	38.849	25 × 20 × 6	1371	1372	553.79	35 × 20 × 6	1415	1414	1123.51
15 × 20 × 7	1731	1700	48.66	25 × 20 × 7	1680	1681	544.107	35 × 20 × 7	1592	1592	1070.21
15 × 20 × 8	1712	1699	13.147	25 × 20 × 8	1310	1320	192.063	35 × 20 × 8	1938	1930	657.221
15 × 20 × 9	1003	995	6.065	25 × 20 × 9	1338	1343	274.523	35 × 20 × 9	1981	1982	561.683
15 × 20 × 10	1098	1089	24.84	25 × 20 × 10	1228	1231	517.145	35 × 20 × 10	1834	1845	168.102

UB: upper bounds; MINC: the minimum makespan of all results; MINT: the time to get the minimum makespan.

. The proposed enhanced IG algorithm obtains 182 new upper bounds and the same upper bounds for the other 42 instances. Computational results prove that the proposed strategies and IG algorithm can effectively improve the solution quality compared to the given IG algorithm [8].

5. Conclusions and Future Work

This paper presents a graph knowledge-enhanced IG algorithm that integrates a critical path analysis and rapid evaluation technique to address the high-frequency scheduling problem—HFSP. An initial solution generation method that utilizes dual permutation-based encoding and a decoding technique with a novel perturbation strategy to broaden the search space. The integration of critical path analysis provides the algorithm with a strategic advantage in identifying and prioritizing tasks that have the most significant impact on the overall schedule. Coupled with the rapid evaluation technique, the algorithm can quickly discard infeasible or suboptimal solutions, thus accelerating the convergence towards an optimal or near-optimal schedule. Experimental evaluation demonstrates that the proposed algorithm surpasses the performance of existing algorithms when applied to the HFSP. The proposed graph knowledge-enhanced IG algorithm seeks new best solutions for 183 hard instances.

This study still has several limitations. The proposed algorithm involves multiple parameters that require manual tuning and lacks adaptive control mechanisms. As the problem scale increases, memory consumption grows significantly, and its effectiveness on ultra-large-scale instances remains underexplored. Moreover, the method is specifically designed for the hybrid flowshop scheduling problem, and its generalizability to other domains has not yet been examined. The objective function focuses solely on makespan minimization, without considering multi-objective scenarios such as energy consumption or tardiness penalties. Additionally, the model assumes a static scheduling environment, ignoring dynamic job arrivals, machine breakdowns, and other real-world uncertainties. Integration with manufacturing execution systems (MES) also presents certain practical challenges.

Future research could be extended in several directions, including automated algorithmic framework construction, incorporation of self-learning mechanisms, and the development of hybrid neighborhood structures driven by both knowledge and data. Furthermore, the proposed method has the potential for adaptation to other complex scheduling and optimization problems, such as flexible job shop scheduling, cloud task scheduling, and logistics distribution optimization.