An improved iterated greedy algorithm for distributed mixed no-wait permutation flowshop problems with makespan criterion

The distributed permutation flowshop scheduling is a critical issue in various industries, involving jobs allocation and scheduling among multiple flowshops. This paper extends the research to explore the Distributed Mixed No-Wait Permutation Flowshop Scheduling Problems (DMNWPFSP) with minimizing makespan. The innovation lies in an optimized mathematical model, hybrid heuristic algorithms, an improved iterated greedy algorithm (IIG), and high-quality solutions. Extensive experimental results demonstrate the effectiveness and superiority of the proposed IIG in terms of scheduling quality, computational efficiency, and robustness compared to existing approaches. The outcomes of this work contribute to the field of distributed flowshop scheduling, providing valuable insights for practitioners seeking to enhance production efficiency and competitiveness.


Introduction
In the era of globalization, industrial collaboration has become increasingly diversified (De Giovanni & Pezzella, 2010).The development of technology has fundamentally transformed the landscape of manufacturing.These technologies offer unprecedented connectivity, real-time data exchange, and intelligent decision-making capabilities.Companies are changing their production strategies to enhance competitiveness and mitigate risks.The traditional centralized production model has transitioned into distributed manufacturing, with numerous factories established globally.Distributed manufacturing offers scalability, flexibility, and high reliability, optimizing resource utilization for geographically dispersed enterprises and factories (Lu, Liu, Zhang, & Yin, 2022).Scheduling plays a crucial role in various industries and has a significant impact on operational efficiency and overall performance.Efficient scheduling minimizes makespan, improves resource utilization, and ensures timely task completion (Jia, Fuh, Nee, & Zhang, 2007) with limited resources, interdependencies, and coordination among stages.Researchers develop various algorithms to optimize scheduling based on criteria like makespan, throughput, and workload balance (Li, Pan, Gao, et al., 2021).Effective scheduling optimizes resources, streamlines processes, and enhances competitiveness (Yang, Wang, & Xu, 2022).One of the extensively researched subjects is the distributed permutation flowshop scheduling problem(DPFSP), which has a wide range of application backgrounds (Pan, Gao, Xin-Yu, & Jose, 2019).One prominent variant for the DPFSP is the DMNWPFSP, which has garnered significant interest from researchers and practitioners (Pan, Fatih Tasgetiren, & Liang, 2008;Shao, Shao, & Pi, 2021).In actual manufacturing process, both waiting and no-wait constraints need to be considered simultaneously (Cheng, Ying, Li, & Hsieh, 2019).This unique characteristic presents new challenges in scheduling and resource allocation, necessitating innovative approaches to optimize production efficiency and meet real-world production requirements (Allahverdi, Ng, Cheng, & Kovalyov, 2008).In the canned food processing industry, operations such as procurement, sorting, trimming, cleaning, peeling, and shelling are typically carried out in the early stage.These operations are all regular operation and there can be waiting between them.Other operations such as adding syrup, degassing, sealing, sterilizing, and refrigerating are usually performed after the ingredients have undergone preliminary processing and are placed into cans.These operations need to be carried out immediately after the preliminary processing to ensure the quality and safety of the ingredients.Another example is the pharmaceutical industry, where the production of medications typically involves multiple processes, including raw material mixing, reactions, filtration, drying, granulation, packaging, etc.Some processes need to be no-waiting to ensure the quality and safety of the medications.For example, processes such as mixing, reactions, filtration, and drying need to be performed sequentially without waiting.It is important to note that whether a factory needs to adopt a mixed no-wait processing approach depends on its specific circumstances and requirements.The above example serves as an illustration, and actual decisions should be based on comprehensive evaluations of factors such as production processes, resource utilization, cost-effectiveness, and technological feasibility (Li, Pan, & Mao, 2016;Li, Pan, He, et al., 2022).
This study focuses on the DMNWPFSP with the criterion of completion time (Wang, Li, Ruiz, & Sui, 2018).In this study, we introduce a mixed integer linear programming (MILP) model aimed at addressing the challenges posed by DMNWPFSP.The MILP model provides a systematic and rigorous approach to addressing the complexity of the problem.An improved iterative greedy algorithm (IIG) is proposed, which significantly improves the effectiveness of the heuristic algorithm.Notably, enhancements are observed in the generation of initial solutions, the utilization of evolutionary strategies, and the implementation of local search operations.As a result of these improvements, the IIG algorithm produces high-quality solutions, which is a key advance in solving DMNWPFSP.And the algorithm was verified through experimentation.Experimental results show that the IIG algorithm performs well under the DMNWPFSP instance and can efficiently find highquality solutions.This further solidifies the practicality and usefulness of the algorithm in practical applications.
In Section 2 of this paper, a comprehensive review of the literature related to DMNWPFSP is presented.Section 3 introduces the DMNWPFSP, providing its definition, examples, and highlighting its key characteristics.Following that, Section 3 provides a detailed description of the improved Iterated Greedy (IG) algorithm.In Section 4, we discuss the fine-tuning of parameters for the IIG algorithm to achieve optimal performance.To assess its effectiveness, Section 5 presents a thorough comparison of the IIG algorithm against four state-of-the-art approaches.Lastly, Section 6 concludes this paper by summarizing the main findings and offers valuable suggestions for future research directions.

Literature Review
Although not been extensively studied, the DMNWFSP is an extension of the DPFSP and the No-Wait Permutation Flowshop Scheduling Problem (NWPFSP), both of which have been well-researched.Therefore, we will focus on DPFSP and NWFSP in this section.The DPFSP deals with a scenario where f identical factories are organized in flowshops configuration with m machines.A crucial challenge is to determine the allocation of n jobs to the appropriate factory and their processing sequence in each factory.Nader and Ruiz (Naderi & Ruiz, 2010) first studied the DPFSP.They proposed 6 MILP models, 2 assignment rules, and 14 heuristic algorithms.Gao and Chen (2011) proposed a GA-based algorithm for the DPFSP.It minimizes makespan using specialized operators and efficient local search.Extensive experiments on Taillard instances (TAILLARD, 1990) show significant improvements over existing methods.Gao et al. (2013) introduce an advanced Tabu search algorithm which utilizes a novel Tabu strategy and enhanced local search.It is worth noting that the Tabu search algorithm exhibits higher efficiency compared to the hybrid genetic algorithm (Gao & Chen, 2011).Victor and Jose (Fernandez-Viagas & Framinan, 2014) presented a bounded-search iterated greedy algorithm for solving the DPFSP.Wang et al. (2016) introduced a hybrid discrete cuckoo search (HDCS) algorithm for DPFSP.It uses permutation encoding and a specialized variable neighborhood search (VNS) for efficient exploration.Simulations confirm the HDCS's effectiveness compared to existing algorithms on various instances.Wang et al. (2013) introduced an Estimation of Distribution Algorithm for the DPFSP.They developed a probabilistic model to characterize the solution space and effectively explored high-quality solutions by updating the model using improved solutions.Deng and Wang (2017) introduced the Competitive Memetic Algorithm (CMA) as a solution to the multi-objective DPFSP.The CMA utilizes two populations, objective-specific operators, and a competitive mechanism.Pan et al. (2019) proposed four intelligent optimization algorithms and three heuristics to solve the DPFSP with minimizing the total flowtime.Meng et al. (2022) and Meng, Zhang, Ren, Zhang, & Lv (2020) utilized their proposed MILP models and constraint programming approaches to address the minimization of makespan in the distributed flexible job shop scheduling problems (DFJSP) and the distributed hybrid flow shop scheduling (DHFSP) with sequence-dependent setup times.In their study, Li et al. (2021) explored the DPFSP with mixed no-idle constraints.They also introduced a total delay rule to address the problem (Li, Pan, Ruiz, & Sang, 2022).Their research aims to find efficient algorithms to solve these complex scheduling problems.Additionally, Rossi and Nagano (2021) proposed a MILP formulation in their work.Their algorithm employs an IG strategy designed to optimize the solution to the problem and provides an efficient solution.
The NWFSP is a significant variant of the flowshop scheduling problem and has become a hot topic (Pei, Zhang, Zheng, & Wan, 2019).Researchers are devoted to solving the NWFSP by developing innovative algorithms and heuristic methods to improve production efficiency and resource utilization.The findings in this field provide valuable guidance for scheduling decisions in practical production scenarios.RöCK proof that the NWPFSP is NP-hard when the number of machines exceed 2. As the scale of the problem increases, traditional methods such as branch and bound or mixed integer programming become impractical.To address this, researchers have devised efficient heuristic algorithms.Aldowaisan and Allahverdi (2004) introduced novel heuristics for the m-machine no-wait flowshop problem with total completion time criterion.Subsequently, a hybrid discrete particle swarm optimization (HDPSO) algorithm (Pan, Wang, Tasgetiren, & Zhao, 2007) was proposed for the NWPFSP.It combines a simplified calculation method for makespan, and a fusion of discrete particle swarm optimization (DPSO) and local search.Experimental results demonstrate the superiority of HDPSO over single DPSO and existing HPSO algorithms in terms of quality, robustness, and efficiency.A Discrete Harmony Search (DHS) algorithm (Gao, Pan, & Li, 2011) was proposed to minimize total flow time for the NWPFSP.It incorporates a new heuristic for harmony initialization and novel pitch adjustment rules.Experimental results validate DHS's effectiveness in solving the NWPFSP.Ye et al. (2017) presented an average idle time heuristic to optimize the NWPFSP with makespan criterion.Deng et al. (2020) formulated the NWPFSP based on the total process time criterion, and proposed a population-based iterated greedy algorithm (PBIG) to solve the sorting subproblem.Recently, to effectively solve the distributed heterogeneous NWPFSP, Li et al. (2021) proposed four neighborhood search operators and used them in the discrete artificial bee colony algorithm for searching neighborhoods in the employed bee stage and the onlooker bee stage.Miyata and Nagano (2021) introduced the distributed wait-free flowshop scheduling problem with sequence-dependent setup time and maintenance operations to minimize makespan.Allali et al. (2022) presented three naturally inspired meta-heuristics: genetic algorithm, artificial bee colony algorithm and migratory bird optimization algorithm for the distributed NWPFSP.
From the above overview, DPFSP and NWPFSP are studied by many people.However, there are no research on the DPFSP considering mixed no-wait constraints.In this paper, the DMNWPFSP is studied.A mathematical model is established, and a heuristic algorithm is proposed.This paper presents the IIG algorithm and validates its practicality.To assess the high efficiency of the IIG algorithm, we conducted a comparative study with four state-of-the-art algorithms from the existing literature.

Problem Description
The DMNWFSP can be succinctly explained as follows.A total of n jobs are required to be processed, which will be distributed among f factories with the same series of processing machines.The key objective is to determine the optimal job assignment for each factory for efficient scheduling.In each factory, a job is processed along the same route, for example, following the same route from machine 1 to machine .In DMNWFSP, the processing time required by job  (where  belongs to the set {1,2, … , }) on machine  (where  belongs to the set {1,2, … , }) is denoted by  , .Due to production process limitations, machines are divided into two types: no-wait machines and regular ones.The set of regular machines is denoted as   , and the number of regular machines is denoted as ξ= | |.Regular machines divide no-wait machines into several groups, which is denoted as ∪  .In the context of the problem, we define  as the r th group of no-wait machines, and q denotes the number of such no-wait machine groups.A no-wait machine group consists of at least two machines, i.e., |  | ≥ 2,  ∈ {1,2, … , }.It is obvious that  ∩  = ∅( ≠ ′).For example，assume  and  ,  - , are no-wait machines in a ten-machine DMNWFSP.Therefore, the machine group can be divided into

𝑶 𝒊,𝒋
The operation of job j on machine i.

𝒒
Number of no-wait machine groups.

𝕄 𝒂
The set of the first machine in all no-wait machine group, The completion time of the job in position l on machine i in factory k.

𝑪 𝒎𝒂𝒙
The completion time of a scheduling.

𝑿 𝒋,𝒌,𝒍
Binary variable: This binary variable takes the value 1 if job j is assigned to location l in factory k; otherwise, it takes the value 0.

The Mixed-Integer Linear Programming Model
To solve DMNWFSP, we propose the MILP model. Objective: subject to: , , > 0, ∀, , , , ∈ {0,1}, ∀, , The goal is to minimize  , which is described by Eq. ( 1).Constraint set (2) ensures that each job occurs only once in all factories.Constraint set (3) ensure that each position is occupied by at most one job.Constraint set (4) represents the completion time of the job at the first position on the first machine.The constraint set (5) enforces that a job can only start processing on a particular machine after a previous job on the same machine has completed.This ensures that jobs are sequenced correctly on individual machines.The set of constraints (6) specifies that each operation of a job must start only after its previous operation has completed.This ensures that jobs are processed in the correct sequence and follow their specific route through the machine.The constraint set (7) guarantees that there is no waiting time between any two consecutive nowaiting machines.This restriction plays an important role in satisfying the problem properties.Constraint set (8) defines the completion time of a schedule.Constraint sets ( 9) and ( 10) define the value ranges of the intermediate and decision variables.

Table 2
Processing times Pi,j of jobs on machines 1-4 In Fig. 1, the Gantt chart illustrates the DMNWPFSP constraints.When processing jobs on  ( [ ] ) and  ( [ ] ), there cannot be jobs waiting for processing, that is, the waiting time between machines is 0. As a result, the makespan of the scheduling is calculated as  , , +  , = 29 + 4 =33.

Proposed Metaheuristics
The Iterated Greedy algorithm (IG) has shown good performance for various scheduling problems and their variants (Deng et al., 2020;Ruiz, Pan, & Naderi, 2019;Glass et al., 1994).The IG is a simple but effective algorithm with two solutions: the best solution and the current solution.Some researchers have proposed IG methods to solve the DPFSP and achieved good results (Li et al., 2019;Li, Pan, Ruiz, et al., 2022).We have made appropriate modifications on the basic IG algorithm based on the characteristics of the considered problem.Generally, the IG is divided into four stages: initialization stage, destruction stage, construction stage, and acceptance criterion.In the first stage, we first generate an initial solution using the heuristic algorithms described in Section 3.5.Then, we perform subsequent operations on this initial solution.During the two-step process of the second and third stages of the algorithm, certain elements are selected and removed from the current solution and temporarily stored, which is known as the destruction stage.The extracted elements are then reinserted into a solution containing only some of the elements.This reinsertion takes place according to predefined rules, and this process is called the construction stage.Once the construction is complete, acceptance criteria come into play.The acceptance criteria evaluate the new solution obtained in the current iteration and determines what to do with it.Depending on the circumstances, the algorithm may choose to accept the new solution as is or discard it entirely.In addition, in order to enhance the prevent from falling into local optimum, local search operators based on shift, swap and hybrid operators are introduced.This local search operator enables the algorithm to explore different regions of the solution space, thereby improving the quality of the obtained solutions.
In the following sections, these modifications will be elaborated to gain a comprehensive understanding of their respective roles in enhancing the effectiveness of the algorithm.

Solution Representation
A reasonable solution representation should be able to fully express the constraints of the problem and the structure of the solution, while reducing the complexity of the search space as much as possible (Pan, Gao, Xin-Yu, et al., 2019).A twodimensional array is used to represent jobs assigned to factories (Pan, Gao, Wang, et al., 2019).The array contains f rows, each representing job sequences  = ( ) assigned to factory k.Jobs within each sequence are arranged in the order of processing.Hence, a solution is denoted as  = ( ,  , … ,  ), using a sequence-based notation commonly employed in scheduling literature due to its intuitive and easily programmable nature (Pan, Zhao, & Qu, 2008).The solution for the example in section 3.2 can be expressed as  = ( ,  ), where  = (1,3,5,7), and  = (2,4,6,8).

Heuristic Algorithm
The quality of randomly generated solutions is generally not high.Heuristics based on the problem characteristics are crucial.The Distributed SDH+Dipak algorithm (DSD) shown in Algorithm 1 combines the initialization method of the SDH algorithm with the Dipak algorithm (Trietsch & Baker, 1993).The job with the largest standard deviation of all machining times is inserted preferentially in the SDH+Dipak algorithm to ensure the quality of the initial solution.First, the standard deviation  of each job at all machining times is calculated (Line 1). is the average processing time of job j on all machine, calculated as the total processing time of job j divided by the number of machines.A temporary job permutation λ is obtained according to the non-descending order of  (Line 2).The first f jobs in λ are put into f empty factories (Lines 3 and Lines 4).The remaining jobs in λ are removed in turn and try to insert the optimal location (Lines 5-18).When there are two or more jobs in each factory, except for the newly inserted job in factory k, all jobs in that factory are inserted into the best position among the other π * positions (Lines 14-17).Finally, the completion time   are updated.The DNEH algorithm (Pan, Gao, Wang, et al., 2019) can also generate high-quality initial solutions which is shown in Algorithm 2. Initially, the total processing times for each job on every machine, denoted as   , are computed (line 1).Subsequently, a temporary job arrangement λ, is created based on the non-descending order of   (line 2).The first f jobs from λ are then chosen and allocated to f available factories, resulting in the formation of  (lines 3 and 4).The remaining jobs in λ are sequentially removed and inserted in their best positions (Lines 5-14).Finally, the completion time   is updated accordingly.
In the IIG algorithm, the parameter "" determines which heuristic algorithm to use.Specifically, when  = 0, the DNEH algorithm is used, and when  = 1, the DSD algorithm is employed for initialization.

RLS (Reference Local Search
) is a reference-based local search algorithm that has demonstrated favorable performance in solving diverse problems (Pan, Gao, Wang, et al., 2019;Pan & Ruiz, 2014).This method employs local search techniques to explore new solutions within a confined search space, thereby avoiding the exhaustive exploration of the entire solution space.After obtaining the initial solution via a heuristic algorithm, RLS extracts jobs one by one according to the job order given in sol and reinserts them in all possible locations to form a new solution.Until all jobs have been tried and no further improvements can be made.

Destruction Stage
The destruction stage is used to perturb solutions to provide diversity.In general, the IG algorithms randomly select jobs from the current solution to remove during the destruction stage.This paper proposes a novel removal strategy for key factories, defined as those with the longest completion time.The strategy involves randomly selecting half /2 of the jobs from the critical factory and half /2 of the jobs from the remaining factories, and then removing these selected jobs from the solution.The removed jobs are placed in a temporary sequence .For this process, please refer to Algorithm 4. Algorithm 4. Destruction(, ) 1: ω = ∅; 2： Find the critical factory  with the maximum makespan in ; 3: Randomly extract  2 ⁄ jobs in factory  ; 4: Append these  2 ⁄ jobs to ω; 5: sizeof(ω) <   6: Randomly select a factory ; 7: Randomly extract a job  in factory ; 8: Append job  to ω; 9:  10:   and ω;

Construction Stage
During the reconstruction phase, the jobs in the temporary sequence  are sorted according to the sorting method in the Algorithm 1.Then, each job in the sequence  is inserted into the solution one by one.Finally, we choose the best positions p, where each job is inserted to minimize the increase in makespan, and repeat this process until all removed jobs are inserted.The details of this stage are presented in Algorithm 5. Algorithm 5. Construction(, ω) ) for job  in ω;

Local Search
High-quality local search leads to better solutions without searching the entire solution space.Based on the characteristics of the DMNWPFSP and the characteristics of the IG algorithm, we define two operators, namely, Shift and Swap.
(1) The operation process of Shift can be shown by Algorithm 6.It randomly selects a job  in the critical factory  and moves job  to another randomly selected position p in all factories.
(2) The Swap operator shown in Algorithm 7 randomly selects a job  in the critical factory  and another random job  in all factories and then swaps jobs  and  .
To search across a wider range of regions, the LocalSearchShift algorithm (presented in Algorithm 8) and the LocalSearchSwap algorithm (presented in Algorithm 9) are proposed to repeatedly operater (Shift and Swap) on the solution sol.After each operation, the current solution is compared with the old one.If the new solution is better, the local search will save it as the current best solution.Otherwise, the solution sol will continue to be operated on until the loop ends after OperNumber times, where OperNumber is a parameter.

Acceptance Criteria
Acceptance criteria play a vital role in determining whether to accept a new solution as a starting point for the next iteration.
In the case of the constant temperature T (Stützle) simulated annealing algorithm, if the objective function value is inferior, the acceptance criterion shown in Equation ( 11) is applied.
where TempFactor is the control parameter.
Step 3: Perform Reference-based local search to the solution .
Step 4: The optimal solution  is recorded.
Step 5: Destruction: remove  jobs, put them in , and store the new solution in ′。 Step 6: Construction: insert the jobs in  into ′.
Step 8: Acceptance Criterion: decide whether to accept the new solution.
Step 9: If the stop condition is met, the IIG algorithm ends; otherwise, it returns to step 5.

Experimental Calibration
For achieving the best performance of the IIG algorithm, we conducted calibration experiments to fine-tune its parameters.We utilized the testing methodology proposed in the literature (Cheng, Ying, Chen, & Lu, 2018) to generate instances for evaluation.A test instance consisted of n jobs and f factories, with m machines in each factory, where f∈{2, 4, 6}, n∈{20, 50, 100, 200, 500} and m∈{5, 10, 20}.Below are the families of no-wait machines of the seven types generated from the paper (Pan & Ruiz, 2014). 1) Series 1: The top 50% of machines are subject to no-wait constraints, while the remaining 50% operate as regular machines.2) Series 2: The bottom 50% of machines are assigned no-wait constraints.3) Series 3: Machines are alternately assigned regular constraints and no-wait constraints in a sequential manner.4) Series 4: 25% of machines are randomly selected and given no-wait constraints.5) Series 5: 50% machines are randomly selected, no waiting time for operation.6) Series 6: 75% of machines are randomly assigned with no-wait constraints.7) Series 7: All machine constraints are no-wait.In each instance, the no-wait machine group categories were randomly generated to maximize the accuracy of the experiment.
Table 3 provides details of the example parameters used in the experiments.The IIG algorithm was implemented using Microsoft Visual Studio 2019 and the C++ programming language, with all optimization flags enabled.The computer used for the experiments runs on the Windows 10 Pro operating system and is equipped with a quad-core Intel i7-12700 2.1 GHz processor and 16 GB of RAM.Using Relative Percentage Increment (RPI) as an indicator allows us to intuitively select the most suitable algorithm or optimize parameters to obtain better solutions.RPI is calculated using the following Eq.( 12): The parameter settings mentioned above include two parameters:  and  * .Here,  represents the performance metric of the algorithm on a specific instance, while  * represents the best value of that metric achieved by optimizing or tuning on the same instance.This RPI measure allows for a more comprehensive assessment of the algorithm's performance (Li, Gao, Meng, Jing, & Zhang, 2023).

Table 3
Parameters of instances.
The IIG involves four parameters that may affect its performance: d, TempFactor, Init and OperNumber.The value of d represents the number of jobs removed in Section 3.7.TempFactor represents the probability of accepting a solution in Section 3.10.The Init parameter indicates the selection of the DNEH heuristic algorithm, or the DSD heuristic algorithm described in Section 3.5.OperNumber represents the number of times the selected operator is applied as described in Section 3.9.For the IIG algorithm, we first determine an approximate range for the four parameters through preliminary experiments.Subsequently, we conduct calibration experiments to find the optimal value for each parameter.The four parameters of the IIG algorithm are set as follows: d: 2, 4 and 6, TempFactor: 0.4, 0.6 and 0.8, Init: 0 and 1 and OperNumber: 50, 60 and 70.Therefore, there are 3×3×2×3 = 54 configurations for the IIG algorithm.
In the calibration experiment, there are three values for variable f (2, 4, 6), and nine combinations for variables m and n: 50×5, 50×10, 50×20, 100×5, 100×10, 100×20, 200×5, 200×10, and 200×20.There are total of 3×9=27 combinations.Five instances are generated for each combination.Finally, we obtained a total of 3×9×5=135 benchmark instances.These 135 instances calibrated the proposed IIG algorithm.For each instance, the experiment was run two times independently.The CPU time, when the IIG algorithm terminates, was v×m×n ms, where v=90.Therefore, there are 135×2×54 = 14580 RPI results.In the experiments presented in this paper, we employed the method of experimental design and analysis of variance (ANOVA) (Li, Pan, & Tasgetiren, 2014;Zhang et al., 2020) to analyze the obtained results.ANOVA is a widely-used statistical technique for comparing the average differences among multiple groups.Our focus in the analysis was on the algorithm type, rather than the problem size factors (n, f, and m).In ANOVA, the algorithm type is considered as the controlled factor, while the variables f and m are treated as uncontrolled variables.The ANOVA results are shown in Table 4, d, TempFactor , Init and OperNumber cause the response variables to differ statistically significantly; that is, to optimize and improve the performance of the IIG algorithm, it is crucial to carefully select and adjust these parameters.According to the analysis of the experimental results, the four parameters of the IIG algorithm are set as follows: d = 4, TempFactor = 0.6, Init = 1 and OperNumber = 60.

Experimental Results
The proposed IIG algorithm was evaluated by a large number of numerical comparisons.In the final experiment, f∈{2, 4, 6} and there are 12 combinations of 20×5, 20×10, 20×20, 50×5, 50×10, 50×20, 100×5, 100×10, 100×20, 200×10, 200×20, 500×20 for n and m.Each combination contained ten instances, which resulted in a total of 12×10×3=360 instances.The dataset and the kind of no-wait machine group for the final experiment were generated using the methods in Section 4. We compared the proposed IIG with EA (Fernandez-Viagas, Perez-Gonzalez, & Framinan, 2018), IG (Pan, Gao, Wang, et al., 2019), DABC (Pan, Gao, Wang, et al., 2019), and ILS (Pan, Gao, Wang, et al., 2019).All algorithms are coded using the same environment as Section 4. We note that the four competitive algorithms compared did not consider the mixed no-wait constraint, and their initial optimization goal was not the completion time.Therefore, we made necessary modifications to these algorithms to fit the DMNWPFSP.In addition, we only made changes to the necessary code to try to maintain all details of the competitive algorithms to ensure and achieve the performance they should have.The parameters of all competitive algorithms are tabulated in Table 5.In the experiments conducted in this paper, we utilized the same operating environment as described in Section 4. All algorithms ran the same termination time and output results.The termination time was v×m×n ms, where v took the 3 values of 30, 60 and 90, and m and n please refer to Table 1, respectively.The comparison of the results of all algorithms under these three termination conditions comprehensively demonstrated the performance of all algorithms.All algorithms independently ran five times to solve each of the 360 instances.Therefore, 360× 5 × 3 × 5= 27000 tests are conducted.The RPI was used as a performance indicator for comparison.
In Tables 6, 7, and 8, we provide the average (ARPI) values for the algorithms.Specifically, Table 6 shows the values obtained by the algorithm by plant, machine, and job classification at a termination time of 30mn ms.The IIG algorithm exhibits superior performance, as indicated by its high ARPI value.This is followed by the IG algorithm, which ranks second in terms of ARPI.Furthermore, it can also be seen that the IIG algorithm consistently exhibits superior performance across different categories.In our study, we conducted a multivariate analysis of variance to assess the significance of various factors presented in Table 6.These factors include algorithm type, the size of the job, number of machines and factories.
Fig. 4 presents the statistics for multiple comparisons at a termination time of 30mn ms.The results of our analysis indicate significant differences in the ARPI values among different algorithms.Specifically, the IIG algorithm demonstrated the highest performance, followed by the IG algorithm.In the study, we observed that although the ILS algorithm is relatively weak, compared with the other two algorithms, the performance gap was not statistically significant.These findings provide valuable insights for further exploration of algorithm performance and demonstrate the utility of the IIG algorithm for the problems under consideration.7 and 8 show the ARPI values of various factors at termination time of 60mn and 90mn ms, respectively.Figs 8 and 9 illustrate the mean and interaction plots at termination times of 60mn ms and 90mn ms, respectively.The ranking of all algorithms is still maintained, with IIG continuing to outperform other comparison algorithms by a significant margin.The ARPI differences of all algorithms are still significant.As the problem complexity rises, particularly for larger instances, the algorithm's performance typically declines due to the increased complexity of the search space, making it more challenging to find optimal solutions.However, the results clearly demonstrate that with longer termination times, all algorithms achieve improved performance.Notably, the proposed IIG algorithm consistently outperforms the four contrasting algorithms in solving the DMNWPFSP with makespan criterion, even with longer termination times.This highlights the excellent performance and superiority of the IIG algorithm in solving the complexity of DMNWPFSP and obtaining high-quality solutions.To further demonstrate how the IIG algorithm evolves over time and how its performance changes, we conducted a series of experiments and analyzed the IIG algorithm evolution curve.To ensure the fairness and practicality of the experiments, we designed 5 different combinations of n×m×f with different scales, which are 20×5×2, 50×5×2, 100×10×4, 200×10×4, and 500×20×6, respectively.We generated 10 instances for each combination.All algorithms run independently 5 times to solve each instance.We used CPU time to measure the efficiency of the IIG algorithm.Fig. 8 shows the changing trend of the average RPI value of all algorithms.As the scale of the instances increases, the time taken by all algorithms to reach a relatively stable peak performance also increases.Moreover, the superior performance of the IIG algorithm becomes more and more evident as compared to the other algorithms.Therefore, in our experiments, we set the CPU termination time of the algorithm to three different values: v∈{30, 60, 90}.For the largest instance of 500×20×6, all algorithms can reach a relatively stable performance at v=90.

Conclusions
This paper introduces an IIG algorithm designed to address the challenges of the DMNWPFSP.The algorithm incorporates critical factory destruction and employs an iterative local search mechanism.Initially, the unique characteristics of the DMNWPFSP are thoroughly examined, and a location-based mathematical model is formulated to describe it.Subsequently, the IIG algorithm utilizes the DSD heuristic algorithm to generate a better initial solution.Then, by utilizing the framework of the IG algorithm and integrating a powerful local search mechanism, the solution space is thoroughly explored, enhancing its ability to find better solutions.The efficacy of the IIG algorithm is extensively evaluated through a series of numerical experiments.Performance evaluation and comparison show that the IIG algorithm achieves better solutions, demonstrating its superiority in solving the given problem and outperforming the other four recently proposed algorithms.Furthermore, the IIG algorithm consistently produces high-quality feasible solutions, even under varying stopping conditions.
Future research in the field of DPFSP should prioritize gaining a comprehensive understanding of the problem, as well as the development of advanced evolutionary algorithms and the design of metaheuristic algorithms tailored specifically for DPFSP.
In terms of algorithms, future work should be combined with other algorithms to improve exploration capabilities.Furthermore, the problem can be extended to the distributed flexible flowshop.

Fig. 1 .
Fig. 1.Gantt chart of a solution for the illustrative example

Fig. 3 .
Fig. 3. Means and 95.0%Tukey HSD confidence intervalsIt can be seen from Fig.3(a) that the optimal value of d should be 4.Fig.3 (b)  shows that TempFactor should be fixed to 0.6.As illustrated in Fig.3 (c), when comparing the performance of the DSD algorithm and the DNEH algorithm, it is observed that the DSD algorithm is more effective in solving the DMNWPFSP problem.Therefore, the parameter selection of Init should be 1.The number of operations on the selection factor during the local search, should be 60, as shown in Fig.3 (d).According to the analysis of the experimental results, the four parameters of the IIG algorithm are set as follows: d = 4, TempFactor = 0.6, Init = 1 and OperNumber = 60.

Fig. 7 .
Fig. 7. Interaction of CPU time and various influencing factors and 95% Tukey HSD intervals Fig.7presents the performance comparison of all algorithms under different termination times.As the problem complexity rises, particularly for larger instances, the algorithm's performance typically declines due to the increased complexity of the search space, making it more challenging to find optimal solutions.However, the results clearly demonstrate that with longer termination times, all algorithms achieve improved performance.Notably, the proposed IIG algorithm consistently outperforms the four contrasting algorithms in solving the DMNWPFSP with makespan criterion, even with longer termination times.This highlights the excellent performance and superiority of the IIG algorithm in solving the complexity of DMNWPFSP and obtaining high-quality solutions.

Table 1
lists of Symbols.

Table 4
ANOVA table for the experiment on tuning the parameters of IIG

Table 6
ARPI value at 30mn ms termination time (The optimal ARPI is in bold)

Table 7
ARPI value at 60mn ms termination time (The optimal ARPI is in bold)

Table 8
ARPI value at 90mn ms termination time (The optimal ARPI is in bold)