A Variant Iterated Greedy Algorithm Integrating Multiple Decoding Rules for Hybrid Blocking Flow Shop Scheduling Problem

Abstract

This paper studies the hybrid flow shop scheduling problem with blocking constraints (BHFSP). To better understand the BHFSP, we will construct its mixed integer linear programming (MILP) model and use the Gurobi solver to demonstrate its correctness. Since the BHFSP exists parallel machines in some processing stages, different decoding strategies can obtain different makespan values for a given job sequence and multiple decoding strategies can assist the algorithm to find the optimal value. In view of this, we propose a hybrid decoding strategy that combines both forward decoding and backward decoding to select the minimal objective function value. In addition, a hybrid decoding-assisted variant iterated greedy (VIG) algorithm to solve the above MILP model. The main novelties of VIG are a new reconstruction mechanism based on the hybrid decoding strategy and a swap-based local reinforcement strategy, which can enrich the diversity of solutions and explore local neighborhoods more deeply. This evaluation is conducted against the VIG and six state-of-the-art algorithms from the literature. The 100 tests showed that the average makespan and the relative percentage increase (RPI) values of VIG are 1.00% and 89.6% better than the six comparison algorithms on average, respectively. Therefore, VIG is more suitable to solve the studied BHFSP.

1. Introduction

The flow shop scheduling problem (FSSP) is prevalent in a variety of industries, including semiconductor, automobile, and textile [1,2,3]. To enhance production efficiency, some identical parallel machines are considered in the flow shop. This production pattern is hybrid or flexible and forms a new scheduling problem, called the hybrid flow shop scheduling problem (HFSP). In HFSP, ‘stages’ refers to the processing centers or machining operations. Each job must go through all stages in a predetermined sequence. Parallel machines may exist in each processing stage, allowing HFSP to process multiple jobs simultaneously. Therefore, HFSP has found wide applications in industries such as steel-making, electronics production, and chemistry [3,4,5,6]. In the literature, FSSP has been certified that it is an NP-hard problem [7]. However, HFSP is much more complex than FSSP. Unlike FSSP, which only considers the ordering of jobs, HFSP requires a more comprehensive approach that balances both job sequencing and machine assignment.

In HFSP, at least one processing stage contains identical parallel machines, and each job can be assigned to any one of these parallel machines for processing. HFSP can be divided into two types based on cost-related restrictions: those with infinite buffers and those with finite buffers. The HFSP with infinite buffers cannot cause job blocking due to sufficient buffers between stages that can deposit completed jobs. However, the HFSP with finite buffers may result in job blocking because of finite intermediate buffers. The term “blocking” refers to the situation where a completed job in the current stage is held up on the machine because all parallel machines in the subsequent stage are busy [8]. The blocking constraint may increase the complete time of jobs and reduce production efficiency. Therefore, it is necessary to search for an optimal scheduling sequence that minimizes the blocking of jobs. Based on this, the present study considers the absence of buffer constraints in HFSP, resulting in the formation of a new problem known as the blocking HFSP (BHFSP). Furthermore, the optimization objective of our study is the makespan. It is a very important indicator for actual production. The shorter the makespan, the faster the jobs are completed. A longer makespan, on the other hand, means that jobs are taking longer to complete, which can result in delays and lower productivity. Therefore, by reducing the makespan, manufacturers can enhance resource utilization and meet customer demands.

As mentioned above, when a blocked state occurs, the job is blocked on the current machines until a machine is available in the next stage. Therefore, before designing corresponding strategies for BHFSP, it is necessary to analyze the challenges of the problem. The details are as follows:

(1)

Due to there being no buffers between two adjacent stages, once a job is blocked on the current stage, it cannot be processed until the machine at the next stage is available, which may increase the wait time of jobs, prolong the completion time of jobs, and reduce the production efficiency.

(2)

The HFSP in production is often a large-scale problem, involving a large number of jobs and machines, and it is difficult to generate an optimal scheduling solution in a short time.

(3)

The solution may fall into a local optimum when the job is blocked on the machine. Therefore, it is crucial to design some appropriate and effective strategies to reduce the blocking time.

The iterated greedy (IG) algorithm is an efficient and simple iterative method when optimizing FSS problems [9,10]. It usually uses heuristics to obtain a better initial solution, and then adopts a destruction and reconstruction strategy to enhance the quality of the initial solution. The IG algorithm is a simple and practical heuristic algorithm that can be applied to real-world problems. It is a single-objective optimization algorithm that can be enhanced by utilizing previous search results to improve search efficiency and accuracy. However, the limitation of the IG algorithm is also noticeable, as it is susceptible to getting stuck in local optima during the iteration process. However, the IG algorithm still performs well as long as we make appropriate improvements to IG based on the problem characteristics. For example, the improved IG algorithm can effectively solve the blocking FSSP by considering its specific characteristics [11]. To sum up, we propose a variant IG (VIG) to optimize BHFSP. Our innovations are summarized as follows:

(1)

We construct a mixed integer linear programming (MILP) model and adopt the Gurobi solver to demonstrate its correctness.

(2)

Two different decoding strategies have been designed to calculate the objective in BHFSP. By adopting the hybrid decoding strategy, it is possible to find a smaller maximum completion time.

(3)

A new reconstruction mechanism based on forward and backward decoding strategies is proposed to enrich the diversity of solutions.

(4)

A swap-based local reinforcement strategy is developed to explore local neighborhoods more deeply.

(5)

Abundant simulation experiments have been performed and demonstrated that the VIG shows superiority in solving BHFSP compared with the six algorithms in existence on 100 test instances.

The rest of this study can be stated as follows: Section 2 puts forward the literature related to BHFSP. Section 3 formulates the BHFSP. In Section 4, a variant IG algorithm is designed. Section 5 lists and discusses the simulation experiments. In the end, a summary and future research points are presented in Section 6.

2. Literature Review

2.1. Hybrid Flow Shop Scheduling Problems

The methods commonly used to solve HFSP fall into three categories: exact methods [12], heuristic methods [13], and metaheuristic algorithms [14]. The first category mainly includes the branch-and-bound method [15] and the dynamic programming approach [16], which can obtain the optimal solution using solvers but are best suited for small-scale problems due to their long computation time. However, for HFSPs with large scales, it is hard to obtain an optimum solution within a limited time. In view of this, the second and third categories of methods, heuristic, and metaheuristic have been developed and applied to optimize large-scale problems. The NEH heuristic, initially proposed by Nawaz, Enscore, and Ham to optimize FSSP [17], has been further developed in subsequent studies. Ronconi et al. developed the combination of MinMax and NEH heuristics, called MME, to optimize the blocking FSSP [18]. Likewise, the author obtained PFE by combining the profile fitting (PF) heuristic with NEH. On this basis, Pan and Wang proposed a combined PE-NEH heuristic to solve FSSP with blocking constraints [19]. Fernandez-Viagas et al. used two memory-based composite heuristics to address the HFSP [20]. Öztop et al. presented a greedy adaptive disturbance method combining NEH (GRASP_NEH(x)) for the HFSP [2]. Although these heuristic methods may not be as effective as meta-heuristics in solving complex problems, they are often considered a useful initialization strategy due to their ability to produce high-quality initial solutions.

In recent years, HFSP and its extensions have attracted the attention of scholars. To solve the general HFSP, Xiao et al. studied the work shift HFSP and presented a modified genetic algorithm (GA) according to a scheduling rule to optimize the weighted makespan [21]. Jin et al. adopted a hybrid simulated annealing (SA) method combining different scheduling rules [22]. To effectively solve HFSP, Wang et al. proposed a distribution estimation algorithm (EDA) that uses a probabilistic model to find promising solutions [23]. Pan et al. employed a variety of heuristic methods to improve the performance of the initial solution and embedded them into the discrete artificial bee colony (DABC) to optimize the makespan of HFSP [24]. Due to the lack of local search ability of the swarm intelligence method, Li et al. designed a variety of neighborhood structures to overcome this challenge and utilized the advantages of EDA and chemical-reaction optimization (CRO) to design a hybrid variable neighborhood search (HVNS) algorithm to solve HFSP [25]. To enrich the method of solving HFSP, Lin et al. proposed a chaos-enhanced SA (CSA) algorithm to optimize makespan [26]. To fill the gap in energy conservation studies for the five phases of HFSP, Utama et al. designed a hybrid Aquila Optimizer (HAO) to optimize the total energy consumption [27]. Subsequently, Utama et al. created a hybrid Archimedes optimization algorithm (HAOA), which hopefully will help provide new insights into advanced HAOA methods for solving HFSP [28]. In the real world, the expansion of HFSP with production limitations is more realistic than the general HFSP. Zhang et al. studied the HFSP with lot streaming to improve production efficiency and presented an effective modified migrating birds optimization (EMBO) algorithm to solve it [29]. In addition, the collaborative mechanism is considered. Zhang et al. proposed a collaborative variable neighborhood descent (CVND) for HFSP with consistent sublots [30]. To overcome the drawback that IG tends to fall into a local optimum, Li et al. introduced a restart strategy and proposed an adaptive IG to solve the hybrid no-idle flow shop scheduling problem [31]. In a multiple-factory environment, Cui et al. proposed an improved multi-population genetic algorithm (MPGA) that considers inter-factory neighborhood structure to solve the HFSP [32]. Considering group scheduling, Qin et al. designed a block-based neighborhood selection strategy according to the characteristics of the problem [33]. In addition, Qin et al. also studied the distributed HFSP, whose optimization goal is to minimize the total energy consumption [34]. For the energy consumption metric, Wang et al. investigated the energy-efficient fuzzy HFSP (EFHFSP) with the variable machine speed and extended the existing non-dominated sorting genetic algorithm-II (NSGA-II) [35]. According to the above literature, we selected some representative literature related to our considered problem and stated their problems and algorithms in

Table 1. Review of the studies on HFSP.

Authors	HFSP with Blocking	Objective (Minimizing)	Algorithms	MILP Model
Xiao et al. [21]	No	Weighted makespan	GA	No
Jin et al. [22]	No	Makespan	SA	Yes
Wang et al. [23]	No	Makespan	EDA	Yes
Pan et al. [24]	No	Makespan	DABC	Yes
Li et al. [25]	No	Makespan	HVNS	No
Lin et al. [26]	No	Makespan	CSA	Yes
Utama et al.[27]	No	Total energy consumption	HAO	Yes
Utama et al. [28]	No	Total energy consumption	HAOA	No
Zhang et al. [29]	No	Total flow time	EMBO	Yes
Zhang et al. [30]	No	Makespan	CVND	Yes
Li et al. [31]	No	Total flow time	adaptive IG(AIG)	Yes
Cui et al. [32]	No	Makespan	MPGA	No
Qin et al. [33]	Yes	Makespan	IG	Yes
Qin et al. [34]	Yes	Total energy consumption	IG	Yes
Wang et al. [35]	No	Total energy consumption	NSGA-II	Yes
This research	Yes	Makespan	VIG	Yes

. Through an analysis of problems and algorithms, we found that most of the literature does not consider the blocking constraint and adopts swarm intelligence algorithms, i.e., GA, SA, EDA, DABC, EMBO, etc. These algorithms can provide multiple solutions to improve the diversity of solutions. However, they have more parameters and complicated structures. In the exploration of a single solution neighborhood, these swarm intelligence algorithms are slightly less effective than the IG algorithm [36]. Thus, a modified IG algorithm is adopted to solve the BHFSP due to the fact that it can more intensively explore a single solution and is very effective at improving the reinforcement of the solution.

Regarding the blocking constraints, we note the following research. Pan et al. analyzed the problem characteristics of FSSP with blocking constraints (BFSP) and developed several effective heuristics to expand the problem-solving methods [19]. Shao et al. proposed a discrete invasive weed optimization method (DIWO) to solve the BFSP with the makespan criterion [37]. Ribas et al. considered realistic production setup times and proposed an IG algorithm to handle the BFSP [11]. Considering the distributed environment, Han et al. proposed an effective IG by combining learning-based selecting multiple neighborhood constructions to solve the discrete BFSP [38]. Meanwhile, Qin et al. used a collaborative IG to solve the HFSP without buffers [39]. Zhang et al. used a discrete whale swarm algorithm to solve HFSP with limited buffers [40]. Considering the machine energy consumption, Qin et al. proposed an improved IG to address the HFSP including energy consumption and blocking constraints [36].

From the literature above, it is evident that research on blocking constraints is still ongoing, and there are many practical applications for BHFSP, such as container trailer scheduling problems [41], train track scheduling [42], ship manufacturing [43], and concrete blocks [44]. Therefore, studying BHFSP has practical significance.

2.2. Iterated Greedy Algorithm

IG is widely used to solve FSSP because of its simple structure, few parameters, and high efficiency [9]. Thus, many scholars have proposed some improved IG algorithms to solve scheduling problems. Rodriguez et al. employed IG to address the FSSP of unrelated parallel machines [45]. Fernandez-Viagas et al. used the eight variants of IG based on some search-based heuristics to vary their population size and optimize the total delay criterion [46]. To minimize the makespan, Rubén Ruiz, Pan, and Naderi used an improved IG to optimize FSSP under the distributed environment [10]. The authors extended the destruction, reconstruction, and local search strategies to create a two-level IG based on mixed properties of the problem. For the distributed blocking FSSP (DBFSP), Chen et al. described a population iterative greedy (PBIG) based on the advantages of the crowd search method and iterative greedy algorithm [47]. Pan and Ruiz [48] first constructed the MILP model for the mixed no-idle flow shop problem and designed an efficient IG combining a speed-up neighborhood insertion strategy. Qin et al. presented a double level mutation IG (IGDLM) to optimize HFSP [49]. Missaoui and Ruiz [50] proposed a parameter-less IG without calibration to address HFSP with setup time and lead-time window restraints.

From the literature cited in this paper, i.e., [7,40,41,42,43,44,45,48], we know that the IGA has shown good performance among the metaheuristics for many scheduling problems, especially in the flow shop scheduling field. For example, (1) as mentioned in the literature [48], unlike other metaphor-based algorithms, IGA is a simple iterated search method with no complex structures, which is easy to be coded and understood. Therefore, it is available to be replicated and used for other related problems. (2) In addition, the latest literature [44] proposed a modified IGA, named IGDLM algorithm that used to solve the BHFSP. This work compares many advanced algorithms, and simulation results have proved that the IGDLM outperforms the existing five compared algorithms. (3) Referring to [45], the authors compared the IG algorithm with different strategies and proved that it is feasible to use the IG algorithm to solve the HFSP and results show that the IG series algorithms generally obtain good solutions. The advantages of the IG algorithm are attributed to the simplicity of the algorithm framework with few parameters, ease of integration, and good reinforcement and local convergence performance. Based on the above analyses, we finally selected the IG algorithm to solve the BHFSP considered in this paper.

Although the above studies have used the IG algorithm to solve the scheduling problem, they have also revealed its limitations. Specifically, the IG algorithm has a strong local perturbation ability, but correspondingly, it is easy to make the solution converge prematurely and fall into a local optimum. Additionally, from the existing literature, the IG algorithm only optimizes a single solution, leading to poor diversity of solutions. To better address the BHFSP problem, we design corresponding strategies to overcome these limitations. We consider using parallel optimization to simultaneously optimize two solutions and using a collaborative mechanism to interact between the two solutions, increasing their diversity. Due to the characteristics of the HFSP, there are different decoding methods available. Therefore, we incorporate a hybrid decoding strategy into the parallel framework. This framework includes a new reconstruction mechanism that combines forward and backward decoding strategies to increase the diversity of solutions. Additionally, we incorporate a swap-based local reinforcement strategy to enable a deeper exploration of local neighborhoods. The proposed strategies can decrease the computational time of the objective function and raise the diversity of solutions.

3. Problem Statement

BHFSP is described as follows: Each job within a set having $J$ jobs are processed at $S$ sequential stages according to the same sequence. For each stage $s \left(s=1,2,\cdots ,S\right)$, there exists $M_s$($M_s\ge 1$) identical parallel machines. Furthermore, there is at least one stage containing more than one identical parallel machine. We assume that there are no intermediate buffers between neighboring stages. The processing time of job $j$ at stage $s$ is denoted as $p_{j,s}$. Our optimization goal is to find a reasonable scheduling sequence with minimal makespan.

Typically, the following discussion of BHFSP is based on the following six hypotheses:

(1)

At time 0, all jobs can be processed and machines are free.

(2)

At any time, a machine can only process one job at a time, and a job cannot be processed by multiple machines at the same time.

(3)

All jobs are continuously processed without any interruptions.

(4)

Each job goes through all the processing stages in turn and is processed by only one machine at a stage.

(5)

Skipping a stage or ending early is not allowed.

(6)

No intermediate buffer exists in any neighboring stages. If all machines at the next stage are busy after a job is processed at the current machine, the finished job will be blocked until one machine at the downstream stage is free.

3.1. Mathematical Model

Objective:

$$Minimize{C}_{max}$$

(1)

Constraints:

$${\displaystyle \sum _{m=1}^{M_s}{y}_{j,s,m}}=1,\forall j\in \left\{1,2,\cdots ,J\right\},\forall s\in \left\{1,2,\cdots ,S\right\}$$

(2)

$$z_{j,j^{\prime },s}+z_{j^{\prime },j,s}\le 1,\forall j,j^{\prime }\in \left\{1,2,\cdots ,J\right\},j<j^{\prime },\forall s\in \left\{1,2,\cdots ,S\right\}$$

(3)

$$\begin{array}{ll}& z_{j,j^{\prime },s}+z_{j^{\prime },j,s}\ge y_{j,s,m}+y_{j^{\prime },s,m}-1,\forall j,j^{\prime }\in \left\{1,2,\cdots ,J\right\},j<j^{\prime },\\ & \forall s\in \left\{1,2,\cdots ,S\right\},\forall m\in \left\{1,2,\cdots ,M_s\right\}\end{array}$$

(4)

$$C_{j,s}\ge p_{j,s},\forall j\in \left\{1,2,\cdots ,J\right\},\forall s\in \left\{1,2,\cdots ,S\right\}$$

(5)

$$\begin{array}{ll}& C_{j^{\prime },s}\ge D_{j,s}+p_{j^{\prime },s}+(y_{j,s,m}+y_{j^{\prime },s,m}+z_{j,j^{\prime }s}-3)\cdot U,\forall j,j^{\prime }\in \left\{1,2,\cdots ,J\right\},j\ne j^{\prime },\\ & \forall s\in \left\{1,2,\cdots ,S\right\},\forall m\in \left\{1,2,\cdots ,M_s\right\}\end{array}$$

(6)

$$C_{j,s+1}=D_{j,s}+p_{j,s+1},\forall j\in \left\{1,2,\cdots ,J\right\},\forall s\in \left\{1,2,\cdots ,S-1\right\}$$

(7)

$$D_{j,s}\ge C_{j,s},\forall j\in \left\{1,2,\cdots ,J\right\},\forall s\in \left\{1,2,\cdots ,S\right\}$$

(8)

$$C_{max}\ge D_{j,S},\forall j\in \left\{1,2,\cdots ,J\right\}$$

(9)

Constraint (1) is the optimized makespan. Constraint (2) guarantees a job is processed on only one machine of each stage. Constraint (3) refers to that $z_{j,j^{\prime },s}$ and $z_{j,j^{\prime },s}$ cannot equal 1 at the same time. Constraint (4) enforces that if jobs $j$ and j’ can be processed on the same machine at stage $s$, one of $z_{j,j^{\prime },s}$ and $z_{j,j^{\prime },s}$ must be equal $1$ and the other equal $0$. Constraint (5) guarantees that the completion time of job $j$ at stage $s$ is larger than or equal to that of the processing time of job $j$ at stage $s$. For job $j$ and job j’, if job $j$ is processed on the same machine before j’ at stage $s$, the completion time of job j’ at stage $s$ must be not less than the departure time of job $j$ at stage $s$ plus $p_{j^{\prime },s}$, ensured by Constraint (6). Constraint (7) defines that the completion time of a job at a stage is not less than the processing time at the same stage plus its departure time at the previous one. Constraint (8) ensures that at each stage, the departure time of a job is larger than or equal to its completion time. Constraint (9) guarantees that the makespan is equal to or larger than the departure time of all jobs at the last stage.

3.2. Example Instance

Consider an example with J = 6, S = 2, M₁ = 2 and M₂ = 2.

Table 2. Processing times of jobs at stage 1 and stage 2.

Job	Stage 1	Stage 2
1	1	3
2	2	4
3	2	4
4	3	1
5	2	3
6	1	2

lists all p_j,s. One possible solution of the example is z_{1, 3, 1} = 1, z_{1, 5, 1} = 1, z_{3, 5, 1} = 1, z_{2, 4, 1} = 1, z_{2, 6, 1} = 1, z_{4, 6, 1} = 1, z_{1, 3, 2} = 1, z_{1, 4, 2} = 1, z_{1, 5, 2} = 1, z_{3, 4, 2} = 1, z_{3, 6, 2} = 1, z_{4, 6, 2} = 1, z_{2, 5, 2} = 1, y_{1, 1, 1} = 1, y_{3, 1, 1} = 1, y_{5, 1, 1} = 1, y_{2, 1, 2} = 1, y_{4, 1, 2} = 1, y_{6, 1, 2} = 1, y_{1, 2, 1} = 1, y_{3, 2, 1} = 1, y_{4, 2, 1} = 1, y_{6, 2, 1} = 1, y_{2, 2, 2} = 1. A scheduling Gantt chart of the given example is displayed in Figure 1.

In Figure 1, the makespan of above example is 11. At moment 3, job 3 has been finished on machine 1 at stage 1. However, job 3 must be blocked on machine 1 until moment 4 because all machines in the next stage are busy. Similarly, at moment 5, job 4 remained on machine 2 at stage 1 until moment 8.

4. VIG Algorithm for BHFSP

Ruiz and Stützle first proposed an IG algorithm for solving the FSP [9]. The framework of the basic IG is shown in Algorithm 1 and consists of four phases: initialization phase, destruction and reconstruction (DR) phase, local search, and acceptance criteria. First, a high-quality solution is obtained during the initialization phase. Second, for the destruction operation, we select some elements at random from the current solution $\pi$ and delete them. All the deleted elements are put into ${\pi }_d$, and the rest elements forms ${\pi }_r$. For the reconstruction operation, each element is removed one by one from ${\pi }_d$ and greedily reinserted into ${\pi }_r$ until a complete solution is obtained. Next, a local reinforcement approach is adopted to further enhance the algorithm’s performance. Finally, the solution is updated by using the acceptance criteria.

Algorithm 1. Basic IG algorithm

01: Generate an initial solution ${\pi }_0$

02: $\mathbf{\pi }$ = Local Search (${\pi }_0$)

03: while (not meet termination criteria) do

04:   (${\pi }_d$, ${\pi }_r$) = Destruction ($\pi$)

05:   $\pi$′ = Reconstruction (${\pi }_d$, ${\pi }_r$)

06:   π″ = Local Search (π′)

07:   π = AcceptanceCriterion (π″, π0)

08: end while

For BHFSP, two questions must be considered simultaneously: how to assign a job to a particular machine at each stage and how to determine the sequence of jobs to be processed at each machine. For the basic IG, only one solution is continually optimized during the iteration process, which reduces the diversity of solution. Therefore, considering the characteristics of BHFSP and the flaw of the basic IG, we proposed a variant IG (VIG). In the proposed VIG, two decoding strategies, i.e., forward decoding, and backward decoding, are devised to solve the machine allocation issue. To enhance the diversity of VIG, we devise a parallel mechanism based on a hybrid decoding strategy. This allows us to obtain two optimized solutions, and their interaction is carried out by crossover operator. The above parallel and cooperation mechanism can increase the opportunity of obtaining a good solution to some extent.

Algorithm 2 describes the proposed VIG algorithm framework. First, two initial solutions are generated by using NEH [17] and MME [18] (see line 1 in Algorithm 2). Then, within the while loop, the DR_LS_SA strategy (see lines 6–7 in Algorithm 2) leads to the parallel evolution of the two solutions. As can be seen from the name of the DR_LS_SA function, this part includes DR, local search, and SA strategies. Algorithm 3 describes these three parts in detail. The DR strategy (see line 1 in Algorithm 3) and local search strategy (see line 5 in Algorithm 3) based on two decoding methods are proposed to improve the quality of the solutions and increase their diversity. If only the improved solution is accepted, the algorithm may converge prematurely and lose diversity. The diversity of solutions is enhanced in our algorithms by utilizing SA. If the quality of the currently generated solution is worse than the quality of the original solution, this research still chooses to accept the current solution with a certain probability (see line 12 in Algorithm 3), instead of directly discarding it, where $T={\displaystyle \sum _{j=1}^J}{\displaystyle \sum _{S=1}^S}{p}_{j,s}/(10\times J\times S)\times \tau$, where J is the number of jobs, S is the number of stages, p_j,s is the processing time of job j at stage s, and τ (_τ∈(0,1)) is a temperature parameter to be adjusted. To avoid the VIG from being trapped in a local optimum, we use a cooperation mechanism based on crossover operator to interact with two solutions, which further enhances the diversity of solutions (see lines 14–17 in Algorithm 2). The parameter $ward$ in Algorithm 3 has two values, 0 and 1, which represent forward decoding and backward decoding, respectively (see lines 6–7 in Algorithm 2). In Algorithm 2, the number of times the best solution has not been improved is represented by parameter $fail\_count$. The parameter $crossover\_threshold$ represents the value of the condition threshold. When $fail\_count$ is equal to $crossover\_threshold$, VIG implements a collaborative mechanism based on crossover operation to increase the diversity of the solution. To help readers better understand, Figure 2 illustrates the specific process of VIG, which includes DR, local search, and cooperation mechanisms.

Algorithm 2. The framework of the VIG algorithm

Input: ${\pi }_1$ and ${\pi }_2$ are two empty scheduling sequences, d is the number of removed and reinserted jobs in DR

01: ${\pi }_1=NEH({\pi }_1)$, ${\pi }_2=MME({\pi }_2)$

02: ${\pi }^{best1}={\pi }_1$, ${\pi }^{temp1}={\pi }_1$, ${\pi }^{best2}={\pi }_2$, ${\pi }^{temp2}={\pi }_2$

03: $fail\_count$ = 0   %%$fail\_count$ is a counter

04: ${\pi }^{best}$ = $\min ({\pi }^{best1},{\pi }^{best2})$

05: while (termination criterion is not satisfied) do

06:   ${\pi }^{temp1}$, ${\pi }^{best1}$, ${\pi }_1$ = $DR\_LS\_SA({\pi }^{temp1}, {\pi }^{best1}, {\pi }_1, d, 0)$ %%including DR, local search, and SA

07:   ${\pi }^{temp2}$, ${\pi }^{best2}$, ${\pi }_2=DR\_LS\_SA({\pi }^{temp2}, {\pi }^{best2}, {\pi }_2, d, 1)$

08:   if (${\pi }^{best1}$ or ${\pi }^{best2}$ is better than ${\pi }^{best}$)

09:      ${\pi }^{best}$ = $\min ({\pi }^{best1},{\pi }^{best2})$

10:      $fail\_count$ = 0

11:   else

12:      $fail\_count$++

13:   end if

14:   if ($fail\_count$ = $crossover\_threshold$)

15:      ${\pi }^{temp1}$, ${\pi }^{temp2}$ = $Crossover({\pi }^{temp1}, {\pi }^{temp2})$  %% Cooperative mechanism

16:      $fail\_count$ = 0

17:   end if

18: end while

Output: ${\pi }^{best}$

Algorithm 3. DR_LS_SA (${\pi }^{temp}$, ${\pi }^{best}$, $\pi$, $d$, $ward$)

Input: ${\pi }^{temp}$, ${\pi }^{best}$, $\pi$, $d$, $ward$

01: ${\pi }^{temp}=Destruction\_\mathrm{Re}construction\left({\pi }^{temp}, d,ward\right)$

02: if (${\pi }^{temp}$ is better than ${\pi }^{best}$)

03:   ${\pi }^{best}$ = ${\pi }^{temp}$

04: end if

05: ${\pi }^{temp}$ = $LocalSearchStrategy({\pi }^{temp},ward)$     %% based on swap strategy

06: if (${\pi }^{temp}$ is better than $\pi$)

07:   $\pi ={\pi }^{temp}$

08:   if (${\pi }^{temp}$ is better than ${\pi }^{best}$)

09:       ${\pi }^{best}={\pi }^{temp}$

10:   end if

11: else         %% SA acceptance criterion

12:   if ($rand()\le \exp (-(C_{max}({\pi }^{temp})-C_{max}(\pi ))/T)$)

13:       $\pi ={\pi }^{temp}$

14:   else

15:      ${\pi }^{temp}=\pi$

16:   end if

17: end if

Output: ${\pi }^{temp}$, ${\pi }^{best}$, $\pi$

4.1. Encoding and Decoding Scheme

There are two key issues that need to be addressed before designing an algorithm for BHFSP: encoding and decoding. Given the discrete nature of the problem, the job sequence corresponding to a solution is represented using a discrete integer encoding. For the decoding issue, its purpose is to obtain the real scheduling and evaluate the makespan. The regular FSSPs are known to be reversible. That is if the jobs go through the flow shop in the opposite direction and in the reverse process, the makespan does not change [24]. However, for BHFSP, due to there being parallel machines in some stages, it does not have the above property. Thus, different makespan values can be obtained for a given job sequence using forward and backward decoding methods. By different decoding strategies, we can select the minimal objective function value as the final makespan. Multiple decoding strategies can assist the algorithm to find the optimal value. Based on this, we propose a hybrid decoding strategy including forward and backward decoding. Suppose there are J jobs, and each job goes through S stages for processing. The processing sequence is [1, 2, …, J]. [j] represents the index of the jth job. In forward decoding, ${fc}_{\left[j\right],s}$ represents the completion time of the job and ${fmt}_{s,m}$ is denoted as the idle time of the machine m at stage s. m^* represents the machine with the earliest idle time at stage s. ${fc}_{\left[j\right],s}$ is calculated according to Equations (10)–(14). Equation (15) represents the makespan of the forward calculation.

$${fc}_{\left[j\right],0} = 0, j = 1, 2, \dots ,J$$

(10)

$$fm{t}_{s,m}=0,s=1,2,\cdots ,S,m=1,2,\cdots ,M_s$$

(11)

$$m^{*}=\underset{m=1,2,\cdots ,M_s}{\mathit{argmin}}\left\{fm{t}_{s,m}\right\},s=1,2,\cdots ,S$$

(12)

$$f{c}_{\left[j\right],s}=\mathit{max}\left\{fm{t}_{s,m^{*}},f{c}_{\left[j\right],s-1}\right\}+p_{j,s},j=1,2,\cdots ,J,s=1,2,\cdots ,S$$

(13)

$$fm{t}_{s,m^{*}}=\left\{\begin{array}{c}f{c}_{\left[j\right],s+1}-p_{\left[j\right],s+1},s=1,2,\cdots ,S-1\hfill \\ f{c}_{\left[j\right],s},s=S\hfill \end{array}\right.$$

(14)

$$C_{\mathit{max}}={\mathit{maxf}}_{\left[j\right],s},j=1,2,\cdots ,J,s=S$$

(15)

In the backward decoding, ${bc}_{\left[j\right],s}$ represents the backward completion time of the job and ${bmt}_{sm}$ is denoted as idle time of the machine m at stage s during the backward calculation. m^* represents the machine with the earliest idle time at stage s. ${bc}_{\left[j\right],s}$ is calculated according to Equations (16)–(20). Equation (21) is of the makespan obtained by the backward calculation.

$$b{c}_{\left[j\right],S+1}=0,j=J,J-1,\cdots ,1$$

(16)

$$bm{t}_{s,m}=0,s=S,S-1,\cdots ,1,m=M_s,M_s-1,\cdots ,1$$

(17)

$$m^{*}=\underset{m=M_{s,M,-1},\cdots ,1}{\mathit{argmin}}\left\{bm{t}_{s,m}\right\},s=S,S-1,\cdots ,1$$

(18)

$$b{c}_{\left[j\right],s}=\mathit{max}\left\{bm{t}_{s,m^{*}},b{c}_{\left[j\right],s+1}\right\}+p_{j,s},j=J,J-1,\cdots ,1,s=S,S-1,\cdots ,1$$

(19)

$$bm{t}_{s,m^{*}}=\left\{\begin{array}{c}b{c}_{\left[j\right],s-1}-p_{\left[j\right],s-1},s=S,S-1,\cdots ,2\hfill \\ b{c}_{\left[j\right],s},s=1\hfill \end{array}\right.$$

(20)

$$C_{\mathit{max}}=maxb{c}_{\left[j\right],s},j=1,2,\cdots ,J,s=1$$

(21)

In the following, we illustrate the forward and backward decoding methods by an example in which there are 3 stages and 4 jobs. There are two identical parallel machines at stage 1 and stage 2, and one machine at stage 3. Suppose that a particular job sequence π = (1, 2, 3, 4), and the processing time of each job at each stage is as follows.

$$p_{j,s}=\left[\begin{array}{ccc}2& 2& 1\\ 1& 1& 2\\ 2& 1& 2\\ 4& 5& 1\end{array}\right]$$

4.1.1. Forward Decoding Method

Forward decoding means arranging the first job in the sequence to each stage, then the second job, and so forth, until the last job. At each stage, the jobs are scheduled to the first earliest available machine. After a job is processed on the current machine, if no machine is available at the next stage, the job is blocked on the current machine until a machine is available at the next stage. For a given job sequence $\pi =(1,2,3,4)$ in the above example, we decode it according to the forward encoding method, and the procedure is as follows:

(1)

First schedule job 1. Job 1 is arranged to stage 1, stage 2, and stage 3 according to the process sequence. As described above, at each stage we select the first earliest available machine for job 1. Figure 3a shows the Gantt chart after arranging job 1.

(2)

Then job 2 is arranged to each stage according to the scheduling process of job 1. Note that on the second machine at the second stage, job 2 is blocked on the current machine until moment 4. Figure 3b shows the Gantt chart after job 2 is scheduled.

(3)

Job 3 and job 4 are scheduled by using the same method as job 1 and job 2, the Gantt charts that job 3 and job 4 have been scheduled are shown in Figure 3c,d, respectively. We finally obtain real scheduling with a makespan that is equal to 12.

4.1.2. Backward Decoding Method

For a given sequence of jobs, real scheduling can also be obtained by traversing the jobs in the opposite order, that is, the last job is considered first. The jobs are assigned to the first available machine in a backward manner from the last stage to the first stage. Considering the above example, we arrange the jobs by the backward strategy as follows.

(1)

First arrange job 4. Job 4 is arranged to stage 3, stage 2, and stage 1 according to the opposite process sequence. At each stage, we select the earliest available machine for job 4 in a backward manner. Figure 4a shows the Gantt chart for arranging job 4 by using the backward decoding method.

(2)

Then consider job 3. In the same way as job 4 is scheduled, job 2 is arranged to each stage according to the opposite process sequence. Figure 4b shows the Gantt chart that job 2 is scheduled by using the backward decoding method.

(3)

Job 2 and job 1 are scheduled by using the same method as job 4 and job 3. Note that blocking may also occur during the backward decoding process. Figure 4c,d give the Gantt charts that job 2 and job 1 have been scheduled by using the backward decoding method, respectively. Finally, we obtain real scheduling whose makespan is equal to 10.

4.2. The Initialization Strategy

The performance of the IG algorithm is strongly impacted by the initialization strategy. Many scholars have proven that NEH is an efficient initialization method for discrete scheduling problems [17]. MME has a good performance in solving the BFSP [18]. Considering the blocking characteristic of BHFSP, both of the above two heuristics are used in this paper as the initialization strategies to solve BHFSP to improve the diversity of VIG.

In our paper, we attempt to enhance the diversity of VIG by generating multiple solutions. Therefore, we use different initialization strategies to solve BHFSP: NEH with a forward decoding strategy to calculate the makespan of job sequences and MME with a backward decoding strategy to calculate the makespan. At this time, we can guarantee that two high-quality initial solutions are obtained. In the next loop, we can optimize the two initial solutions in different directions, which may broaden the search space and increase the diversity of solutions.

4.3. Destruction and Construction

In traditional IG algorithms, the destruction and reconstruction operators can strongly disturb the current solution, which increases the diversity of solution. In the destruction phase, we randomly delete d jobs from ${\pi }^{temp}$ and put them into ${\pi }^{remove}$. The remaining jobs compose of ${\pi }^{temp}$ (${\pi }^{temp}={\pi }^{temp}\backslash {\pi }^{remove}$) (see lines 2–6). In the reconstruction phase, we extracted job ${\pi }_j^{remove}$ from ${\pi }^{remove}$, one by one, and then try to insert them into all positions of ${\pi }^{temp}$. We adopt forward and backward decoding strategies to calculate the makespan, respectively. If $ward=0$, forward decoding strategy is adopted to evaluate the objective function. If $ward=1$, backward decoding strategy is adopted (see lines 11–15). Repeated the above process until all the jobs in sequence ${\pi }^{remove}$ have been removed, and find the position with minimal $C_{\max }$. Algorithm 4 shows the pseudocode of the destruction and reconstruction strategy, $Destruction\_\mathrm{Re}construction\left({\pi }^{temp}, d, ward\right)$, which d is the number of jobs to be removed from ${\pi }^{temp}$, and $ward$ is the parameter that decides the decoding strategy.

Algorithm 4.  $Destruction\_\mathrm{Re}construction\left({\pi }^{temp}, d, ward\right)$

Input: ${\pi }^{temp}$, parameter $d$, $ward$

01: ${\pi }^{remove}=\varnothing$, ${\pi }^{temp’}$ = ${\pi }^{temp}$

02: while (${\pi }^{remove}.size$ < $d$)    %% Destruction

03:   $pt=rand()\%J+1$

04:   Extract ${\pi }_{pt}^{temp’}$ from ${\pi }^{temp’}$ and put it into ${\pi }^{remove}$

05:   ${\pi }^{temp’}={\pi }^{temp’}\backslash {\pi }_{pt}^{temp’}$

06: end while

07: for $j$ =1 to $d$    %% reconstruction

08:   $pos$ = 0

09:   while ($pos\le {\pi }^{temp}.size$)

10:       Insert ${\pi }_j^{remove}$ into position $pos$ of ${\pi }^{temp’}$

11:       if ($ward$ = 0)

12:          Calculate $C_{\max }$ using forward decoding strategy

13:       else if ($ward$ = 1)

14:          Calculate $C_{\max }$ using backward decoding strategy

15:       end if

16:       $pos$++

17:   end while

18:   Select the best position $pos$ with minimal $C_{\max }$ and insert ${\pi }_j^{remove}$ to position $pos$ of ${\pi }^{temp’}$

19: end for

Output: ${\pi }^{temp’}$

4.4. Local Search Strategy

Following the destruction and reconstruction phases, it is common to perform a local search operation on the solution to improve the quality of the current solution. The local search strategy in the traditional IG algorithm usually uses the insert operator. Assuming that there are $J$ jobs, each job needs to be inserted into $J$ positions, so the time complexity of using the insertion operator is $O(J^2)$. However, by replacing the insert operator with the swap operator, the time complexity can be reduced to $O(J)$. To reduce time complexity and explore local neighborhoods more deeply, we propose a swap-based local reinforcement strategy.

In Algorithm 5, function $swap({\pi }_k^{temp},{\pi }_{pt}^{temp})$ refers to exchange job ${\pi }_k^{temp}$ and ${\pi }_{pt}^{temp}$, and obtain a new sequence ${\pi }^{temp’}$. $Forward\_Fit({\pi }^{temp’})$ in line 6 means that the ${\pi }^{temp’}$ adopts the forward decoding strategy to calculate the makespan, $C_{\max ’}$. Similarly, $Backward\_Fit({\pi }^{temp’})$ in line 8 represents that the ${\pi }^{temp’}$ uses backward decoding to calculate $C_{\max ’}$. If the makespan of ${\pi }^{temp’}$, $C_{\max ’}$, is less than the makespan of ${\pi }^{temp}$, $C_{\max }$, then ${\pi }^{temp}$ is updated with ${\pi }^{temp’}$; otherwise, ${\pi }^{temp’}$ is updated with ${\pi }^{temp}$.

Algorithm 5.  $LocalSearchStrategy({\pi }^{temp},ward)$

Input:  ${\pi }^{temp}$, $C_{\max }$ is the target value of ${\pi }^{temp}$, $ward$

01: $k$ = 0, ${\pi }^{temp’}$ = ${\pi }^{temp}$

02: while ($k<{\pi }^{temp}.size$)

03:   for $pt$ = $k$ + 1 to $J$

04:      ${\pi }^{temp’}=swap({\pi }_k^{temp},{\pi }_{pt}^{temp})$

05:      if ($ward$ = 0)

06:         $C_{\max ’}=Forward\_Fit({\pi }^{temp’})$

07:      else if ($ward$ = 1)

08:         $C_{\max ’}=Backward\_Fit({\pi }^{temp’})$

09:      end if

10:      if ($C_{\max ’}$ < $C_{\max }$)

11:         ${\pi }^{temp}$ = ${\pi }^{temp’}$

12:      else

13:         ${\pi }^{temp’}$ = ${\pi }^{temp}$

14:      end if

15:   end for

16:  $k$++

17: end while

Output: ${\pi }^{temp’}$

5. Simulation Experiments and Analysis

All the algorithms are coded in Visual Studio 2019 using C++. The same library functions are employed to make fair comparisons. All the instances are executed five independent replications on the same PC with an Intel Core i7 Pentium processor @ 3.60 GHz and 32 GB RAM, whose operating system is Windows 10 X64. For all the algorithms, an elapsed CPU time is adopted as the termination criterion.

5.1. Test Data and Performance Metric

To demonstrate the effectiveness of the proposed algorithm, we have conducted extensive simulation experiments. We use the methods of generating test instances provided by the literature [49] to obtain the test data. That is, the processing time of each job on each machine is obtained randomly from the interval [1, 99]. The number of machines at each stage is randomly generated from the range [1,5]. $J$ belongs to {20, 40, 60, 80, 100}, and $S$ belongs to {5, 10}. This will result in 10 ($\left|J\right|\times \left|S\right|$) different combinations, in which each combination has 10 test instances. Thus, 100 test instances are generated. To ensure fairness, each instance is independently run 30 times, and all algorithms set the same CPU runtime as the termination criteria, denoted as $TimeLimit=J\times S\times CPU$ (millisecond), in which $CPU$ is set as 10 and 15, respectively. The source code in this paper can be found on GitHub (https://github.com/nideluckily/VIG.git (accessed on 17 May 2023)).

All performance comparisons are conducted using the relative percentage increase (RPI) as shown in Equation (22).

$$RPI=\frac{1}{10}\sum _{ins\mathit{tan}ce=1}^{10}\frac{c_i-c_{min}}{c_{min}}\times 100$$

(22)

where, for each test instance, $c_i$ is the average of makespan obtained by the i^th algorithm that independently runs 30 times. $c_{min}$ is the best makespan found by all seven algorithms that independently run 30 times. The average RPI (ARPI) of 10 different combinations (scales) is calculated.

5.2. Validation of MILP Model

The MILP model mentioned in Section 2 will be evaluated and nine small-scale instances are randomly selected to demonstrate its correctness by using a Gurobi solver [38]. The maximum termination criteria of the Gurobi solver and VIG algorithm are set to 3600 s and $TimeLimit=J\times S\times CPU$ (millisecond), respectively. Each instance of VIG algorithm runs independently 30 times, and the average value of the makespan of 20 times is obtained as the final objective value.

Table 3. Makespan values for the MILP Model and the VIG algorithm.

J_S	MILP		VIG
	Makespan	Time (s)	Makespan	Time (s)
8_2	74	2.28	74	0.17
8_3	154	1.13	158	0.25
8_4	185	5.66	186	0.33
13_2	194	935.10	196	0.27
13_3	193	3600	196	0.39
13_4	247	3600	241	0.53
18_2	243	3600	243	0.38
18_3	298	3600	296	0.55
18_4	341	3600	328	0.73

Best values are indicated in bold.

shows the makespan and runtime obtained by the MILP model and VIG.

In Table 3, the MILP model performs better for small test instances, such as 8_2, 8_3, 8_4, 13_3, and 18_2 instances. However, as instance sizes increase, the performance of MILP gradually decreases compared to VIG, such as 13_4, 18_3, and 18_4 test instances. Table 3 also reveals that the time taken for MILP to solve the problem is much higher than that of VIG. Furthermore, for large-scale instances, the MILP model is difficult to provide a good solution in a short time. In practical production, it is necessary to find an approximate optimal solution within a reasonable time. In contrast, the proposed VIG is more suitable for practical applications.

5.3. Calibration of Parameters

In the IG algorithm, different parameter configurations may have an impact on the final results. In this subsection, we have calibrated two key parameters, d and $crossover\_threshold$, using Taguchi experimental method. For parameter d, it plays an important role in balancing the local and global search abilities of an algorithm and coordinating its diversity. A too large d may increase the perturbation for the current sequence and devote more time. However, a too small d will result in a small perturbation and potentially insufficient exploration of the solution. For parameter $crossover\_threshold$, it is used to interact with two solutions obtained by DR and local search strategies. The cooperation strategy based on crossover operator can increase the diversity with a certain probability. In other words, if the number of times that the makespan is not minimized reaches the threshold $crossover\_threshold$, the algorithm may converge prematurely. Thus, the value of $crossover\_threshold$ is related to the scale of test instances. In this paper, the calculation formula of $crossover\_threshold$ is α/J, where α = {1600, 1800, 2000, 2200, 2400}. Thus, the calibration of $crossover\_threshold$ in this paper is the calibration of α.

In the calibration of parameters, preliminary experiments are conducted under the terminal condition $TimeLimit=J\times S\times CPU$ (millisecond). Each parameter is set to have five factor levels, such as d = {2, 3, 4, 5, 6} and α = {1600, 1800, 2000, 2200, 2400}, respectively. We obtained 25 different configurations using the orthogonal table shown in

Table 4. Orthogonal table and response values.

Combination	Parameters		ARPI
	d	α
1	2	1600	0.747758
2	2	1800	0.720745
3	2	2000	0.729445
4	2	2200	0.739731
5	2	2400	0.697866
6	3	1600	0.551798
7	3	1800	0.556757
8	3	2000	0.555334
9	3	2200	0.582645
10	3	2400	0.567974
11	4	1600	0.60351
12	4	1800	0.587508
13	4	2000	0.581717
14	4	2200	0.524173
15	4	2400	0.57228
16	5	1600	0.631847
17	5	1800	0.641343
18	5	2000	0.655224
19	5	2200	0.64794
20	5	2400	0.639212
21	6	1600	0.734407
22	6	1800	0.691219
23	6	2000	0.719173
24	6	2200	0.669324
25	6	2400	0.696156

. To ensure fair, four different instances, such as 20 × 5, 60 × 10, 80 × 5, and 100 × 10, are randomly selected. The mean RPI values of different combinations are integrated. Based on the yielded RPI, the trend of the level of the factor is plotted in Figure 5.

Figure 5 shows the Taguchi analysis of the ARPI for each parameter. ARPI value is the smallest when d = 3, suggesting that VIG has the best performance with this parameter setting. Then as d becomes larger, the value of RPI gradually becomes larger as well. This is because as the value of d increasing, the number of the reinsertion operator used in the DR strategy also increases, which takes more time. As a result, the number of iterations for VIG is reduced, and the algorithm loses opportunities to search for potential solutions. Parameter α has little influence on VIG. When α = 2200, VIG demonstrates dominance. Based on the above experimental analysis, we can conclude that d has a significant impact on VIG, while α has only a minor impact. Therefore, we set the parameters as d = 3 and α = 2200.

Table 5. The ARPI response values of each parameter.

Level	d	α
1	0.7271	0.6539
2	0.5629	0.6395
3	0.5738	0.6482
4	0.6431	0.6328
5	0.7021	0.6347
Delta	0.1642	0.0211
Rank	1	2

reports the significance level of parameter d and α in terms of the ARPI value of all scale instances, where delta measures the magnitude of the effect by calculating the difference between the maximum and minimum ARPI values among the five levels. Delta is larger or the rank indicator is smaller, suggesting that the parameter has an obvious influence. Thus, from Table 5, d and α have great and small impacts on the algorithm, respectively.

5.4. Evaluating Different Strategies

This section will evaluate and analyze the algorithm components. Two sets of experiments, including comparisons of different decoding strategies and comparisons of local search strategies, are performed to verify their effectiveness.

As mentioned in Section 4, we know that for a given sequence of jobs, the objective values calculated by forward decoding and backward decoding, respectively, may be different [24]. To obtain the minimal makespan, we adopted a hybrid decoding strategy, which combines forward decoding and backward decoding. To verify the superiority of our hybrid decoding strategy, we tested the performance of VIG with only backward decoding, VIG with only forward decoding, and VIG with hybrid decoding. The three algorithms were run under the same experimental environment. For each compared strategy, we adopted 100 test instances, each one ran independently 30 times, and the ARPI values are shown in Figure 6. In Figure 6, the hybrid decoding strategy combining forward and backward is superior to the single decoding strategy. The reason may be that different decoding strategies can obtain different makespans, and multiple decoding strategies provide more opportunities to obtain minimal makespans than single decoding strategy. Therefore, the hybrid decoding strategy is suited for solving BHFSP.

In traditional IG algorithms, the insertion operator is often considered to disturb the current solution. Local search using the insertion operator typically takes more time than the one based on the swap operator. Therefore, we adopted a swap-based local search strategy instead of the insertion operator. To verify its effectiveness, the strategies with the insertion operator and with the swap operator, respectively, have been conducted under the terminal condition $J\times S\times 10$ and ran five times independently on 100 instances. From Figure 7, we observed that the swap-based operator is obviously more effective than the insertion operator. The reason may be that the time complexity of the former is lower than that of the latter. Thus, in the same terminal time, the number of iterations of the algorithm using a swap operator is much more than that of an insertion operator, resulting that VIG is enabled to obtain more possible approximate solutions or explore more neighborhoods. Therefore, the swap-based local search can enhance the performance of the algorithm, which can effectively explore undiscovered neighborhoods and search for more solutions with high quality.

5.5. Performance Evaluation of Comparative Algorithms

To analyze the capability of VIG and prove its effectiveness, we compared VIG with six algorithms in this section. The comparison algorithms include four population-based intelligence optimization methods, such as GA [51], DABC [24], EMBO [29], and discrete particle swarm optimization algorithm (DPSO) [52], and two improved IG algorithms, i.e., IGTALL [2] and double level mutation iterated greedy (IGDLM) [49]. GA is a metaheuristic algorithm that is influenced by natural selection and generates new candidate solutions by using operators such as crossover and mutation. DABC is a classical swarm intelligence algorithm that uses heuristics to generate the initial population and then optimizes the solution through three stages: employed bees, onlooker bees, and scout bees. EMBO uses two competitive mechanisms to improve the probability of finding a better solution at the front end of the flock. DPSO combines the variable neighborhood search (VNS) algorithm with the particle swarm optimization algorithm to reduce the computation time and obtain the optimal solution. IGTALL adds a local search strategy after the destruction phase to improve the quality of some solutions and further expand the ability of the algorithm to explore the solution space. IGDLD reduces the computation time and helps the algorithm explore the solution space more deeply by using two mutation operations. The above six comparison algorithms are all proposed for HFSP and have been proven to have excellent performance. Thus, it is equitable to consider them as contrastive algorithms. In addition, to be fair, we modified them appropriately to adapt our problem. To be fair, the parameters of all compared algorithms were set to the values recommended by the original literature and shown in

Table 6. Parameters of the comparison algorithms.

Algorithm	Population Size	Number of Destruction Jobs	Crossover Rate	Variation Rate	Constant Factor	Temperature Coefficient
	Psize	d	Pc	Pr	α	T
DABC	20	/	/	/	30	/
DPSO	100	/	/	/	200	/
EMBO	25	/	/	/	10	/
GA	100	/	0.7	0.1	4	0.85
IGDLM	/	4	/	0.3	/	0.5
IGTALL	/	3	/	/	10	0.5
VIG	/	3	/	/	/	0.5

. All algorithms were set up in the same experimental environment to run and use the same termination criterion $TimeLimit=J\times S\times CPU$ for 100 test instances. Each instance ran independently 30 times.

Table 7. The values of average makespan and RPI for all comparison algorithms when CPU = 10.

J × S	VIG		IGTALL		IGDLM		GA		EMBO		DPSO		DABC
	AVG	RPI	AVG	RPI	AVG	RPI	AVG	RPI	AVG	RPI	AVG	RPI	AVG	RPI
20 × 5	794	0.08	798	0.72	796	0.37	810	2.41	795	0.18	796	0.33	796	0.47
20 × 10	1350	0.11	1357	0.61	1351	0.20	1389	3.04	1352	0.27	1350	0.14	1355	0.52
40 × 5	1363	0.31	1386	2.36	1380	1.83	1403	3.82	1376	1.48	1393	2.99	1393	2.97
40 × 10	2215	0.13	2235	1.01	2224	0.52	2271	2.66	2229	0.74	2242	1.27	2255	1.86
60 × 5	2761	0	2762	0.03	2761	0.01	2770	0.35	2762	0.04	2761	0.02	2764	0.14
60 × 10	3175	0.21	3200	1.13	3192	0.87	3221	1.80	3191	0.81	3225	2.00	3231	2.09
80 × 5	3400	0.16	3416	1.11	3408	0.63	3427	1.50	3409	0.61	3430	1.89	3435	1.90
80 × 10	4272	0.05	4286	0.36	4280	0.22	4321	1.17	4283	0.30	4332	1.39	4353	1.89
100 × 5	3904	0.08	3917	0.88	3911	0.50	3925	1.20	3913	0.58	3932	1.67	3934	1.69
100 × 10	5490	0.15	5526	0.81	5516	0.62	5549	1.22	5504	0.41	5667	3.37	5714	4.24
mean	2872.4	0.13	2888.3	0.92	2881.9	0.60	2908.6	1.87	2881.4	0.58	2913	1.62	2923	1.91

Best values are indicated in bold.

and

Table 8. The values of average makespan and RPI for all comparison algorithms when CPU = 15.

J × S	VIG		IGTALL		IGDLM		GA		EMBO		DPSO		DABC
	AVG	RPI	AVG	RPI	AVG	RPI	AVG	RPI	AVG	RPI	AVG	RPI	AVG	RPI
20 × 5	794	0.07	798	0.67	796	0.34	811	2.62	794	0.16	795	0.31	797	0.53
20 × 10	1349	0.08	1356	0.60	1351	0.16	1387	2.90	1352	0.26	1350	0.10	1356	0.55
40 × 5	1363	0.31	1385	2.30	1380	1.84	1401	3.71	1376	1.43	1392	2.96	1393	2.98
40 × 10	2214	0.11	2233	0.93	2224	0.50	2274	2.79	2229	0.74	2240	1.21	2256	1.87
60 × 5	2761	0.00	2762	0.02	2761	0.00	2771	0.39	2762	0.03	2761	0.02	2764	0.12
60 × 10	3175	0.17	3198	1.07	3190	0.79	3224	1.86	3190	0.75	3224	1.94	3229	2.01
80 × 5	3400	0.10	3415	1.05	3408	0.63	3428	1.58	3409	0.60	3429	1.83	3434	1.83
80 × 10	4271	0.02	4285	0.35	4279	0.21	4317	1.08	4283	0.29	4330	1.33	4350	1.81
100 × 5	3904	0.10	3916	0.85	3910	0.49	3926	1.21	3913	0.59	3931	1.64	3934	1.68
100 × 10	5489	0.12	5525	0.79	5515	0.59	5553	1.29	5505	0.42	5662	3.28	5712	4.19
mean	2872	0.11	2887.3	0.86	2881.4	0.56	2909.2	1.94	2881.3	0.53	2911	1.46	2922.5	1.76

Best values are indicated in bold.

give the experimental results, i.e., average makespan (AVG) and RPI values obtained by all algorithms on 10 different scales when $CPU=10$ and $CPU=15$, respectively. In Table 7 and Table 8, ‘J×S’ represents the scale of the problem, where J and S refer to the number of jobs and stages, respectively. Meanwhile, to visually illustrate the advantages of all comparison algorithms, Figure 8 and Figure 9 show the means and 95% least significant difference (LSD) confidence intervals of all test algorithms.

In Table 7 and Table 8, the proposed VIG algorithm shows extremely superior performance in solving 10 instance sets of different scales. We can observe that the number of the best average makespan generated by VIG is 10, followed by DPSO (2), IGDLM (1), IGTALL (0), GA (0), EMBO (0), and DABC (0). Meanwhile, the RPI values obtained by VIG are the best among all the algorithms. Similarly, VIG obtains the best average makespan and RPI values for all the instances when CPU = 15. Overall, VIG outperforms the comparative algorithms in solving the BHFSP, which may be attributed to our hybrid decoding strategy that can efficiently identify and select a small makespan value. Additionally, the swap-based local search can explore undiscovered neighborhoods more effectively and potentially find more feasible solutions.

To intuitively display the performance of all comparison algorithms, Figure 8 and Figure 9 show the means and 95% LSD confidence intervals of all test algorithms. We can observe that under the different CPU running times, the VIG algorithm outperforms other comparison algorithms, followed by IGDLM, EMBO and IGTALL, DPSO, DABC, and GA algorithms. We can believe that the algorithm including the proposed hybrid decoding, local search, and interaction strategies can show superior performance in solving BHFSP.

To further demonstrate the superiority of VIG, we selected four instance sets of different scales, i.e., 20 × 10, 60 × 10, 80 × 5, and 100 × 5, and displayed their box plots in Figure 10. The makespan of the VIG algorithm was smaller than those of IGDLM, EMBO, IGTALL, DPSO, DABC, and GA. In the four randomly selected test instances, VIG stood out from the other comparison algorithms and exhibited a relatively stable state. This indicates that the quality of the solutions produced by our algorithm does not fluctuate much and the convergence of the algorithm is good when dealing with instances of different sizes. From the overall perspective, VIG obtained the best makespan value.

In addition, to enrich the experiments, we analyzed the convergence properties of the proposed algorithm. Four test instances, 40 × 5, 60 × 10, 80 × 5, and 100 × 10, were randomly selected to plot the evolutionary curves. All algorithms were performed in the same experimental environment, and the CPU is set to 10. In Figure 11, Y-axis is the makespan yielded by the algorithm during the evolutionary process, and the X-axis refers to the elapsing time of the algorithm. From Figure 11, it is clear that VIG has the lowest convergence curve and is the most rapid among the seven algorithms. VIG can use a hybrid decoding strategy to obtain different makespan values, increasing the diversity of solutions. At the same time, the use of local search can further increase the depth of neighborhood exploration and hopefully find better solutions. In addition, VIG can find better solutions for test instances of different scales and shows low convergence curves, which again demonstrates the good convergence of the algorithm. The above analysis demonstrates the effectiveness of VIG in solving the BHFSP.

5.6. Friedman Test

These simulation results are used to test whether significant differences exist in multiple overall distributions [53]. We presume that all the compared methods are not significantly different from each other at every beginning. When the p-value is less than 0.05, the above assumption is unacceptable, and all methods are regarded to be significantly different. On the contrary, if the above assumption is accepted, it suggests that there are no significant differences between all methods.

Table 9. Friedman Test (α = 0.05) when CPU = 10.

Algorithm	Ranks	CN	Min	Max	Mean	Std. Deviation
VIG	2.13	100	0.00	0.64	0.061	0.1369
IGTALL	3.84	100	0.00	5.88	0.827	1.4039
IGDLM	2.91	100	0.00	4.67	0.506	1.0183
GA	6.23	100	0.00	8.09	1.804	1.9808
EMBO	3.41	100	0.00	4.47	0.471	0.8354
DPSO	4.25	100	0.00	10.59	1.442	2.4597
DABC	5.26	100	0.00	10.18	1.692	2.4898
p-value	0.000

Best values are indicated in bold.

and

Table 10. Friedman Test (α = 0.05) when CPU = 15.

Algorithm	Ranks	CN	Min	Max	Mean	Std. Deviation
VIG	2.17	100	0.00	0.68	0.063	0.1366
IGTALL	3.99	100	0.00	6.11	0.829	1.3963
IGDLM	2.95	100	0.00	4.72	0.512	1.0325
GA	6.23	100	0.00	7.92	1.764	1.9696
EMBO	3.23	100	0.00	4.11	0.460	0.8254
DPSO	4.26	100	0.00	10.22	1.416	2.4265
DABC	5.18	100	0.00	8.10	1.559	2.2845
p-value	0.000

Best values are indicated in bold.

list the results of the Friedman test for 100 instances under CPU = 10 and CPU = 15, respectively. The p-value obtained by the Friedman test is equal to 0.000, which is less than the given level α = 0.050, suggesting that VIG is significantly different from the six compared algorithms. For the values of ranks, the proposed VIG algorithm has the minimum rank value, e.g., 2.13 and 2.17 when CPU = 10 and CPU = 15, respectively. In addition, the maximum value ARPI (max), mean value ARPI (mean), and standard deviation (std. deviation) of VIG are 0.64, 0.061, and 0.1369, respectively. The above values are the smallest compared to other algorithms. Based on the above analysis, our VIG has an extremely high ability to solve BHFSP and is suitable for BHFSP.

Remark 1. 

Based on the experimental data and analysis reported in Section 5.2, Section 5.3, Section 5.4, Section 5.5 and Section 5.6, the proposed VIG algorithm has good convergence and is effective in solving BHFSP. The reasons are given as follows: (1) This paper adopts the parallel optimization route to obtain two solutions; one solution adopts forward decoding and the other adopts backward decoding, which can effectively calculate the objective value and select a minimal makespan. (2) Two efficient initialization methods based on different decoding strategies are used to generate high-quality solutions at the beginning, which can assist the algorithm to have more opportunities for probing the search space in depth. (3) The implementation of a swap-based local search strategy with low time complexity, which explores the neighborhood space of the solution very quickly. (4) The interaction of optimization solutions with some probability yields two new scheduling sequences, which improves the diversity of the solutions. Based on the analyses, the proposed hybrid decoding strategy and parallel optimization route are reasons for the outstanding performance of VIG. In addition, in real production, traditional manual scheduling methods often fail to obtain efficient solutions due to the complexity of scheduling problems. The intelligent optimization algorithm can find a solution close to the optimal solution within a reasonable time frame by the computing power and search technique of the computer. From the experimental results and analysis, our VIG algorithm is effective in solving the BHFSP, which can provide a promising solution for realistic production scheduling problems.

6. Conclusions

We studied the BHFSP and now propose a VIG algorithm to optimize the makespan. First, a MILP model of BHFSP was built, and the Gurobi solver was adopted to demonstrate its correctness. Second, multiple decoding strategies based on forward and backward mechanisms were proposed to find a smaller completion time. Then a parallel evolution framework of two solutions was designed to broaden the search scope of VIG. In addition, the swap-based local disturbance strategy could quickly change the position of the job sequence, which saved the running time and increased the opportunities to probe the search space in depth, effectively enhancing the quality of the algorithm. Finally, the use of a crossover operator increased the diversity of solutions. Through the simulation experiments listed in Section 5, the proposed VIG algorithm shows superiority compared with the six existing algorithms.

This paper presents insights into the application of intelligent optimization algorithms in solving production scheduling problems. In practice, production scheduling involves the task of arranging production resources and job sequences in complex production environments to maximize production efficiency and meet production requirements. Due to the complexity of production scheduling problems and the diversity of constraints, traditional manual scheduling methods often fail to achieve optimal or efficient solutions. Intelligent optimization algorithms use the computing power and search techniques of computers to explore near-optimal solutions in large-scale problem spaces. The experimental results and analysis demonstrate the effectiveness of the proposed optimization approach. Decision makers can utilize our method to obtain high-quality solutions within a reasonable time frame, thereby improving production efficiency, reducing costs, enhancing competitiveness, and achieving sustainable development.

Although VIG demonstrates excellent performance in solving the BHFSP, there are still some related issues that require further research. Firstly, VIG performs well in solving the optimization objective of the maximum completion time, but it may not be suitable for other objectives or multi-objective scenarios. In future research, multi-objective optimization problems can be considered. Secondly, the production constraints currently considered are not comprehensive enough, and the next step of research can also consider multi-factory production, group problems, etc. Finally, considering the actual production demand, we should apply the proposed algorithm to real production scheduling problems.