A Matheuristic Approach for the No-Wait Flowshop Scheduling Problem with Makespan Criterion

Abstract

The No-wait Flowshop Scheduling Problem (NWFSP) has always been a research hotspot because of its importance in various industries. This paper uses a matheuristic approach that combines exact and heuristic algorithms to solve it with the objective to minimize the makespan. Firstly, according to the symmetry characteristics in NWFSP, a local search method is designed, where the first job and the last job in the symmetrical position remain unchanged, and then, a three-level neighborhood division method and the corresponding rapid evaluation method at each level are given. The two proposed heuristic algorithms are built on them, which can effectively avoid al-ready searched areas, so as to quickly obtain the local optimal solutions, and even directly obtain the optimal solutions for small-scale instances. Secondly, using the equivalence of this problem and the Asymmetric Traveling Salesman Problem (ATSP), an exact method for solving NWFSP is constructed. Importing the results of the heuristics into the model, the efficiency of the Mil-ler-Tucker-Zemlin (MTZ) model for solving small-scale NWFSP can be improved. Thirdly, the matheuristic algorithm is used to test 141 instances of the Tailard and Reeves benchmarks, and each optimal solution can be obtained within 134 s, which verifies the stability and effectiveness of the algorithm.

1. Introduction

Improving production efficiency is one of the final aims of the manufacturing industry. Production scheduling can meet that need, so it is used in manufacturing systems extensively. Considering the differences in factory conditions and job processing requirements, the scheduling problem has been divided into several kinds, such as flow shop [1,2], hybrid flow shop [3,4], job shop [5,6], open shop [7,8], and so on. The flow shop problem (FSP) claims that each job should be processed in the same order through every stage, and the hybrid flow shop refers to parallel machines at one or more stages. A job shop environment permits jobs to pass some steps or repeat them at a given machine route, and the processing order of the job in an open shop can be arbitrary. It can be concluded that the flow shop problem is the basic one, then the others can be seen as its variants. In other words, the FSP reflects some common characteristics of production scheduling problems.

In recent years, flow shop scheduling problems with constraints have become research hotspots owing to the actual technology demand. Typically, no-wait attribute, which stipulates all the jobs should be processed from the first stage to the last without any interruption, fits lots of production industries. For instance, in steel processing, maintaining the temperature is a necessary condition, so it calls for no-wait demand. Once you wait, you need more time and energy to heat to the desired temperature, or accept degradation. As early as 1971, Callahan [9] considered that the steel industry required a dependent processing and the no-wait constraint. Tang and Song [10] modeled the mill roll annealing process as a no-wait hybrid flow shop scheduling problem. Höhn and Jacobs [11] also considered continuous casting in the multistage production process a variant of no-wait flowshop scheduling. Yuan and Jing [12] explained and affirmed the importance of the no-wait flowshop problem to steel manufacturing. Similarly, Reklaits [13] pointed out that the no-wait constraint is also suitable for the chemical industry due to its instability. Hall [14] emphasized that a similar situation also occurs in plastic molding and silver-ware industries, as well as the food processing industry [15]. In addition, there are also many other practical problems that can be solved by the assistance of being modeled as no-wait scheduling problems, such as controlling health care management costs [16], developing a metro train real-time control system [17], and so on.

In this paper, the NWFSP with makespan criterion is considered because of its universality. It minimizes the maximum completion time of the jobs ($C_{\max }$), maximizing the efficiency of machine usage [18]. The problem can be described as $F_{\mathrm{m}}|nwt|C_{\max }$ when the symbolic notation proposed by Graham [19] is applied. The first field represents the production environment, which is a flow shop with $m$ stages. The second field shows the constraints and “$nwt$“ is for “no-wait constraint”. The performance criteria occupy the third field.

The research on NWFSP began around the 1970s. Garey and Johnson [20] proved that the NWFSP is a strongly NP-hard problem when the number of machines is no less than three. At the same time, the problem was documented as NP-hard for more than two machines by Papadimitriou and Kanellakis [21]. Due to the complexity of NWFSP and the wide range of its applications, many heuristic algorithms have emerged or been tried by Bonney and Gundry [22], King and Spachis [23], Gangadharan and Rajendran [24], Laha [25], and so on, which aimed to make the solution as close as possible to the optimal within an acceptable time. In addition, exact methods [26] like branch-and-bound [27] and the column generation method [28] are widely used to obtain optimal solutions for small-scale problems. Metaheuristic algorithms, whose search mechanisms are inspired by phenomena in various fields of the real world are also active for solving NWFSP. Hall [14] and Allahverdi [29] jointly detailed the research progress of NWFSP before 2016. A typical example is the discrete particle swarm optimization algorithm [30]. In recent years, various improved or emerging metaheuristic algorithms have been used to solve the NWFSP. For example, a hybrid ant colony optimization algorithm (HACO [31]), a discrete water wave optimization algorithm (DWWO [32]), a factorial based particle swarm optimization with a population adaptation mechanism (FPAPSO [33]), a single water wave optimization (SWWO [34]), a hybrid biogeography-based optimization with variable neighborhood search (HBV [35]), a quantum-inspired cuckoo co-search (QCCS [36]) algorithm, and an improved discrete migrating birds optimization algorithm (IDMBO [37]) have also been used with good results. In 2021, Lai used the Discrete Wolf Pack Algorithm [38] to solve the NWFSP problem. Each algorithm has its own advantages, which makes it perform better than others in certain applications. In order to give full play to the advantages of each algorithm and enhance the generality of the algorithm, hyper-heuristic (HH) [39] and matheuristic [40] algorithms have appeared. The emergence of a new generation of large-scale mathematical programming optimizers such as CPLEX [41] and Gurobi [42] has greatly improved the performance of matheuristic algorithms that combine heuristic algorithms and exact algorithms. In recent years, matheuristics [43] have been widely used in scheduling problems, including NWFSP. Since NWFSP can be transformed into the ATSP [44], it is effective to incorporate more mathematical computations into its search mechanism.

Existing NWFSP researches mostly focus on designing algorithms from the perspective of instances rather than problems. The heuristic rules or the component mechanisms and parameter selections of the metaheuristics are determined by the quality of the test results, so as to balance the local search and the global search. In this way, the algorithm is dependent on the instances, and the performance of the algorithm will be different for different instances. This paper aims to explore the heuristic rules from the perspective of the problem, so that the rules show consistent effects on the instances, thereby enhancing the stability of the algorithm. Existing neighborhood structures for local search focus on insertion, swap, destruction-construction, etc., and do not divide the already searched area and the unsearched area, so the same sequence cannot avoid being tested repeatedly. Likewise, good structures are not necessarily preserved after multiple iterations. In this paper, by expanding the search domain gradually, the search process is kept in the unsearched potential areas, and the repeated calculation is reduced. The experimental results in Section 4.1 show that such a search method can also effectively preserve good structures. Exact algorithms are limited by the complexity and scale of the problem, so they are less applicable than heuristics and metaheuristics. Using heuristic rules to guide the search direction of the exact algorithm can improve the solving efficiency and increase the application scope of the exact algorithm. The experiments in Section 4.2 demonstrate that by fully exploiting the advantages of both methods, better results can be obtained than the current mainstream metaheuristic algorithms for solving NWFSP problems.

The rest of this article is organized as follows. Section 2 describes the problem of NWFSP. Section 3 proposes two heuristic algorithms for improving the solutions of NWFSP. Section 4 discusses the performance of the proposed matheuristic algorithm on two benchmarks. Section 5 summarizes the contributions of this article and provides some suggestions for future research directions.

2. No-Wait Flow Shop Scheduling Problem

Compared to FSP, NWFSP permits no interruption when a job is processed from the first stage to the last one. The details are expressed as follows.

Typically, the NWFSP includes $m$ stages, preparing for $n$ jobs to follow the same given route, where the $m$ and $n$ are determined. It also restricts only one machine at each stage, so it contains $m$ machines overall. Furthermore, the processing time of job $j$ on machine $i$ is also known and may be named as $P\left(i,j\right)$. It is natural to consider every $P\left(i,j\right)$ as the element of row $i$, column $j$ in processing time matrix $P$. One job should be processed on only one machine at the same time and it is merely allowed to be transferred to the next stage until the current work is finished; similarly, each machine cannot deal with more than one job at any time. Here, one only considers the situation of ignoring the setup time and transfer time.

2.1. Problem Description

As we known, makespan, the complete time of the last job in a sequence, is one of the indicators that directly measures economic benefits. Let ${\left(C_{\max }\right)}_{\min }$ denote the minimum makespan and its expression is shown in Equation (1). The meanings of related symbols are as follows.

The job set: $J=\left\{1,2,3,L,n|n\in Z,n\ge 1\right\}$

The machine set: $M=\left\{1,2,3,L,m|m\in Z,m\ge 1\right\}$

$\pi$ any sequence

$\mathsf{\Pi }$ the set of all possible sequence $\pi$

${\pi }_k$ the $kth$ job in the sequence $k\in Z \mathrm{and} k\ge 1$

$C_{ij}$ end time of job $j$ on machine i

$${\left(C_{\max }\right)}_{\min }=\underset{\pi \in \mathsf{\Pi }}{\min }\left(C_{m,{\pi }_n}\right)$$

(1)

$DY\left(j_1,j_2\right)$ is the delay of the job $j_2$ when it is arranged after job $j_1$, $\forall j_1,j_2\in J, j_1\ne j_2.$

$P{R}_j$ the tail value of the job $j$.

$$P{R}_j={\displaystyle \sum _{i=2}^{m}P\left(i,j\right),\forall j\in J,i\in M}$$

(2)

$P1$ the sum of the processing times of all the jobs on the first machine

$$P1={\displaystyle \sum _{j=1}^{n}P\left(1,j\right)}$$

(3)

Owing to the no-wait constraint, the delay value between two adjacent jobs is constant and can be calculated by matrix $P$. As shown in Figure 1, $C_{\max }$ has been divided into three parts and can be calculated from Equation (4). Obviously, $P1$ is a constant, so the change of $C_{\max }$ is only affected by two parts. Then, the simplified objective function was formulated in Equation (5).

$$C_{\max }={\displaystyle \sum _{j=1}^{n-1}DY\left({\pi }_j,{\pi }_{j+1}\right)}+P{R}_{{\pi }_n}+P1$$

(4)

$${C^{\prime }}_{\max }={\displaystyle \sum _{j=1}^{n-1}DY\left({\pi }_j,{\pi }_{j+1}\right)}+P{R}_{{\pi }_n}$$

(5)

2.2. Equivalent Model

Considering jobs as cities and the delay value as the distance between two cities, the NWFSP can be transformed into the ATSP. After adding virtual city/job “0”and “n + 1”, the model can be described as follows. For convenience, “0” and “n + 1” are counted as the same city, and “0” represents the starting city/job, and “n + 1” represents the ending city/job. The city/job set is $JC=\left\{0,1,2,3,L,n+1|n\in Z,n\ge 1\right\}$.

$$DY\left(0,j_2\right)=P1,\hspace{1em}{j}_2\in \left[1,n\right]$$

(6)

$$DY\left(j_1,n+1\right)=P{R}_{j_1},\hspace{1em}{j}_1\in \left[1,n\right]$$

(7)

The objective:

$$Minimize\left({\displaystyle \sum _{j_2=1}^{n}DY\left(0,j_2\right)x_{0,j_2}+}{\displaystyle \sum _{j_1=1}^n{\displaystyle \sum _{j_2=1,j_1\ne j_2}^{n+1}DY\left(j_1,j_2\right)x_{j_1,j_2}}}\right)$$

(8)

Subjected to:

$${\displaystyle \sum _{j_2=1}^n{x}_{0,j_2}}=1$$

(9)

$${\displaystyle \sum _{j_2=1,j_2\ne j_1}^{n+1}{x}_{j_1,j_2}}=1,\forall j_1\in \left[1,n\right]$$

(10)

$${\displaystyle \sum _{j_1=0,j_1\ne j_2}^n{x}_{j_1,j_2}}=1,\forall j_2\in \left[1,n\right]$$

(11)

$${\displaystyle \sum _{j_1=1}^n{x}_{j_1,n+1}=1}$$

(12)

$${\displaystyle \sum _{\begin{array}{l}{j}_1,j_2\in S, j_1\ne j_2\\ if j_1=0, then j_2\ne n+1\\ j_1\in \left[0,n\right], j_2\in \left[1,n+1\right]\end{array}}{x}_{j_1,j_2}\le \left|S\right|-1,2\le \left|S\right|}\le n,S\subset JC$$

(13)

$$x_{j_1,j_2}=\{\begin{array}{c}1\\ 0\end{array}\begin{array}{c}if j_2 is the next job/city of j_1\\ else\end{array}$$

(14)

3. The Proposed Heuristic Algorithms

The NWFSP can be transformed into the ATSP, so the path-exchange-strategy used in the Lin-Kernighan–Helsgaun (LKH) [45] algorithm is also suitable for solving NWFSP. Based on this idea, we can divide the neighborhood and construct heuristic algorithms.

3.1. Basic Neighborhood Structures

Considering the search efficiency fully, the search solution domain is initially limited to three levels, that is, Neighborhood $N2$, $N3$, $N4$. The characteristics of the three basic neighborhoods are given in

Table 1. Basic Neighborhood Features.

Name	Total Area Lines	Total Areas	Conditions for Jumping Out of the Neighborhood
N2	2	3	Being the three-exchange optimum
N3	3	4	Being the four-exchange optimum
N4	4	5	Being the five-exchange optimum

. The $n-exchange$ optimum means that the solution cannot be better by exchanging $n$ areas, which are arbitrarily divided in the sequence.

The $N2$ neighborhood is shown in Figure 2 as an example, where $L1$ and $L2$ are the two area lines and the three regions are $Aera0$, $Aera1$, $Aera2$.

3.2. Selected Potential Sub-Neighborhoods

In order to improve the search efficiency and advance the search process in more potential sub-domains, three rules are proposed and three sub-domains are selected, namely $Z2$, $Z3$, and $Z4$. The details are shown in

Table 2. Neighborhood classification.

No	Name	Level	Combinations to Be Tested for Each Sequence	Constant Job
1	Z2	A	{102}	Last job
2	Z3	B	{2103}	Last job
3	Z4	C	{03214}	First and Last job

. Two heuristic algorithms will be carried out along these three neighborhoods.

• Skipping consecutive area rule

Considering that the current solution sequence is almost derived from the last region-exchange operation, the combinations containing the adjacent area number pair (that is “01”, “12”, “23”, “34”) as a part do not temporarily need to test again.

• First and last job unchanged rules

From the experimental results, along the evolutionary direction, the job in last position is easier to have coincidence with the optimal solution because of being affected by $PR$ values. Then is the first position. When the evolution process has advanced to a certain level, the first and last job can be fixed.

• Low-Level-neighborhood first searched rule

The lower the neighborhood level, the higher the search priority. The algorithm flow chart is shown in Figure 3. “US” is the abbreviation of “Update successfully” and “UF” is the abbreviation of “Update failed”. For ease of representation, the structure in the dashed box in Figure 3 is referred to as “PHM”.

3.3. Two Heuristic Algorithms

Based on the mechanism in Figure 3, it is easy to propose two heuristic algorithms according to whether the $PR$ value characteristic is highlighted. The two heuristic algorithms HG1 and HG2 differ only in the first step, that is, the input feasible solutions are different. The details are shown in Figure 4. The advantage of HG1 is randomness. HG2 always takes the job with the smallest $PR$ value as the final job to start the search, which is more in line with the characteristics of NWFSP and can speed up the algorithm convergence.

In order to improve the utilization of historical data and improve the efficiency of neighborhood search. According to the different characteristics of the neighborhoods of $Z2$, $Z3$ and $Z4$, corresponding search algorithms are provided one by one. They are vmcmp2, vmcmp3, and vmcmp4.

3.3.1. Local Evolutionary Algorithm in Z2

Searching the only manner {102} can improve evolution speed. Without the change of $PR$, the evaluation speed is further improved. Let the size of $\Delta$ characterize the degree of improvement of the new sequence; the larger the value, the better the improvement.

$$\Delta ={C^{\prime }}_{\max }\left(CS\right)-{C^{\prime }}_{\max }\left(NS\right)=DY\left(x_1,y_1\right)+DY\left(x_2,y_2\right)-DY\left(x_2,A\right)-DY\left(x_1,y_2\right)$$

(15)

In Figure 2, it can be seen that for the same $CS$, when $L1$ and $L2$ move, $x_1$, $x_2$, $y_1$, $y_2$ are changed, but $A$, $B$ remains unchanged, which can be regarded as constants. Because the first job is stored in $A$, once the adjustment is made according to {102}, the $A$ value of the new sequence must change, and the value of $DY\left(x_2,A\right)$ will also change. As can be seen from Equation (15), in order to make full use of historical data and reduce repeated calculating, $\Delta$ is regarded as two components. The first part and the second part are respectively represented by functions $f$ and $g$, as shown in Equations (16) and (17).

$$f\left(x_2,A\right)=DY\left(x_2,A\right)$$

(16)

$$g\left(x_1,y_2\right)=DY\left(x_1,y_1\right)+DY\left(x_2,y_2\right)-DY\left(x_1,y_2\right)$$

(17)

The two-dimensional array $G$ is constructed, and the calculation result $g\left(x_1,y_2\right)$ of Equation (17) is stored in the $x_{1}th$ row and the $y_{2}th$ column of $G$. Such an operation can ensure that after the sequence is updated, the intermediate result $G$ only needs to recalculate part of the data. For the convenience of description, several definitions are given below.

Definition 1

(Point). Adjacent job pair makes up a point. If $\left(x_1,y_1\right)$ is a point,  $x_1$ is the predecessor job of  $y_1$, and  $y_1$ is the successor job of  $x_1$.

Definition 2

(Single-point Attribute (SPA)). The function value calculated by a point only or with information of a stable job. For example, function $f$ is the single-point attribute of the point  $\left(x_2,y_2\right)$, where  $A$ is the stable job.

Definition 3

(Double-point Attribute (DPA)). The function value is calculated by two points and reflects the relationship of four related jobs. For example, function $g$ is the double-point attribute of point  $\left(x_1,y_1\right)$ and point  $\left(x_2,y_2\right)$.

When traversing $\left(L1,L2\right)$, function $f$ is associated with the attributes of job $x_2$ which belongs to the second point $\left(x_2,y_2\right)$. But in essence, $x_2$ is still a job in $CS$. If the index number of the first job in the sequence is 0, then the index range of $x_2$ is $\left[1,n-2\right]$ (denote the index of $x_2$ in the sequence as $L\left(x_2\right)$, then $L\left(x_2\right)\in \left[1,n-2\right]$). Function $f$ is seen as the single-point attributes of the jobs whose index ranges from 1 to $n-2$. Once $CS$ is given, we can directly calculate the function $f$. It can be seen from the characteristics of the double-point attribute that if the two points do not change, then their DPAs do not change. That is, as long as the con1 is met, the saved values in $G$ need not be updated, and the calculation speed can be increased.

The con1 is described as follows.

First, the jobs $x_1$ and $y_2$ remain in the original pair order, that is, in the sequence $NS$, and $x_1$ is still on the left side of $y_2$.

Second, to find the $g$ value of the job $x$ and job $y$, that is, in $g\left(x,y\right)$, x cannot be equal to $x_1$ or $x_2$ in the last operation; $y$ cannot be equal to $y_1$ or $y_2$.

The local optimal algorithm (Algorithm 1) for $Z2$ is described as follows.

Algorithm 1. vmcmp2(con1)// Search {102} only

Step 1. compute all the SPAs in CS, that is, all the $f$

Step 2. compute all the DPAs in CS, that is, all the $g$

Step 3. $({\Delta }_{\max }{,x}_1{,x}_2)={\left(g-f\right)}_{\max }$//Save the best positions to ${ x}_1 {\mathrm{and} x}_2$ which provide the ${\Delta }_{\max }$

Step 4. if $({\Delta }_{\max }>0)$

L1 = $x_1$ and L2 = $x_2$

CS=CS ({102})//Perform operation {102} on CS to update CS

update ($f$); //Recalculate all the f values

update ($g$, $con1$); // Recalculate g values that do not meet con1

jump to Step 3

end if

else// CS is the best of Z2 now

Stop searching in Z2

end else

3.3.2. Local Evolutionary Algorithm in Z3

Since the first job and the last job are constant, the point attribute can be used with the historical data to optimize the algorithm. Figure 5 shows the evolution form of “0213”, from which Equation (20) can be obtained.

Where $SD\left(j_1,j_2\right)$ represents the sum of the delay values of all the jobs from the job $j_1$ to the job $j_2$ in the current sequence. Equation (20) is the sum of the expressions in the three brackets, and the three sub-expressions, which can be seen as DPAs are in a rotation-symmetric relationship. Parentheses 1 and 2 can share the function $f_1$. Parenthesis 3 is denoted as function $f_2$.

$${C^{\prime }}_{\max }\left(CS\right)=SD\left(A,x_1\right)+DY\left(x_1,y_1\right)+SD\left(y_1,x_2\right)+DY\left(x_2,y_2\right)+SD\left(y_2,x_3\right)+DY\left(x_3,y_3\right)+SD\left(y_3,B\right)+PR\left(B\right)$$

(18)

$${C^{\prime }}_{\max }\left(NS\right)=SD\left(A,x_1\right)+DY\left(x_1,y_2\right)+SD\left(y_2,x_3\right)+DY\left(x_3,y_1\right)+SD\left(y_1,x_2\right)+DY\left(x_2,y_3\right)+SD\left(y_3,B\right)+PR\left(B\right)$$

(19)

$$\Delta \left(0213\right)={C^{\prime }}_{\max }\left(CS\right)-{C^{\prime }}_{\max }\left(NS\right)=\left[DY\left(x_1,y_1\right)-DY\left(x_1,y_2\right)\right]+\left[DY\left(x_2,y_2\right)-DY\left(x_2,y_3\right)\right]+\left[DY\left(x_3,y_3\right)-DY\left(x_3,y_1\right)\right]$$

(20)

$f_1$ and $f_2$ are considered as functions of the job numbers and the function values are saved. See Equations (21) and (22) for details.

$$\{\begin{array}{c}{f}_1\left(x_a,y_b\right)=DY\left(x_a,y_a\right)-DY\left(x_a,y_b\right)\\ L(x_a)\in \left[0,n-3\right],L(y_b)\in \left[2,n-1\right],and L(x_a)+1<L(y_b)\end{array}$$

(21)

$$\{\begin{array}{c}{f}_2\left(x_b,y_a\right)=DY\left(x_b,y_b\right)-DY\left(x_b,y_a\right)\\ L(x_b)\in \left[2,n-2\right],L(y_a)\in \left[1,n-3\right],and L(x_b)>L(y_a)-1\end{array}$$

(22)

Compute and save each $f_1\left(x_a,y_b\right)$ value to the $x_{a}th$ row, $y_{b}th$ column of the two-dimensional array $G1$. Assume point1 $\left(x_a,y_a\right)$, point2 $\left(x_b,y_b\right)$, point3 $\left(x_c,y_c\right)$, then Equation (20) can be replaced by Equation (23) to reduce double counting.

$$\{\begin{array}{c}\Delta \left(0213\right)=f_1\left(x_a,y_b\right)+f_1\left(x_b,y_c\right)+f_2\left(x_c,y_a\right)\\ L(x_a)\in [0,n-4],L(x_b)\in [1,n-3],L(x_c)\in [2,n-2],and L(x_a)<L(x_b)<L(x_c)\end{array}$$

(23)

In contrast to the search in $S3$, there is only one combination to try, so compute all $\Delta \left(0213\right)$ and choose the biggest improvement. If all $\Delta \left(0213\right)$ is computed but only updated at most once, the utilization rate of historical data is too low. Then Multiple Iterations in One step (MIO) is proposed to improve this situation.

Traverse the Z3 neighborhood of CS, the specific method is to calculate by Formula 23, and save all the values greater than 0 in $DY0$. In Figure 6, $DY0$ is a multiset that sorts the results according to its $\Delta$ values, from largest to smallest, and itRS7 is the iterator of $DY0$.

.

Suppose there is a NWFSP with $n=12$, and the $DY0$ is shown in Figure 6. As shown in Figure 7, its current solution is $C{S}^{\left(0\right)}=\left\{0,1,2,3,4,5,6,7,8,9,10,11\right\}$.

Take out the element pointed to by the iterator $itRS7$, that is $\left(T_1,T_2,T_3\right)$.Then the evolution process can be seen in Figure 8. The indices of points (1, 2), (3, 4), (10, 11) in the sequence are respectively recorded as $T_1,T_2,T_3$. In Figure 6, $\left(T_1,T_2,T_3\right)$ means $T_1<T_2<T_3$.

Because of the constant last job, the $PR$ is constant too. Then the essence of every evolution manner is the change of boundary values. Combining Figure 6 and Figure 7, we can draw the conclusions of

Table 3. Changed Paths of Boundary Values.

Evolution Manner	Changed Paths of Boundary Values
(T1, T2, T3)	DY(1,2) + DY(3,4) + DY(10,11)→DY(1,4) + DY(3,11) + DY(10,2)
(Z1, Z2, Z3)	DY(2,3) + DY(6,7) + DY(8,9)→DY(2,7) + DY(6,9) + DY(8,3)
(R1, R2, R3)	DY(1,2) + DY(7,8) + DY(9,10)→DY(1,8) + DY(7,10) + DY(9,2)

.

It is easy to see from Table 3 that no matter how many iterations are completed, as long as the changed path of boundary values still exist, evolution in this direction will succeed.

It can be seen from Figure 9 that after two iterations, the corresponding point of $R_1$ cannot be found in $C{S}^{\left(2\right)}$ at this time, so it cannot be evolved in this way. Next, derive the conditions con2 whose paths still exist after iterations, as shown in

Table 4. Conditions for con2.

Conditions for the Establishment of con2
1. Same points constraint.
The same 3 points can be found both in sequence before and after the iteration.
Suppose their corresponding relationship is: (Z1, Z2, Z3)→(Z1′, Z2′, Z3′)
2. Position constraint.
Z1′ < Z2′ < Z3′ or Z2′ < Z3′ < Z1′ or Z3′ < Z1′< Z2′ (if Z1 < Z2 < Z3)

.

Traverse $DY0$ and determine whether each element meets the con2 in turn. If one is satisfied, it is applicable and the iteration can be completed directly. Therefore, $DY0$ is calculated only once, and there is a chance to iterate multiple times. The algorithm (Algorithm 2) vmcmp3(con2) suitable for $Z3$ is described as follows.

Algorithm 2. vmcmp3(con2)

Step 1. Input ${ CS}^{\left(0\right)}$, record Loc (j, ${CS}^{\left(0\right)}$) and save them to vector k1, Let its jth element, k1(j) to save the location of job j in ${CS}^{\left(0\right)}$

Step 2. flag = 0// Set the initial value of the flag

Step 3. Compute and save $f1$, $f2$, then compute $\Delta$ and save them to multiset DY0 when $\Delta >0$.

Step 4. if (DY0.size()! = 0) // if DY0 is not empty

for itRS7 = DY0.begin() to DY0.end ()-1)// Traverse DY0 by itRS7

if(con2) //If con2 is met

CS= update (itRS7, {2013}, CS);// According the locations

//provided by DY0, give CS a {2013} operation

flag=1// Updated successfully

update (Loc (j, CS)); // Save the new correspondence of location //and job number

end if(con2)

end for

end if

else

flag=2

end else

if flag==1 // When update successfully

jump to Step2

end if

else // When update failed

Stop searching in Z3

end else

3.3.3. Local Evolutionary Algorithm in Z4

Experiments show that the combination {03214} has a higher hit rate. Its main feature is that the first and last jobs are not changed. The Figure 10 shows the evolution form.

Still, start with the expression of $\Delta \left(03214\right)$, specific as shown in Equations (24)–(26).

$$\begin{array}{l}{C^{\prime }}_{\max }\left(CS\right)=SD\left(A,x_1\right)+DY\left(x_1,y_1\right)+SD\left(y_1,x_2\right)+DY\left(x_2,y_2\right)+SD\left(y_2,x_3\right)\\ \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{0.17em}+DY\left(x_3,y_3\right)+SD\left(y_3,x_4\right)+DY\left(x_4,y_4\right)+SD\left(y_4,B\right)+PR\left(B\right)\end{array}$$

(24)

$$\begin{array}{l}{C^{\prime }}_{\max }\left(NS\right)=SD\left(A,x_1\right)+DY\left(x_1,y_3\right)+SD\left(y_3,x_4\right)+DY\left(x_4,y_2\right)+SD\left(y_2,x_3\right)\\ \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{0.17em}+DY\left(x_3,y_1\right)+SD\left(y_1,x_2\right)+DY\left(x_2,y_4\right)+SD\left(y_4,B\right)+PR\left(B\right)\end{array}$$

(25)

$$\begin{array}{l}\Delta \left(03214\right)={C^{\prime }}_{\max }\left(CS\right)-{C^{\prime }}_{\max }\left(NS\right)\\ =DY\left(x_1,y_1\right)+DY\left(x_2,y_2\right)+DY\left(x_3,y_3\right)+DY\left(x_4,y_4\right)-DY\left(x_1,y_3\right)-DY\left(x_4,y_2\right)-DY\left(x_3,y_1\right)-DY\left(x_2,y_4\right)\\ =\left[DY\left(x_1,y_1\right)+DY\left(x_3,y_3\right)-DY\left(x_1,y_3\right)-DY\left(x_3,y_1\right)\right]+\left[DY\left(x_2,y_2\right)+DY\left(x_4,y_4\right)-DY\left(x_4,y_2\right)-DY\left(x_2,y_4\right)\right]\end{array}$$

(26)

Similarly, using Equation (27) to uniformly calculate the two parts separated by parentheses in Equation (26) can simplify the calculation. Let $\Delta \left(03214\right)$ be $V\left(x_a,y_b\right)$ here.

$$\{\begin{array}{c}V\left(x_a,y_b\right)=DY\left(x_a,y_a\right)+DY\left(x_b,y_b\right)-DY\left(x_a,y_b\right)-DY\left(x_b,y_a\right)\\ L(x_a)\in \left[0,n-4\right],L(y_b)\in \left[3,n-1\right],and L(x_a)<L(y_b)-1 \end{array}$$

(27)

Compute all the results by Equation (27) and save them in multiset $RS2$.

Use two iterators, $it1$ and $it2$ to traverse $RS2$. Then select all the elements that meet the condition of con3, and store them in multiset $JSF$. See Figure 11 and Figure 12 for details.

$JSF$ collects all successful evolution paths. Its iterator is itRS9 in Figure 12 ($T_1<T_2<T_3<T_4$). Suppose the variables saved by a single element in $RS2$ are $DOT1$ and $DOT2$, then the conditions for con3 to be established are shown in

Table 5. Conditions for con3.

Conditions for the establishment of con3
1. Greater than 0 constraint, that is, DV > 0, where DV = it1.V + it2.V
2. Position constraint.  it1.DOT1 < it2.DOT1< it1.DOT2< it2.DOT2 or it2.DOT1 < it1.DOT1< it2.DOT2< it1.DOT2

.

Similarly, use MIO Strategy to construct an algorithm (Algorithm 3) to speed up the search process.

Algorithm 3. vmcmp4(con3, con4)

Step 1. Input ${CS}^{\left(0\right)}$, record Loc (j, ${CS}^{\left(0\right)}$) and save them to vector k1, Let its jth element, k1(j) to save the location of job j in ${CS}^{\left(0\right)}$

Step 2. flag = 0// Set the initial value of the flag

Step 3. for $x_A$ = 0 to n-4 // The union of the ranges L1 and L2

for $y_B$ = 3 to n − 1// The union of the ranges L3 and L4

cmpRS2($x_A$,$y_B$)//compute the DPAs of ($x_A$, $y_A$, $x_B$, $y_B$) and save them in RS2

end for // End the inner loop

end for// End outer loop

Step 4. it1begin = RS2.begin()

it2begin = it1 + 1 // Assign initial values to iterators it1 and it2

for it1 = it1begin to it1end

for it2 = it2begin to it2end // Double loop for traverse RS2

if (con3(it1, it2)) //If the elements pointed to by it1 and it2 satisfy con3

JSF. insert (it1, it2)//Save the evolution path provided

//by the elements which are pointed to by it1 and it2 in JSF

end if

end for// End the inner loop

end for// End outer loop

Step 5. if (JSF. size ()$\ne$0)//If JSF is not empty, it means that ${ CS}^{\left(0\right)}$ can be

//updated in its neighborhood Z4

for itJSF9 = JSF. begin () to JSF. end ()−1 //Traverse multiset JSF

//which is the neighborhood Z4 of ${CS}^{\left(0\right)}$

if (con4(itJSF9))//If the element pointed to by itJSF9 satisfies the con4

CS = update (JSF9, {03214}, CS)//Update CS as specified by JSF9

update (Loc (j, CS)); // Save the new correspondence of

//location and job number

flag = 1; // Assign 1 to the flag bit

end if

end for

end if

else

flag = 2

end else

if flag == 1// If there is an update in this round

jump to Step2

end if

else// This round of searching this ${CS}^{\left(0\right)}$ in Z4 has not been updated

Stop searching in Z4

end else

Let the condition that satisfies MIO in Z4 be con4. If con4 in the algorithm is to be established, two conditions must be met, as shown in

Table 6. Conditions for con3.

Conditions for the Establishment of con4
1. Same points constraint.  The same 4 points can be found both in sequence before and after the iteration.  Suppose their corresponding relationship is: (Z1, Z2, Z3, Z4)→(Z1′, Z2′, Z3′, Z4′)
2. Position constraint.  Suppose (1, 2, 3, 4, DV) is taken from JSF, then rearrange them from small to large according to their position numbers in the NS. There are 8 orders that satisfies the position constraint, that is {4321, 4123, 3412, 3214, 2341, 2143, 1234, 1432}

.

3.4. Experimental Results of the Two Heuristic Algorithms

Use HG1 and HG2 to solve Tailard (TA) benchmark. Then record the calculation results in

Table 7. Results of HGs on Tailard Benchmark (TA).

TA	HG1		HG2		TA	HG1		HG2		TA	HG1		HG2		TA	HG1		HG2
	CHG1	$\stackrel{\_\_\_\_\_}{\mathit{R}\mathit{P}\mathit{I}}$	CHG2	$\stackrel{\_\_\_\_\_}{\mathit{R}\mathit{P}\mathit{I}}$		CHG1	$\stackrel{\_\_\_\_\_}{\mathit{R}\mathit{P}\mathit{I}}$	CHG2	$\stackrel{\_\_\_\_\_}{\mathit{R}\mathit{P}\mathit{I}}$		CHG1	$\stackrel{\_\_\_\_\_}{\mathit{R}\mathit{P}\mathit{I}}$	CHG2	$\stackrel{\_\_\_\_\_}{\mathit{R}\mathit{P}\mathit{I}}$		CHG1	$\stackrel{\_\_\_\_\_}{\mathit{R}\mathit{P}\mathit{I}}$	CHG2	$\stackrel{\_\_\_\_\_}{\mathit{R}\mathit{P}\mathit{I}}$
01	1505	4.10	1509	0.8	31	3220	2.23	3198	0.83	61	6488	1.92	6453	0.82	91	15523	2.08	15401	0.92
02	1590		1528		32	3467		3490		62	6333		6264		92	15326		15164
03	1586		1462		33	3310		3247		63	6232		6138		93	15536		15352
04	1634		1588		34	3424		3354		64	6148		6055		94	15303		15221
05	1482		1449		35	3398		3392		65	6274		6240		95	15379		15194
06	1522		1502		36	3403		3360		66	6203		6099		96	15328		15129
07	1561		1515		37	3292		3251		67	6326		6267		97	15643		15418
08	1548		1521		38	3336		3268		68	6210		6144		98	15467		15245
09	1577		1470		39	3162		3082		69	6487		6412		99	15320		15130
10	1405		1377		40	3407		3324		70	6445		6401		100	15573		15386
11	2228	5.40	2153	2.58	41	4448	3.40	4283	1.42	71	8214	2.50	8122	1.10	101	19773	2.18	19840	1.61
12	2248		2230		42	4372		4234		72	8084		7959		102	20331		20179
13	2051		1987		43	4300		4170		73	8267		8084		103	19998		19986
14	1945		1811		44	4477		4513		74	8538		8430		104	20297		20122
15	2077		2070		45	4340		4340		75	8049		8014		105	20233		19962
16	1925		1955		46	4390		4330		76	7952		7875		106	20329		20148
17	2031		1990		47	4653		4496		77	8123		7966		107	20478		20478
18	2145		2068		48	4555		4361		78	8100		7957		108	20238		20117
19	2120		1992		49	4270		4255		79	8331		8199		109	20319		20233
20	2126		2088		50	4381		4359		80	8247		8179		110	20195		20006
21	3102	5.39	3001	1.45	51	6260	4.07	6210	1.70	81	11092	3.01	10799	1.12	111	47034	1.71	46600	1.28
22	3128		2878		52	5990		5935		82	10904		10786		112	47561		47219
23	3090		3027		53	6098		5972		83	10783		10631		113	46922		46820
24	3275		3004		54	6001		5883		84	10938		10744		114	47131		47108
25	3137		3071		55	6177		5924		85	10762		10629		115	46879		46728
26	3132		3022		56	6205		5919		86	10898		10702		116	47276		47095
27	3193		3116		57	6247		6042		87	11128		10880		117	46592		46503
28	3036		2876		58	6079		6112		88	11147		10907		118	47098		46977
29	3199		3156		59	6116		5949		89	11101		10843		119	47028		46870
30	3019		3002		60	6194		6024		90	11039		10855		120	47243		46824

. The heuristic algorithms were coded in C++. All the experiments executed in Windows 10 on a desktop PC with an 11th Gen Intel(R) Core (TM) i7-1165G7 (2.80GHz) processor and 16.0 GB RAM. The calculation formula of RPI (Relative Percentage Increase) and $\stackrel{\_\_\_\_\_}{RPI}$ are shown in Equations (28) and (29), where $C_{(opt,a1)}$ refers to the optimal $C_{\max }$ of instance a1. $C_{(i1,a1)}$ refers to the result of algorithm i1 to solve the instance a1.

$$RPI\left(i1,a1\right)=\frac{C_{(i1,a1)}-C_{(opt,a1)}}{C_{(opt,a1)}}\times 100$$

(28)

$$\{\begin{array}{c}\stackrel{\_\_\_\_\_}{RPI}{|}_{from b \mathrm{to} \mathrm{b}+9 }=\frac{{\displaystyle \sum _{a1=b}^{a1=b+9}RPI\left(i_1,a1\right)}}{10}\times 100\\ b\in \left\{1,11,21,31,41,51,61,71,81,91,101,111\right\}\end{array}$$

(29)

In Table 7, HG2 has a smaller $\stackrel{\_\_\_\_\_}{RPI}$ value than HG1 in all scale instances; its fluctuation range is from 0.8% to 2.58%, the maximum $\stackrel{\_\_\_\_\_}{RPI}$ value of 2.58% appears on the small-scale instances (scale is 20 × 10), while its $\stackrel{\_\_\_\_\_}{RPI}$ value on the largest-scale instances (500 × 20) is only 1.28%. On the whole, it performs better for large-scale instances. The average $\stackrel{\_\_\_\_\_}{RPI}$ is 1.30%, and the fluctuation is not large, indicating that the algorithm has strong local search ability, and can quickly converge to a local optimal solution regardless of the scale, with stable performance.

It can be seen from Table 7 that out of 120 instances, HG1 only exceeds HG2 in 6 instances (the part in bold in the table). Therefore, for the goal of approximating the optimal value, the effect of the HG2 algorithm constructed by introducing the $PR$ value is much better than that of HG1, and even HG2 directly obtains the optimum on some small-scale instances (the part in italics in the table). Taking “TA 05” as an example, its Gantt chart is shown in Figure 13. If the result of HG1 is imported into Gurobi, another set of optimal solution sequences can be obtained. This Gantt chart is shown in Figure 14. Therefore, the use of different heuristic algorithms is effective for the breadth search. The same job-blocks in the HG1 sequence and the HG2 sequence can also be considered as high-quality structures by comparing them with the optimal solution sequence. Therefore, the heuristic algorithms can easily construct multiple high-quality solutions. Arrange the jobs according to their $PR$ values from small to large, take them as the last job in turn, and then perform the PHM operation.

Similarly, we used HG1 and HG2 to solve Reeves (REC) benchmark. The results are recorded in

Table 8. Results of HGs on REC.

REC	HG1		HG2		REC	HG1		HG2		REC	HG1		HG2		REC	HG1		HG2
	CHG1	$\mathit{R}\mathit{P}\mathit{I}$	CHG2	$\mathit{R}\mathit{P}\mathit{I}$		CHG1	$\mathit{R}\mathit{P}\mathit{I}$	CHG2	$\mathit{R}\mathit{P}\mathit{I}$		CHG1	$\mathit{R}\mathit{P}\mathit{I}$	CHG2	$\mathit{R}\mathit{P}\mathit{I}$		CHG1	$\mathit{R}\mathit{P}\mathit{I}$	CHG2	$\mathit{R}\mathit{P}\mathit{I}$
01	1658	8.65	1534	0.52	13	2748	7.98	2653	4.24	25	3841	6.90	3669	2.12	37	8109	1.26	8079	0.89
03	1364	0.22	1361	0.00	15	2693	6.48	2597	2.69	27	3633	5.89	3531	2.91	39	8689	3.21	8569	1.78
05	1614	6.82	1545	2.25	17	2657	2.71	2657	2.71	29	3544	7.69	3380	2.70	41	8719	3.34	8543	1.26
07	2066	1.18	2066	1.18	19	3009	5.58	2906	1.96	31	4412	2.44	4383	1.76
09	2167	6.12	2066	1.18	21	2866	1.60	2835	0.50	33	4558	3.03	4477	1.20
11	2010	6.86	2011	6.91	23	2849	5.52	2719	0.70	35	4651	5.78	4407	0.23

.

On this benchmark, the values obtained by HG2 are also better than that obtained by HG1. Except for REC11, HG1 does not get a better $C_{\max }$ than HG2, and HG2 even gets the optimal solution on REC03. Obviously, the effect of HG2 is better than that of HG1, so HG2 was selected to participate in the calculation in subsequent studies.

4. Solving the Model with Matheuristic Algorithms

4.1. Test on Small-Scale Instances with MTZ Model

When Gurobi solves the NWFSP problem, if all constraints are added directly at the beginning of the optimization, the solution performance will be greatly reduced, for example, when the famous Miller-Tucker-Zemlin model [46] (Formulas (6)–(12), Equation (14) and Formula (30)) is used directly. However, the model has high research value [47]. We combine the heuristic algorithm to improve the efficiency.

$$\{\begin{array}{c}{\mu }_{j_1}-{\mu }_{j_2}+n\times x_{j_1,j_2}\le n-1\\ {\mu }_j\ge 0\end{array}$$

(30)

Using Gurobi (The version is 9.1.2.) to solve this model directly, the results are shown in

Table 9. Results of MTZ model on REC (tolerance is 10⁻⁴).

REC	$\mathit{R}\mathit{P}\mathit{I}(\%)$	Time(s)	REC	$\mathit{R}\mathit{P}\mathit{I}(\%)$	Time(s)	REC	$\mathit{R}\mathit{P}\mathit{I}(\%)$	Time(s)	REC	$\mathit{R}\mathit{P}\mathit{I}(\%)$	Time(s)
01	0	0.05	13	0	0.10	25	0	0.13	37	0	0.77
03	0	0.08	15	0	0.08	27	0	9.50	39	0	1.06
05	0	0.07	17	0	0.20	29	0	0.13	41	0	9.51
07	0	0.26	19	0	0.11	31	0	0.35
09	0	0.10	21	0	2.39	33	0	0.24
11	0	0.04	23	0	0.11	35	0	0.37

and

Table 10. Results of MTZ model on TA01–TA60 (tolerance is 10⁻⁴).

TA	$\mathit{R}\mathit{P}\mathit{I}(\%)$	Time(s)	TA	$\mathit{R}\mathit{P}\mathit{I}(\%)$	Time(s)	TA	$\mathit{R}\mathit{P}\mathit{I}(\%)$	Time(s)	TA	$\mathit{R}\mathit{P}\mathit{I}(\%)$	Time(s)	TA	$\mathit{R}\mathit{P}\mathit{I}(\%)$	Time(s)
01	0	0.18	13	0	0.34	25	0	0.29	37	NA	36,000	49	0	72.10
02	0	971.08	14	0	0.05	26	0	0.30	38	0	0.29	50	0	0.72
03	0	0.05	15	0	0.04	27	0	0.15	39	0	0.37	51	0	0.98
04	0	0.05	16	0	0.09	28	0	0.07	40	0	0.21	52	0	0.84
05	0	0.10	17	0	0.21	29	0	0.08	41	0	0.41	53	0	0.27
06	0	0.11	18	0	0.07	30	0	0.10	42	0	0.37	54	0	8.01
07	0	0.05	19	0	0.05	31	0	0.36	43	0	0.37	55	0	0.68
08	0	0.06	20	0	59.29	32	0	1.17	44	0	0.38	56	0	0.66
09	0	0.05	21	0	0.39	33	0	18.69	45	0	0.61	57	0	0.56
10	0	0.07	22	0	0.49	34	0	0.47	46	0	0.31	58	0	0.42
11	0	0.23	23	0	0.24	35	0	0.35	47	0	0.63	59	0	1.28
12	0	0.26	24	0	0.14	36	0	0.24	48	0	154.33	60	0	0.47

. Among them, TA02 takes a longer time, and TA37 has not completed the calculation within 36,000 s.

We select those instances (T > 7s) with longer solution times, and combine heuristics to improve efficiency. NA (not a number) indicates that the calculation has not been completed within 36,000 s.

The method of importing only the result (named as S2) of HG2 as an initial feasible solution to the optimizer is called MH2, then the solution efficiency for instances marked in italics is improved.

Since NWFSP is solved by transforming it into an ATSP problem, i.e., the solution satisfies the characteristic of a “loop”. We choose the last three jobs in S2 to join the first three jobs to form a test sequence. The test sequence is shown in Formula (31).

$$\left\{S2[n-2],S2[n-1],S2[n],S2[1],S2[2],S2[3]\right\}$$

(31)

Using adjacent job pairs in the test sequence as constraints one by one, test the running time separately (if a single test exceeds 10s, test the next job pair or end the test). Among the results satisfying RPI = 0, select the best (the one with the shortest running time) as the improvement value and store it in the IMH2 column of

Table 11. Comparison Results of MH2, IMH2 and MTZ only (tolerance is 10⁻⁴).

Ins	$\mathit{R}\mathit{P}\mathit{I}$	${\mathit{T}}_{\mathit{M}\mathit{T}\mathit{Z}}\left(\mathit{s}\right)$	$\mathit{R}\mathit{P}\mathit{I}$	${\mathit{T}}_{\mathit{M}\mathit{H}2}\left(\mathit{s}\right)$	$\mathit{R}\mathit{P}\mathit{I}$	${\mathit{T}}_{\mathit{I}\mathit{M}\mathit{H}2}\left(\mathit{s}\right)$	${\mathit{T}}_{\mathit{M}\mathit{T}\mathit{Z}}/{\mathit{T}}_{\mathit{I}\mathit{M}\mathit{H}2}$
REC27	0	9.50	0	7.22	0	0.13	73.08
REC41	0	9.51	0	2.87	0	0.76	12.51
TA02	0	971.08	0	1726.03	0	0.05	19,421.60
TA20	0	59.29	0	63.50	0	0.08	741.13
TA33	0	18.69	0	6.29	0	5.35	3.49
TA37	NA	>36,000	NA	>36,000	0	0.51	>70,588.24
TA48	0	154.33	0	160.55	0	0.33	467.67
TA49	0	72.10	0	39.87	0	7.07	10.20
TA54	0	8.01	0	10.41	0	5.94	1.35

. It can be seen that the speed of solving other instances in Table 11 are also improved to varying degrees (the last column in Table 11). This shows that the matheuristic method is effective.

4.2. Comparison Results of MH2 and Other Algorithms

While we used the matheuristic in the previous subsection to improve the efficiency of the MTZ model, the strategy of dynamically adding constraints using callback functions when solving large-scale instances has greater advantages. We use this strategy to solve the proposed model (Formula 6-Formula 14), also naming the mathematic algorithm that introduces HG2 as MH2. The comparison results of MH2, DWWO [32], SWWO [34], and IDMBO [37] are shown in

Table 12. Comparison Results of MH2, IDMBO, DWWO, and SWWO on TA.

n × m	$\stackrel{\_\_\_\_\_}{\mathit{o}\mathit{p}\mathit{t}.}$	MH2		IDMBO [37]				DWWO [32]				SWWO [34]
		$\begin{array}{c}\stackrel{\_\_\_\_\_\_\_\_}{\mathit{R}\mathit{P}\mathit{I}}\\ \left(\mathit{\%}\right)\end{array}$	$\begin{array}{c}\stackrel{\_\_\_\_\_\_\_\_}{\mathit{T}\mathit{i}\mathit{m}\mathit{e}}\\ \left(\mathit{s}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathbf{min}}}\\ \left(\mathit{\%}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathit{A}\mathit{v}\mathit{g}}}\\ \left(\mathit{\%}\right)\end{array}$	$\stackrel{\_\_\_}{\mathit{S}\mathit{D}}$	$\begin{array}{c}\stackrel{\_\_\_\_\_\_\_\_}{\mathit{T}\mathit{i}\mathit{m}\mathit{e}}\\ \left(\mathit{s}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathbf{min}}}\\ \left(\mathit{\%}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathit{A}\mathit{v}\mathit{g}}}\\ \left(\mathit{\%}\right)\end{array}$	$\stackrel{\_\_\_}{\mathit{S}\mathit{D}}$	$\begin{array}{c}\stackrel{\_\_\_\_\_\_\_\_}{\mathit{T}\mathit{i}\mathit{m}\mathit{e}}\\ \left(\mathit{s}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathbf{min}}}\\ \left(\mathit{\%}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathit{A}\mathit{v}\mathit{g}}}\\ \left(\mathit{\%}\right)\end{array}$	$\stackrel{\_\_\_}{\mathit{S}\mathit{D}}$	$\begin{array}{c}\stackrel{\_\_\_\_\_\_\_\_}{\mathit{T}\mathit{i}\mathit{m}\mathit{e}}\\ \left(\mathit{s}\right)\end{array}$
20 × 5	1480.3	0	0.04	0	0.05	0.58	4.50	0	0	0.04	4.50	0	0	0	4.50
20 × 10	1983	0	0.08	0.02	0.08	0.77	9.00	0	0.12	0.12	9.00	0	0	0.04	9.00
20 × 20	2971.9	0	0.11	0	0.02	0.39	18.01	0	0.01	0.45	18.01	0.03	0.03	0.32	18.00
50 × 5	3269.5	0	0.18	1.62	1.91	6.86	11.26	0.83	1.09	6.54	11.27	0.02	0.12	2.32	11.25
50 × 10	4273.6	0	0.29	0.38	0.70	9.58	22.51	0.20	0.37	5.64	22.51	0.03	0.08	1.85	22.50
50 × 20	5897.4	0	0.64	0.23	0.43	9.04	45.01	0.10	0.28	9.59	44.21	0.01	0.06	2.93	45.00
100 × 5	6196.1	0	0.99	3.68	4.17	20.42	22.53	3.80	4.27	20.98	22.51	0.34	0.52	8.45	22.50
100 × 10	7991	0	1.56	1.90	2.23	20.39	45.03	1.65	1.98	18.47	45.01	0.28	0.44	10.13	45.00
100 × 20	10,658.5	0	2.11	1.13	1.49	24.31	90.03	1.07	1.28	16.76	90.01	0.29	0.40	10.12	90.08
200 × 10	15,124.7	0	6.39	4.14	4.42	29.88	90.07	5.27	5.61	36.87	90.02	1.09	1.34	25.62	90.00
200 × 20	19,788.4	0	10.55	2.85	3.13	39.49	180.07	3.42	3.77	46.20	180.02	1.00	1.19	27.51	180.00
500 × 20	46,284.1	0	112.82	4.92	5.10	57.91	450.21	6.36	6.58	69.18	450.10	2.31	2.53	77.71	450.02

and

Table 13. Comparison Results of MH2, IDMBO, DWWO, and SWWO on REC.

REC	opt.	MH2		IDMBO [37]				DWWO [32]				SWWO [34]
		$\begin{array}{c}\stackrel{\_\_\_\_\_\_\_\_}{\mathit{R}\mathit{P}\mathit{I}}\\ \left(\mathit{\%}\right)\end{array}$	$\begin{array}{c}\stackrel{\_\_\_\_\_\_\_\_}{\mathit{T}\mathit{i}\mathit{m}\mathit{e}}\\ \left(\mathit{s}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathbf{min}}}\\ \left(\mathit{\%}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathit{A}\mathit{v}\mathit{g}}}\\ \left(\mathit{\%}\right)\end{array}$	$\stackrel{\_\_\_}{\mathit{S}\mathit{D}}$	$\begin{array}{c}\stackrel{\_\_\_\_\_\_\_\_}{\mathit{T}\mathit{i}\mathit{m}\mathit{e}}\\ \left(\mathit{s}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathbf{min}}}\\ \left(\mathit{\%}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathit{A}\mathit{v}\mathit{g}}}\\ \left(\mathit{\%}\right)\end{array}$	$\stackrel{\_\_\_}{\mathit{S}\mathit{D}}$	$\begin{array}{c}\stackrel{\_\_\_\_\_\_\_\_}{\mathit{T}\mathit{i}\mathit{m}\mathit{e}}\\ \left(\mathit{s}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathbf{min}}}\\ \left(\mathit{\%}\right)\end{array}$	$\begin{array}{l}\stackrel{\_\_\_}{{\mathsf{\Delta }}_{\mathit{A}\mathit{v}\mathit{g}}}\\ \left(\mathit{\%}\right)\end{array}$	$\stackrel{\_\_\_}{\mathit{S}\mathit{D}}$	$\begin{array}{c}\stackrel{\_\_\_\_\_\_\_\_}{\mathit{T}\mathit{i}\mathit{m}\mathit{e}}\\ \left(\mathit{s}\right)\end{array}$
01	1526	0	0.08	0	0	0	4.50	0	0	0	4.50	0	0	0	4.50
03	1361	0	0.03	0	0	0	4.50	0	0	0	4.50	0	0	0	4.50
05	1511	0	0.06	0	0.08	1.47	4.50	0	0	0	4.50	0	0	0	4.50
07	2042	0	0.13	0	0	0	9.01	0	0	0	9.00	0	0	0	9.00
09	2042	0	0.05	0	0.04	0.40	9.00	0	0	0	9.00	0	0	0	9.00
11	1881	0	0.04	0	0	0	9.00	0	0	0	9.00	0	0	0	9.00
13	2545	0	0.07	0	0	0	13.51	0	0	0	13.51	0	0	0	13.50
15	2529	0	0.09	0	0	0	13.51	0	0	0	13.51	0	0	0	13.50
17	2587	0	0.07	0	0	0	13.50	0	0	0	13.51	0	0	0	13.50
19	2850	0	0.04	0.14	0.30	4.84	13.50	0	0.25	5.98	13.51	0	0	0	13.50
21	2821	0	0.10	0	0.13	3.25	13.51	0	0.17	4.12	13.51	0	0	0	13.50
23	2700	0	0.06	0	0.30	7.29	13.50	0	0	0	13.51	0	0	0	13.50
25	3593	0	0.13	0	0.06	1.83	20.26	0	0	0	20.26	0	0	0	20.25
27	3431	0	0.15	0	0.01	0.40	20.27	0	0.01	0.40	20.26	0	0.01	0.49	20.25
29	3291	0	0.06	0	0	0	20.25	0	0.06	4.00	20.25	0	0	0	20.25
31	4307	0	0.41	0.60	0.75	4.92	22.52	0.23	0.36	3.26	22.50	0	0.02	2.00	22.50
33	4424	0	0.14	0.47	1.26	22.92	22.51	0.52	0.77	11.21	22.50	0	0.14	8.58	22.50
35	4397	0	0.24	0.52	0.65	5.71	22.51	0.07	0.32	11.15	22.50	0	0	0	22.50
37	8008	0	0.69	0.74	1.15	25.67	67.52	0.71	0.84	10.09	67.51	0	0.26	12.19	67.50
39	8419	0	0.77	0.68	0.75	5.69	67.52	0.58	0.96	18.71	67.52	0.13	0.35	14.66	67.50
41	8437	0	0.96	0.91	1.11	12.28	67.53	0.33	0.76	22.69	67.52	0.08	0.25	12.70	67.50

.

These comparison algorithms are the main intelligent algorithms for solving NWFSP problems in recent years (2018–2020). We carefully reproduced the algorithms following the steps in the literature and set the parameters as required therein. Considering the uniformity, the condition for terminating the program was selected from the literature [34], that is, the upper limit of the running time is n × m × 90/2. Each algorithm takes five independent runs for each instance, according to [37]. Calculate with Equations (32)–(34) and fill in Table 12 and Table 13 with the results. All algorithms are programmed in C++ (Visual studio 2019) and run on the same desktop PC with an 11th Gen Intel(R) Core (TM) i7-1165G7 (2.80GHz) processor and 16.0 GB RAM.

$${\Delta }_{\min ,i1,a1}=\frac{C_{(\min ,i1,a1)}-C_{(opt,a1)}}{C_{(opt,a1)}}\times 100$$

(32)

$${\Delta }_{Avg,i1,a1}=\frac{C_{(Avg,i1,a1)}-C_{(opt,a1)}}{C_{(opt,a1)}}\times 100$$

(33)

$$S{D}_{i1,a1}=\sqrt{\frac{{\displaystyle \sum _{ct=1}^5{\left(C_{(ct,i1,a1)}-C_{(Avg,i1,a1)}\right)}^2}}{5}}$$

(34)

The minimum and average values of five independent runs of algorithm i1 on instance a1 are denoted as $C_{(\min ,i1,a1)}$ and $C_{(Avg,i1,a1)}$. $\stackrel{\_\_\_}{{\Delta }_{\min }}$, $\stackrel{\_\_\_}{{\Delta }_{Avg}}$, $\stackrel{\_\_\_}{SD}$ and $\stackrel{\_\_\_\_\_\_}{Time}$ represent the arithmetic mean of ${\Delta }_{\min }$, ${\Delta }_{Avg}$, $SD$ and Time of the same scale, respectively, and $C_{(ct,i1,a1)}$ represents the result of the ctth running of the algorithm i1 on the instance a1.

Table 12 shows the test results of the four algorithms on the Tailard benchmark, in which the first column $\stackrel{\_\_\_\_}{opt.}$ records the averages of the optimal values for instances of the same size. The proposed matheuristic algorithm MH2 achieves the optimal solutions in all instances. Even for the largest instances (500 × 20), the average running time is 112.82 s. The running time of a single instance with a scale of less than or equal to 200 is short, ranging from tens of milliseconds to a dozen seconds. Therefore, the algorithm is efficient and feasible. MH2 does not contain random parameters, so the SD value is always 0, and the algorithm is stable.

It can be seen from column $\stackrel{\_\_\_}{{\Delta }_{\min }}$ that when the job size of the Tailard benchmark is greater than or equal to 50, the three metaheuristic algorithms cannot obtain an optimal solution within n × m × 90/2, even if they are run 5 times independently. As the job size increases, the difference between the output value and the optimal solution also increases. In the case of SWWO [34], which has the best comprehensive ability among the three metaheuristics, when the scale is 200 × 20, the difference between the average output solution and the average optimum is about 200 (19788.4 × 1.00%). The metaheuristic algorithm needs more running time to get a better solution, and its convergence speed is not as fast as MH2.

Table 13 shows the results of the four algorithms for solving the small-scale benchmark Reeves, where the first column records the optimal values of the instances. The operating efficiency of the MH2 algorithm is the highest, and the optimal value of any REC instance can be obtained within 1 s. The second is the SWWO algorithm [34], which can find the optimal solution except REC39 and REC41.

In summary, when n < 30, the difference between the four algorithms is not big, and the optimal solutions can basically be found. When n = 50, the search ability of the two swarm intelligence algorithms, IDMBO [37] and DWWO [32], are not as good as that of the adaptive algorithm SWWO [34]. SWWO [34] has the ability to find the optimal solution for an instance of size n = 75 in 67.5 s. To a certain extent, it verifies the NWFSP, which is more suitable for a search mechanism with more local search than global search. Comparing Table 7, it can be seen that when the scale is increased to 200 × 10 and 500 × 20, the $\stackrel{\_\_\_\_\_\_\_\_}{RPI}$ of the heuristic algorithm HG2 is 0.92% and 1.28% respectively, that is, the search performance also exceeds the other three intelligent algorithms. This shows that it is feasible to perform a local search with the job with the smallest $PR$ value in the job set as the end job.

4.3. Results and Discussion

• This study determined the optimal solutions for 141 instances on the Tailard and Reeves benchmarks. Further analysis based on the optimal solutions can verify the validity of the proposed heuristic rule. The final job of the optimal solution is often the job with a smaller $PR$ value.

Step 1. Arrange the jobs according to their $PR$ values from small to large. The corresponding rank with the smallest $PR$ value is 0.

Step 2. Record the Final Job Ranking (FJR) of each optimal sequence. See

Table 14. The FJR of TA.

TA	FJR	TA	FJR	TA	FJR	TA	FJR	TA	FJR	TA	FJR	TA	FJR	TA	FJR
01	7	16	10	31	2	46	0	61	5	76	0	91	0	106	1
02	0	17	0	32	0	47	0	62	0	77	2	92	0	107	1
03	0	18	0	33	0	48	0	63	0	78	0	93	1	108	5
04	0	19	1	34	1	49	1	64	6	79	0	94	3	109	14
05	0	20	1	35	0	50	2	65	0	80	5	95	0	110	0
06	0	21	3	36	0	51	2	66	0	81	1	96	0	111	0
07	1	22	0	37	0	52	1	67	0	82	5	97	0	112	0
08	2	23	2	38	0	53	4	68	3	83	0	98	0	113	1
09	0	24	0	39	0	54	3	69	0	84	1	99	0	114	1
10	0	25	5	40	0	55	0	70	0	85	0	100	0	115	0
11	2	26	0	41	0	56	0	71	0	86	0	101	2	116	0
12	1	27	4	42	0	57	1	72	7	87	0	102	15	117	2
13	1	28	0	43	4	58	1	73	6	88	0	103	25	118	0
14	0	29	5	44	1	59	0	74	1	89	1	104	1	119	0
15	1	30	0	45	0	60	5	75	0	90	0	105	30	120	0

for details.

It can be seen from Table 14 that the FJR values of the instances are distributed between 0 and 30, and the case of “$FJR=0$” accounts for 55%, as shown in Figure 15.

• The heuristic algorithm can effectively guide the optimization direction of the optimizer and improve the solution rate of complex models. Making full use of the advantages of both can not only find more optimal solutions, but also expand the application range of exact algorithms and obtain high-quality solutions that cannot be obtained by metaheuristic algorithms. Two different optimal sequences are obtained on REC05, REC09, TA01, TA03, TA05, TA21, TA32, TA33, TA34, TA35, TA41, TA42, TA44, TA45 and TA46, respectively.

5. Conclusions and Future Work

5.1. Conclusions

This paper studied the characteristics of NWFSP and verified that the $PR$ value is an important indicator of a job. Taking the job with the smaller $PR$ value as the final job has a higher probability of obtaining the optimal solution.

Along the evolutionary direction of HG1 and HG2, different optimal values can be obtained. This shows that HG1 and HG2 as initial solutions have good dispersion. The $PR$ rule and $Z2$, $Z3$, $Z4$ neighborhoods are also fit to be components of intelligent algorithms.

If the job with the smallest $PR$ value is placed in the last position, and then the neighborhood search is expanded step by step (search $Z2$, $Z3$, $Z4$ in turn), the iterative results are often consistent with the optimal solutions in the first few and last few jobs. Bringing these into the optimizer increases the model solution rate.

Experiments show that the optimal values of the two benchmarks (REC and TA) can be obtained by using the Matheuristic MH2 method within an acceptable time (the running time of a single instance with a scale of 500 × 20 is less than 134 s). This shows that the algorithm is feasible.

5.2. Future Work

• Considering the computing power of personal laptops, this paper only studies the three-level neighborhood division method, and initially realizes the idea of gradually expanding the search domain of NWFSP. However, for large-scale instances, the coverage of the three-level neighborhood is not enough, so the effect has a certain dependence on the initial value. In the future, more levels of neighborhood division methods and corresponding neighborhood search methods can be further studied to improve the stability of the algorithm.
• The scope of application of the proposed rules and neighborhood partitioning strategies can be generalized in the future, and they can be embedded in the framework of metaheuristic algorithms to solve NWFSP. In the past, heuristic algorithms were mostly used to construct high-quality solutions, but the rules proposed in this paper satisfy the conditions of participating in all stages. The interaction method between heuristic rules driven by problem features and metaheuristics with the advantage of generality can be further studied to improve the ability of metaheuristics to solve NWFSP.
• In real production, distributed requirements are becoming more and more extensive.

Since the matheuristic solves the NWFSP problem well, it can also be studied to solve the Distributed No-wait Flowshop Scheduling Problem (DNWFSP). On the one hand, it is possible to study the method of building a simplified model of DNWFSP based on the existing NWFSP model; on the other hand, how to use the obtained heuristic rules to guide the optimization direction of the optimizer, improve the speed of solving large-scale instances and expand the application range of exact algorithms is also a future research direction.