Next Article in Journal
Investigation of Improved Cooperative Coevolution for Large-Scale Global Optimization Problems
Previous Article in Journal
Boundary Loss-Based 2.5D Fully Convolutional Neural Networks Approach for Segmentation: A Case Study of the Liver and Tumor on Computed Tomography
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

No-Wait Job Shop Scheduling Using a Population-Based Iterated Greedy Algorithm

Key Laboratory of Cyber-Physical System and Intelligent Control in Universities of Shandong, School of Information and Electrical Engineering, Ludong University, Yantai 264025, China
*
Author to whom correspondence should be addressed.
Algorithms 2021, 14(5), 145; https://doi.org/10.3390/a14050145
Submission received: 2 April 2021 / Revised: 24 April 2021 / Accepted: 28 April 2021 / Published: 30 April 2021
(This article belongs to the Section Combinatorial Optimization, Graph, and Network Algorithms)

Abstract

:
When no-wait constraint holds in job shops, a job has to be processed with no waiting time from the first to the last operation, and the start time of a job is greatly restricted. Using key elements of the iterated greedy algorithm, this paper proposes a population-based iterated greedy (PBIG) algorithm for finding high-quality schedules in no-wait job shops. Firstly, the Nawaz–Enscore–Ham (NEH) heuristic used for flow shop is extended in no-wait job shops, and an initialization scheme based on the NEH heuristic is developed to generate start solutions with a certain quality and diversity. Secondly, the iterated greedy procedure is introduced based on the destruction and construction perturbator and the insert-based local search. Furthermore, a population-based co-evolutionary scheme is presented by imposing the iterated greedy procedure in parallel and hybridizing both the left timetabling and inverse left timetabling methods. Computational results based on well-known benchmark instances show that the proposed algorithm outperforms two existing metaheuristics by a significant margin.

1. Introduction

No-wait constraints widely exist in the steel-making industry (Pinedo [1]; Tang et al. [2]), concrete manufacturing (Grabowski and Pempera [3]), chemical and pharmaceutical industries (Rajendran [4]), food industries (Hall and Sriskandarajah [5]), and so on. The job shop problem with no-wait constraints is called the no-wait job shop scheduling problem (NWJSP) and it differs from traditional job shop problem (JSP) a lot because of the no-wait constraints. NWJSP has gained the increasing attention of researchers over decades. With regard to its complexity, NWJSP is NP (non-deterministic polynomial time)-hard in the strong sense (Lenstra et al. [6]). Sahni and Cho [7] proved that it is strongly NP-hard even for two machine cases. Mascis and Pacciarelli [8] formulated it as an alternative graph and presented several heuristics and a branch and bound method. Broek [9] formulated the problem as a mixed integer program (MIP) and presented a branch and bound method. Recently, Bürgy and Gröflin [10] provided a compact formulation of the problem and proposed an effective approach based on optimal job insertion.
Due to the NP-hardness of NWJSP, the focus has been mostly on metaheuristic approaches for the problem. The pioneer work conducted by Macchiaroli et al. [11] decomposed the problem into two sub-problems and gave out a two-phase tabu search algorithm that is superior to dispatching rules. Schuster and Framinan [12] presented a variable neighborhood search (VNS) algorithm and a hybrid algorithm of simulated annealing and generic algorithm (GASA). Later, Schuster [13] developed a fast tabu search (TS) method, and Framinan and Schuster [14] proposed a complete local search with memory (CLM). Zhu et al. [15] investigated the timetabling methods and developed a complete local search with limited memory (CLLM), which was shown to be comparable to the VNS, GASA and CLM. Zhu and Li [16] also proposed an efficient shift penalty-based timetabling method and further put forward a modified complete local search with memory (MCLM). Mokhtari [17] presented a neuro-evolutionary variable neighborhood search which is based on the combination of an enhanced variable neighborhood search and an artificial neural network. The proposed algorithm was shown to be applicable and effective for the problem. Very recently, Aitzai et al. [18] proposed a branch and bound method and a particle swarm optimization algorithm for the problem. They compared the proposed algorithms with several heuristics but bypassed the other metaheuristics. Li et al. [19] improved the CLLM and developed a complete local search with memory and variable neighborhood structure (CLMMV) algorithm. The CLMMV was shown to have similar effectiveness to and better efficiency than the CLLM. More recently, Sundar et al. [20] proposed a hybrid artificial bee colony (HABC) algorithm and stated that the HABC outperforms the MCLM, as well as the CLLM.
According to the decomposition scheme in Macchiaroli et al. [11], the NWJSP can be decomposed into a timetabling problem and sequencing problem. The sequencing problem is to find a processing sequence of an optimal schedule, whereas the timetabling problem is to determine a feasible starting time for each job in the processing sequence. Using this decomposition scheme, the NWJSP can be solved in a similar way as the flow shop scheduling problem. As an effective and efficient procedure, the iterated greedy (IG) algorithm originally presented by Ruiz and Stutzle [21] has been applied in various scheduling environments, such as identical parallel machine scheduling [22], the distributed flow shop scheduling problem [23], and the blocking flow shop scheduling problem [24]. The IG has shown its unique potentials and advantages of fast convergence, good effectiveness, and easy implementation. In this study, we try to introduce and adapt the IG for the NWJSP. In order to enhance the diversity of the algorithm, we introduce a co-evolutionary scheme, and present a population-based IG algorithm.
The rest of the paper is organized as follows. In Section 2, the NWJSP is formulated into two sub-problems: the timetabling problem and the sequencing problem. Section 3 presents the iterated greedy algorithm and the competitive co-evolutionary scheme. Section 4 analyzes the computational results. Finally, concluding remarks are given in Section 5.

2. No-Wait Job Shop Scheduling Problem (NWJSP) with Makespan Minimization

2.1. Problem Statement

The NWJSP involves a set of machines and a set of jobs which have to be processed on the machines. Each job has its own processing route, namely its own sequence of operations. Each operation is associated with a processing time and a processing machine. The no-wait constraint holds for each job, which means no waiting time is allowed between two consecutive operations of the same job. Besides, we have the following assumptions: (1) all the jobs and machines are available at time zero; (2) at any time, a machine can process at most one job, and a job can be processed on at most one machine; (3) preemption is not allowed; (4) the set-up, release, and transfer time is incorporated in the processing time; (5) no job is allowed to reenter previous machines.
The objective is to find a feasible schedule that minimizes the maximum completion time of all jobs, namely the makespan.

2.2. Problem Formulation

In conformity with the description in Zhu and Li [16], the notations in Table 1 are used.
For two jobs Ji and Jj, let u and v be their two operations that are processed on the same machine ( { u , v } ξ i j ). According to the no-wait constraint, the completion time of operation u and v is t i + P i u and t j + P j v , respectively. Operation u is either anterior or posterior to operation v. Therefore, we have t j + P j v p j v t i + P i u   or   t i + P i u p i u t j + P j v , which is equivalent to:
t j t i P i u P j v + p j v   or   t i t j P j v P i u + p i u
Using the above condition (1), the problem with the makespan criterion can be described as follows:
min t n + 1 s . t . t n + 1 t i L i   for   all   i { 1 , , n }
t i 0   for   all   i { 1 , , n }
t j t i P i u P j v + p j v   or   t i t j P j v P i u + p i u for   all   { u , v } ξ i j , i < j , i , j { 1 , , n }
tn+1 is the start time of a dummy job, representing the makespan. Constraint (3) means that each job starts after time zero. Constraint (4) guarantees that the no-wait requirement is satisfied for any two jobs. Note that the number of constraint (4) is reduced by using i < j instead of i j .
For the above operation pair { u , v } ξ i j , let Mk denote the same machine of operations u and v, then P i u , P j v , p i u , p j v mean the same as P i k , P j k , p i k , p j k , respectively. Condition (1) can be rewritten as:
t j t i ( , P i k P j k P i k ] [ P i k P j k + P j k , + )
For two jobs Ji and Jj, if their start time difference t j t i satisfies condition (5), then these two jobs do not conflict on machine Mk.
Obviously, the start times ti and tj are feasible if and only if jobs Ji and Jj do not conflict on all machines, which means that tjti satisfies condition (5) for all machines Mk (k = 1, 2, …, m). Therefore, constraint (4) can be described as t j t i F i j , where Fij is an interval set with the feasible values of t j t i , obtained by:
F i j = k = 1 k m ( , P i k P j k P i k ] [ P i k P j k + P j k , + )
With the above notations, the NWJSP with the makespan criterion is further formulated as follows:
min t n + 1 s . t . t n + 1 t i L i   for   all   i { 1 , , n }
t i 0   for   all   i { 1 , , n }
t j t i F i j   for   all   i < j , i , j { 1 , , n }
Li and all Fij can be computed in advance. According to Equation (6), all Fij can be computed in time O(n2mlogm). Fij is an interval set with at most m + 1 intervals.
The existing effective approaches for the problem usually decompose it into the sequencing and timetabling sub-problems. The purpose of the sequencing sub-problem is to find a job sequence, denoted here as π = ( π [ 1 ] , , π [ n ] ) , that generates a schedule minimizing the makespan. Clearly, the search space of the sequencing sub-problem has n ! solutions. The purpose of the timetabling sub-problem is to find a timetable, S T π = ( t [ 1 ] , , t [ n ] , C max ( π ) ) , with a minimum C max ( π ) based on a given job sequence π = ( π [ 1 ] , , π [ n ] ) .

2.3. Timetabling Methods

There are several timetabling methods to determine a feasible schedule from a provided job permutation. The combinations of different timetabling methods and different sequencing algorithms are extensively studied by Samarghandi et al. [25]. They found that complicated methods are not necessarily superior to simple methods, and some simpler methods prove to be more effective. Deng et al. [26] investigated several timetabling methods for the problem with total flow time criterion and found that the left timetabling and inverse left timetabling methods are more effective when the algorithm for the sequencing problem is run with the same computational efforts. In the left timetabling method, we set t[1] = 0, and compute the minimum t[i] successively for i = 2,…,n, subjected to (1) t [ i ] 0 and (2) π [ i ] does not conflict with π [ j ] for all j < i. The inverse left timetabling method is the same as the left timetabling method except that it is performed on the inverse instance. The inverse left timetabling method is based on the fact that a solution for the inverse instance is also applicable for the original instance (see more in Schuster [13] and Zhu et al. [15]).
As stated above, t j t i F i , j means the start times of J j and J i are feasible. Let S i , j = [ 0 , + ) F i , j , then t j t i S i , j means the start times of J j and J i are feasible and J j starts not earlier than J i . All F i , j and S i , j can be computed in advance with time complexity O ( n 2 m log m ) . Without loss of generality, assume that the permutation is π = ( J 1 , J 2 , , J n ) . The left timetabling of π utilizes all the precomputed S 1 , j ( 1 < j ) and F i , j ( 1 < i < j ). First let t 1 = 0 . Then t j is computed successively from j = 2 to j = n . For job J j , with the already computed t i ( i < j ), the steps to compute t j is designed as follows.
Step 1: set t j t 1 as the minimum value that satisfies the first interval of S 1 , j .
Step 2: check F j 1 , j , …, F 2 , j , S 1 , j successively. When checking F i , j ( i > 1 ) or S i , j ( i = 1 ), if the incumbent t j t i does not satisfy any interval of F i , j ( i > 1 ) or S i , j ( i = 1 ), augment t j to make it satisfied and then check F j 1 , j , …, F 2 , j , S 1 , j successively again. This step is repeated until t j t i satisfies all the F j 1 , j , …, F 2 , j , S 1 , j .
Since there are at most m + 1 intervals in F i , j or S i , j , when the worst case happens, to compute t j needs time complexity O ( m j 2 ) , and to compute all the t j (j = 1, …, n) needs time complexity O ( m n 3 ) , which results in the worst case time complexity O ( m n 3 ) for the left timetabling. According to Deng et al. [26], the above procedure is effective for the left timetabling method and inverse left timetabling method.

3. Population-Based Iterated Greedy Algorithm

In this section, we try to introduce and adapt the IG for the NWJSP. We first develop an IG algorithm as a combination of a perturbator and an insertion-based local search. Thereafter, we introduce a co-evolutionary scheme and present a population-based IG (PBIG) algorithm. Most of the algorithms in the existing studies apply one timetabling method, whereas the PBIG in this study uses both the left timetabling and inverse left timetabling methods to enhance the quality of schedule solutions.

3.1. Iterated Greedy Procedure

In the framework of IG for permutation flow shop scheduling problem (PFSP), the incumbent solution is updated by iterating over three phases. Firstly, the destruction and construction (DC) operator is used as a perturbator to generate a candidate solution usually different from the incumbent solution. Then an iterative improvement local search is applied to the candidate solution and a new solution is obtained. Finally, an acceptance criterion decides whether the new solution will replace the incumbent one. In this paper, these phases are applied to NWJSP as follows.

3.1.1. Destruction and Construction

The DC operator consists of two phases: destruction phase and construction phase. In destruction phase, d jobs are randomly selected, removed from the incumbent permutation π. Then in the construction phase, all the deleted jobs are reinserted, one by one, into π to construct a complete permutation. The procedure of the DC is shown in Algorithm 1, where the final πF is the candidate solution found by the DC.
Algorithm 1. The destruction and construction (DC) operator.
1: choose d unrepeated jobs s1, …, sd randomly, delete them from π, and a sequence π F with nd jobs is obtained.
 2: for i from 1 to d
3:  insert si into the nd + i positions of πF, evaluate the obtained nd + i sequences, and replace πF with the best one.
4: endfor.

3.1.2. Local Search

The local search is performed on the candidate solution found by the DC. In the local search of the IG algorithm by Ruiz and Stutzle [21], a job s is extracted from the permutation π and inserted into the other n − 1 possible positions. Let π b i n s e r t s denote the permutation of the best insert move, namely the permutation resulting in the best makespan among the n − 1 permutations. If π b i n s e r t s is better than π, π is replaced with π b i n s e r t s . The process is then repeated for another job, and it terminates when no improvement occurs for all jobs. Deng et al. [26] improved this local search by avoiding redundant search, and developed insert-based local search (IBLS). Here we introduce the IBLS for the makespan criterion. The procedure of the IBLS is shown in Algorithm 2. The IBLS employs a random permutation at the very beginning to make the local search more stochastic.
Algorithm 2. Insertion-based local search (IBLS).
1: π R = a permutation generated randomly
2: i = 0, h = 1
3: while (i < n)
4:   let s = π R [ h ]
5:   find π b i n s e r t s
6:   if ( π b i n s e r t s is better than π)
7:       π = π b i n s e r t s
8:     i = 1
9:   else
10:     i = i + 1
11:   endif
12:   h = (h + 1) % n
13: endwhile

3.2. Initialization

Since the PBIG is a pullulation-based algorithm, there is a population with p solutions evolving in the algorithm. Each solution is performed with the IG procedure. The Nawaz–Enscore–Ham (NEH) heuristic (Nawaz et al. [27]) has been shown to be one of the most effective heuristics for flow shop problems, and it has been extensively utilized to generate initial solutions for metaheuristics for the flow shop problems. The NEH heuristic firstly sequences the jobs in non-increasing order of the total processing time on all the machines. Then it constructs a partial solution by taking into consideration the first two jobs. Finally, a complete solution is constructed by inserting these jobs one by one into the current partial solution.
To adapt the NEH heuristic for NWJSP, the evaluation of a partial sequence in NWJSP is different from that in PFSP. For a partial sequence, here the timetabling method is applied to construct a partial time table as a partial solution. With this, the NEH heuristic is described as follows.
Step 1: sequence the jobs in non-increasing order of the total processing time on all the machines and obtain a priority job order ρ = ( ρ [ 1 ] , , ρ [ n ] ) . Let partial sequence σ = ( ρ [ 1 ] ) and k = 2.
Step 2: insert job ρ ( k )  to all the possible k positions of σ and obtain k tentative partial sequences. Evaluate these partial sequences by applying the timetabling method, replace σ with the partial sequence that results in the minimum makespan.
Step 3: Let k = k + 1. If kn, go to step 2; otherwise σ is the final permutation.
To employ the NEH heuristic to generate a random solution with good quality, we use a random job permutation as job order in the first step, and develop a variant of the NEH heuristic, called NEH_RAN. It should be noted that both the left timetabling and inverse left timetabling methods can be used in the above NEH heuristic and its variants. In other words, the heuristic can be applied with the left timetabling for the original instance to obtain a solution, and it can also be applied with the inverse timetabling for the inverse instance to obtain another solution.
To take advantage of both the left timetabling and inverse left timetabling methods, both methods are applied in the p IG procedures. A bool vector md = (md(1),…, md(p)) is designed to indicate the timetabling method for the p IG procedures. md(k) = true means that the k-th IG procedure is performed with the left timetabling, otherwise it is performed with the inverse left timetabling. md is initialized in a form of (true, false, true, false, …). Then, the p initial solutions of the p IG procedures are initialized as follows.
The first is initialized by the NEH heuristic using the left timetabling, and the second is initialized by the NEH heuristic using the inverse left timetabling. The remaining p − 2 initial solutions are initialized by the NEH_RAN using the inverse left timetabling (if the md(k) value is true) or using the inverse left timetabling (if the md(k) value is false). Such an initialization strategy not only takes advantage of both the timetabling methods, but also constructs the initial start solutions with both quality and diversity.

3.3. Competitive Co-Evolutionary Scheme

Three best solutions, πL, πI and πG, are stored together in the algorithm. πL is the best solution found by all IG procedures with respect to left timetabling method, while πI is the best solution found by all IG procedures with respect to inverse left timetabling method. πG is the better of πL and πI, namely the global best solution found so far. πL, πI and πG are initialized based on the p initial solutions.
After the p initial solutions are generated, the p IG procedures go into iteration simultaneously. Each IG procedure evolves according to its own timetabling method, either left timetabling or inverse left timetabling. It can be easily inferred that as the evolution proceeds, the incumbent solutions found by the IG algorithms are probably not the same, which means some of the incumbent solutions may be relatively better than others. Therefore, a reasonable assumption is that when an iteration is accomplished, some advantage should be taken of the relatively better solutions. Based on this assumption, the tournament selection is introduced as a competitive strategy. In the tournament selection, firstly, three solutions are randomly selected, and then the worst one is replaced with a perturbation solution which is generated by performing the DC on πL or πI with parameter D. Let π k (k = 1, …, p) denote the incumbent solution of the k-th IG procedure, and let mdbest denote the bool value indicating the timetabling method for πG. The competitive strategy is illustrated in Algorithm 3, where rand is a real number randomly generated in [1]. Note that mdbest = true means that πG is the same as πL, otherwise it is the same as πI. The perturbation solution is generated based on the global solution πG with probability pb. Considering that the global solution πG should be given more chances than the other best solution, the suggested value of pb are between 0.5 and 1.0.
Algorithm 3. Competitive Strategy.
1: randomly select three solutions from all and find the worst one.
2: if (rand < pb)
3:    πC := πG
4:   md(k*) := mdbest
5: else if (mdbest)
6:        πC := πL
7:       md(k*) := true
8:    else
9:        πC := πI
10:      md(k*) := false
11:   endif
12: endif
13: perform DC on π C with parameter D and obtain a perturbation solution π C
14: π k := π C

3.4. Procedure of the Population-Based Iterated Greedy (PBIG) Algorithm

Since the details of all components of the PBIG have been given, the whole computational procedure is outlined in Algorithm 4. Such an algorithm is expected to solve the NWJSP with the makespan criterion effectively and efficiently. It should be noted that although the PBIG in this study has an analogous framework with the population-based iterated greedy (denoted PBIG_D here) algorithm in [26], they are different in several facets. Firstly, the PBIG in this study is applied to the makespan criterion, whereas the PBIG_D is designed for the total flow time criterion. Secondly, different optimization criteria cause different characteristics for the NWJSP, including the distribution features of the solutions and the effects of timetabling methods. Therefore, the PBIG uses both the left timetabling and inverse left timetabling methods, whereas the PBIG_D only employs the left timetabling method. Lastly, the PBIG contains a newly-designed competitive scheme, where the perturbation solution is generated based on a solution with either of the two timetabling methods, whereas in the competitive mechanism of the PBIG_D, the shaking solution is simply generated from the best solution found so far.
Algorithm 4. Procedure of the PBIG.
1: set parameters d, p, D, pb.
2: initialize πk (k = 1, …, p), πL, πI, πG, md, mdbest, Temp.
3: while (not termination)
4:   for (each πk)  //perform each IG procedure
5:     perform the DC operator on πk and then the IBLS, and obtain a new solution π k . If π k is better than πk, then let πk := π k and update πL, πI, πG, mdbest if possible.
6:   endfor
7:   perform competitive strategy.
8: endwhile

4. Computational Results and Comparisons

Computational experiments are performed on the following well-known benchmark instances: ft06, ft10, ft20 (Fisher and Thompson [28]), orb01-10 (Applegate and Cook [29]), abz5-9 (Adams et al. [30]), la01-40 (Lawrence [31]), and swv01-20 (Storer et al. [32]). The algorithm is programmed in C++ language and the running environment is a PC with Intel Core(TM) i5-6200 2.3 GHz processor. The acceleration method for insert neighborhood in [33] is used in order to save computational efforts. The following relative percentage deviation (RPD) is calculated to indicate the effectiveness:
RPD = C ALG C REF C REF × 100
where CALG is the solution obtained by the tested algorithm, and CREF is the reference solution. In this study, we use the same reference solution as in [16,20].

4.1. Calibration of the PBIG Algorithm

There are four parameters in total to calibrate for the PBIG, namely p, d, pb, and D. A larger Design of Experiments (DOE) [34] is carried out based on the following factor: (1) parameter p tested at four levels: 4, 6, 8, 10; (2) parameter d tested at four levels: 2, 4, 6, 8; (3) parameter pb tested at four levels: 0.6, 0.7, 0.8, 0.9; (4) parameter D tested at four levels: 2, 4, 6, 8. We select the following seven instances with different sizes from each other: la06, la11, la21, la26, la31, la36, and swv01. Each instance is solved by the algorithm for each combination of the factors with five independent replications. The average RPD (ARPD) obtained by the algorithm is calculated as a response variable. The stopping criterion is the elapsed CPU time not less than 6 mn2 milliseconds (ms). The multi-factor Analysis of Variance (ANOVA) technique is used to analyze the computational results. The ANOVA results are shown in Table 2. It can be seen from Table 2 that the parameters p, d, and D are statistically significant, whereas the parameter pb is not. The means plots of these factors, together with least significant difference (LSD) 95% confidence intervals, are illustrated in Fig. 1. Recall that if the LSD intervals for two means are not overlapping, then the difference between the two means is statistically significant.
Figure 1 suggests that for the values of parameter p, 8 is statistically better than 4 and 6, although its difference from 10 is not significant. For the values of parameter d, 4 is statistically better than 2 and 8. The values 6 and 8 are relatively better than 2 and 4 for the parameter D, while no statistical significance is found for the parameter pb. Finally, the parameters of the algorithm are set as p = 8, d = 4, pb = 0.7, and D = 6.

4.2. Comparisons with Other Metaheuristics

Among the metaheuristics developed for the NWJSP in the literature, the MCLM [16] and the HABC [18] algorithms are two state-of-the-art approaches. Therefore, these two algorithms are used to compare with the proposed PBIG in this subsection. We bypassed the other algorithms either because it provided a low-level performance or because it was hard to compare with the PBIG due to different performance indexes. Like the MCLM and HABC algorithms, the PBIG is applied to 22 small instances and 40 large instances with 20 replications. It should be noted that the MCLM was implemented in Java on a Pentium 4 processor and its average central processing unit (CPU) time was 6.55 s for the small instances and 654.48 s for the large instances, while the HABC was implemented in C on an identical processor and its average CPU time was 4.63 and 570.40 s for the small and large instances, respectively. Both the MCLM and the HABC adopted a stopping criterion determined by the current results found by the algorithm, and thus the computational time of the algorithm was not controllable. Such kind of stopping criterion makes it difficult to compare the algorithms in a fair way. Take instance Swv09 as an example, the average CPU time of the MCLM was 448 s whereas that of the HABC was 1531.08 s, and it was difficult to determine which algorithm was better although the RPD results of the MCLM were worse than those of the HABC. For this reason, the stopping criterion of the PBIG was set as the elapsed CPU time not less than 3 mn2 ms for the small instances and 60 mn2 ms for the large instances to facilitate the comparisons under the same criterion by future researchers. Using this stopping criterion, the PBIG required less average CPU time than the MCLM and HABC. We adopt the original results from [16,18] and do not reimplement the MCLM and HABC. The computational results are given in Table 3 and Table 4 for the small and large instances, respectively. In Table 3 and Table 4, TA denotes the average CPU time (in seconds) of 20 runs. Best denotes the best makespan value among 20 runs for the corresponding algorithm. RPDB denotes the RPD value of the Best. ARPD denotes the average RPD value over 20 runs. Best results among the three algorithms are shown in bold for Best, RPDB, and ARPD. NA denotes that the value was not provided in the original results. The column noted as BKS shows the reference solution used in the RPD. Note that the BKS values in Table 3 are also optimal solutions of the small instances.
Table 3 shows that the PBIG can optimally solve all the small instances except Orb05. Further, for all the instances except Orb05 and La01, the PBIG can find the optimal solutions for every single run since the RPDB and ARPD values are both 0.00. The average RPDB and ARPD values of the PBIG are both 0.01, which are better than those of the MCLM (0.39, 0.45) and HABC (0.23, 0.47), whereas the average computational time of the PBIG (2.55 s) is much less than that of the MCLM (6.55 s) and HABC (4.63 s). It can be seen clearly from Table 4 that the results obtained by the PBIG and HABC are clearly better that that of the MCLM. Besides, Table 4 illustrates that the PBIG is a competitive algorithm for the large instances, and the average computational time of the PBIG is less than half of that of the HABC. The results also show that the PBIG finds equal best solution for 25 instances and better best solution for 9 instances when compared with the HABC. The PBIG obtains the same average ARPD value (−0.64) as the HABC while the average RPDB value of the PBIG (−1.88) is slightly better that that of the HABC (−1.74), which implies that the peak performance of the PBIG is superior to that of the HABC. We do not perform statistical test due to lack of the original data for the MCLM and HABC. However, it can be concluded from the results of Table 3 and Table 4 that the proposed PBIG algorithm is a competitive metaheuristic to solve the problem under consideration, especially for the large instances.
In addition, to illustrate the best scheduling results provided by the PBIG more clearly, Gantt charts are drawn in Figure 2 and Figure 3 for two instances, La11 and La12, respectively. In Figure 2 and Figure 3, we assume that time unit is minute, and the job number starts from zero. The start time of each job is marked as red. The processing times of all jobs are taken from the benchmark instances La11 and La12 (Lawrence [31]). For instance with La11, it can be seen from Table 4 that the best solutions obtained by the MCLM and HABC are 1635 and 1627, respectively. Compared with the MCLM and HABC, the PBIG can yield a solution with lower makespan value (1621). With La12, the PBIG can also yield a solution with lower makespan value than the MCLM and HABC.

5. Conclusions

This study considers the no-wait job shop scheduling problem by using a population-based iterated greedy (PBIG) algorithm. The problem is decomposed into a sequencing problem and timetabling problem. The Nawaz–Enscore–Ham (NEH) heuristic used for flow shop is extended in no-wait job shops, and an initialization scheme based on the NEH heuristic is developed to generate start solutions with both quality and diversity. Furthermore, a population-based co-evolutionary scheme is presented by imposing the iterated greedy procedure in parallel and hybridizing both the left timetabling and inverse left timetabling methods. Lastly, the proposed algorithm is compared with two effective metaheuristics in literature, and its effectiveness is demonstrated by computational results.
Considering the structural simplicity and high effectiveness of the PBIG, we hold the view that the algorithm is technically feasible to apply in practical production environment. In future, we will focus on adapting the PBIG algorithm for the multi-objective job shop scheduling problem, as well as the job shop scheduling problem with uncertainty.

Author Contributions

Conceptualization, G.D.; Formal analysis, S.Z.; Methodology, G.D.; Software, S.Z.; Supervision, G.D.; Validation, M.X.; Visualization, M.X.; Writing—original draft, M.X. All authors have read and agreed to the published version of the manuscript.

Funding

This research was funded by project ZR2019QF008 supported by Shandong Provincial Natural Science Foundation.

Institutional Review Board Statement

Not applicable.

Informed Consent Statement

Not applicable.

Data Availability Statement

The data presented in this study are available on request from the corresponding author.

Conflicts of Interest

The authors declare no conflict of interest.

References

  1. Pinedo, M. Scheduling: Theory, Algorithms, and Systems, 5th ed.; Springer: Berlin/Heidelberg, Germany, 2016. [Google Scholar]
  2. Tang, L.; Liu, J.; Rong, A.; Yang, Z. A mathematical programming model for scheduling steelmaking-continuous casting production. Eur. J. Oper. Res. 2000, 120, 423–435. [Google Scholar] [CrossRef]
  3. Grabowski, J.; Pempera, J. Sequencing of jobs in some production system. Eur. J. Oper. Res. 2000, 125, 535–550. [Google Scholar] [CrossRef]
  4. Rajendran, C. A no-wait flow shop scheduling heuristic to minimize makespan. Eur. J. Oper. Res. 1994, 45, 472–478. [Google Scholar]
  5. Hall, N.; Sriskandarajah, C. A survey of machine scheduling problems with blocking and no-wait in process. Oper. Res. 1996, 44, 510–525. [Google Scholar] [CrossRef]
  6. Lenstra, J.K.; Kan, A.H.G.R.; Brucker, P. Complexity of machine scheduling problems. Ann. Discret. Math. 1997, 1, 343–362. [Google Scholar]
  7. Sahni, S.; Cho, Y. Complexity of scheduling shops with no-wait in process. Math. Oper. Res. 1979, 4, 448–457. [Google Scholar] [CrossRef]
  8. Mascis, A.; Pacciarelli, D. Job-shop scheduling with blocking and no-wait constraints. Eur. J. Oper. Res. 2002, 143, 498–517. [Google Scholar] [CrossRef]
  9. Van den Broek, J. MIP-Based Approaches for Complex Planning Problems. Ph.D. Thesis, Technische Universiteit Eindhoven, Eindhoven, The Netherlands, 2009. [Google Scholar]
  10. Bürgy, R.; Gröflin, H. Optimal job insertion in the no-wait job shop. J. Comb. Optim. 2013, 26, 345–371. [Google Scholar] [CrossRef]
  11. Macchiaroli, R.; Mole, S.; Riemma, S. Modelling and optimization of industrial manufacturing processes subject to no-wait constraints. Int. J. Prod. Res. 1999, 37, 2585–2607. [Google Scholar] [CrossRef]
  12. Schuster, C.; Framinan, J. Approximate procedures for no-wait job shop scheduling. Oper. Res. Lett. 2003, 31, 308–318. [Google Scholar] [CrossRef]
  13. Schuster, C. No-wait job shop scheduling: Tabu search and complexity of subproblems. Math. Methods Oper. Res. 2006, 63, 473–491. [Google Scholar] [CrossRef]
  14. Framinan, J.M.; Schuster, C. An enhanced timetabling procedure for the no-wait job shop problem: A complete local search approach. Comput. Oper. Res. 2006, 331, 1200–1213. [Google Scholar] [CrossRef]
  15. Zhu, J.; Li, X.; Wang, Q. Complete local search with limited memory algorithm for no-wait job shops to minimize makespan. Eur. J. Oper. Res. 2009, 198, 378–386. [Google Scholar] [CrossRef]
  16. Zhu, J.; Li, X. An effective meta-heuristic for no-wait job shops to minimize makespan. IEEE Trans. Autom. Sci. Eng. 2012, 9, 189–198. [Google Scholar] [CrossRef]
  17. Mokhtari, H. A two-stage no-wait job shop scheduling problem by using a neuro-evolutionary variable neighborhood search. Int. J. Adv. Manuf. Technol. 2014, 74, 1595–1610. [Google Scholar]
  18. Aitzai, A.; Benmedjdoub, B.; Boudhar, M. Branch-and-bound and PSO algorithms for no-wait job shop scheduling. J. Intell. Manuf. 2016, 27, 679–688. [Google Scholar] [CrossRef]
  19. Li, X.; Xu, H.; Li, M. A memory-based complete local search method with variable neighborhood structures for no-wait job shops. Int. J. Adv. Manuf. Technol. 2016, 87, 1401–1408. [Google Scholar]
  20. Sundar, S.; Suganthan, P.N.; Jin, C.T.; Xiang, C.T.; Soon, C.C. A hybrid artificial bee colony algorithm for the job-shop scheduling problem with no-wait constraint. Soft Comput. 2017, 21, 1193–1202. [Google Scholar]
  21. Ruiz, R.; Stutzle, T. A simple and effective iterated greedy algorithm for the permutation flowshop scheduling problem. Eur. J. Oper. Res. 2007, 177, 2033–2049. [Google Scholar]
  22. Lee, C.H. A dispatching rule and a random iterated greedy metaheuristic for identical parallel machine scheduling to minimize total tardiness. Int. J. Prod. Res. 2018, 56, 2292–2308. [Google Scholar] [CrossRef]
  23. Ruiz, R.; Pan, Q.K.; Naderi, B. Iterated greedy methods for the distributed permutation fowshop scheduling problem. OMEGA 2019, 83, 213–222. [Google Scholar] [CrossRef]
  24. Ribas, I.; Companys, R.; Tort-Martorell, X. An iterated greedy algorithm for solving the total tardiness parallel blocking flow shop scheduling problem. Expert Syst. Appl. 2019, 121, 347–361. [Google Scholar] [CrossRef]
  25. Samarghandi, H.; ElMekkawy, T.Y.; Ibrahem, A.M. Studying the effect of different combinations of timetabling with sequencing algorithms to solve the no-wait job shop scheduling problem. Int. J. Prod. Res. 2013, 51, 4942–4965. [Google Scholar] [CrossRef]
  26. Deng, G.; Su, Q.; Zhang, Z.; Liu, H.; Zhang, S.; Jiang, T. A population-based iterated greedy algorithm for no-wait job shop scheduling with total flow time criterion. Eng. Appl. Artif. Intell. 2020, 88, 103369. [Google Scholar] [CrossRef]
  27. Nawaz, M.; Enscore, J.E.E.; Ham, I. A heuristic algorithm for the m-machine, n-job flow-shop sequencing problem. Omega 1983, 11, 91–95. [Google Scholar] [CrossRef]
  28. Fisher, H.; Thompson, G.L. Probabilistic Learning Combinations of Local Job-Shop Scheduling Rules. Industrial Scheduling; Prentice-Hall: Englewood Cliffs, NJ, USA, 1963; pp. 225–251. [Google Scholar]
  29. Applegate, D.; Cook, W. A computational study of the job-shop problem. ORSA J. Comput. 1991, 3, 149–156. [Google Scholar] [CrossRef]
  30. Adams, J.; Balas, E.; Zawack, D. The shifting bottleneck procedure for job shop scheduling. Manag. Sci. 1988, 34, 391–401. [Google Scholar] [CrossRef]
  31. Lawrence, S. Resource Constrained Project Scheduling: An Experimental Investigation of Heuristic Scheduling Techniques; Technical Report; Carnegie-Mellon University: Pittsburgh, PA, USA, 1984. [Google Scholar]
  32. Storer, R.H.; Wu, S.D.; Vaccari, R. New search spaces for sequencing instances with application to job shop scheduling. Manag. Sci. 1992, 38, 1495–1509. [Google Scholar] [CrossRef]
  33. Deng, G.; Zhang, Z.; Jiang, T.; Zhang, S. Total flow time minimization in no-wait job shop using a hybrid discrete group search optimizer. Appl. Soft Comput. 2019, 81, 105480. [Google Scholar] [CrossRef]
  34. Montgomery, D.C. Design and Analysis of Experiments, 8th ed.; Wiley: New York, NY, USA, 2012. [Google Scholar]
Figure 1. Means plot for the parameters with least significant difference (LSD) 95% confidence intervals.
Figure 1. Means plot for the parameters with least significant difference (LSD) 95% confidence intervals.
Algorithms 14 00145 g001
Figure 2. Scheduling Gantt chart obtained by the PBIG for the instance La11.
Figure 2. Scheduling Gantt chart obtained by the PBIG for the instance La11.
Algorithms 14 00145 g002
Figure 3. Scheduling Gantt chart obtained by the PBIG for the instance La12.
Figure 3. Scheduling Gantt chart obtained by the PBIG for the instance La12.
Algorithms 14 00145 g003
Table 1. Notations used throughout the paper.
Table 1. Notations used throughout the paper.
Notation.DescriptionNotationDescription
mnumber of machinestistart time of Ji
nnumber of jobs π = ( π [ 1 ] , , π [ n ] ) job permutation
M = {M1, M2, …, Mm}set of m machinest[i]start time of π [ i ]
J = {J1, J2, …, Jn}set of n jobs o i k operation of J i on M k
oi,uu-th operation of Ji p i k processing time of o i k
Mi,umachine on which oi,u is processed S i , j start time difference set
pi,uprocessing time of oi,u C max ( π ) makespan of π
Pi,u = v = 1 u p i , v cumulated processing time of Ji when oi,u is finished S T π = ( t [ 1 ] , , t [ n ] , C max ( π ) ) start time table of π
ξ i , j = {(u,v)| Mi,u = Mj,v}pairs of operations processed on the same machine P i k cumulated processing time of J i when o i k is finished
Litotal processing times of Ji
Table 2. Analysis of variance (ANOVA) results for the calibration.
Table 2. Analysis of variance (ANOVA) results for the calibration.
SourceSum of SquaresDfMean SquareF-Ratiop-Value
MAIN EFFECTS
A: p54.9931318.331016.85000.0000
B: d343.3963114.465105.2200.0000
C: pb5.4524631.817491.670000.1737
D: D142.747347.582543.74000.0000
E: instance7962.7361327.121219.900.0000
REDIDUAL9797.7289411.09582
TOTAL (CORRECTED)18307.08959
Table 3. Results for the modified complete local search with memory (MCLM), hybrid artificial bee colony (HABC) and population-based iterated greedy (PBIG) on the small instances.
Table 3. Results for the modified complete local search with memory (MCLM), hybrid artificial bee colony (HABC) and population-based iterated greedy (PBIG) on the small instances.
Instance.n, mBKSMCLMHABCPBIG
RPDBARPDTA(s)RPDBARPDTA(s)RPDBARPDTA(s)
Ft066, 6730.000.000.000.000.000.150.000.000.65
La0110, 59710.000.004.550.410.410.780.000.021.50
La0210, 59370.000.007.602.562.561.410.000.001.50
La0310, 58200.000.003.100.000.000.700.000.001.50
La0410, 58870.000.006.250.000.000.870.000.001.50
La0510, 57770.510.903.900.510.511.140.000.001.50
Ft1010, 1016070.000.007.850.000.009.860.000.003.00
Orb0110, 1016150.000.006.650.000.008.000.000.003.00
Orb0210, 1014852.162.166.700.000.006.860.000.003.00
Orb0310, 1015990.000.0013.750.000.0010.070.000.003.00
Orb0410, 1016530.000.127.850.000.005.280.000.003.00
Orb0510, 1013650.000.008.500.370.374.770.150.153.00
Orb0610, 1015550.000.003.550.000.005.760.000.003.00
Orb0710, 106890.000.007.25NANANA0.000.003.00
Orb0810, 1013190.000.006.400.000.008.990.000.003.00
Orb0910, 1014450.000.004.250.000.284.100.000.003.00
Orb1010, 1015570.000.0011.850.000.005.510.000.003.00
La1610, 1015751.841.845.650.000.005.430.000.003.00
La1710, 1013710.000.1211.850.000.004.620.000.003.00
La1810, 1014172.822.826.150.005.227.130.000.003.00
La1910, 1014820.000.615.000.000.433.440.000.003.00
La2010, 1015261.311.315.400.000.003.000.000.003.00
Average 0.390.456.550.230.474.630.010.012.55
Table 4. Results for the MCLM, HABC and PBIG on the large instances.
Table 4. Results for the MCLM, HABC and PBIG on the large instances.
Instancen, mBKSMCLMHABCPBIG
BestRPDBARPDTA(s)BestRPDBARPDTA(s)BestRPDBARPDTA(s)
La0615, 5124812480.000.7590.0012480.000.0039.9912480.000.0067.50
La0715, 5117211780.512.4683.0011720.000.9290.1911720.000.4467.50
La0815, 5124412440.000.4780.0012440.000.1585.6312440.000.4867.51
La0915, 5135813650.520.73106.0013620.290.6734.4313620.290.6167.50
La1015, 5128712870.000.0469.0012940.540.7065.4212940.540.8467.50
La1120, 516711635−2.15−0.58439.001627−2.631.97259.3716212.99−1.08120.02
La1220, 514521429−1.580.57593.001434−1.240.00168.9714251.860.17120.02
La1320, 516241605−1.17−0.15303.0015802.711.47222.401582−2.59−0.09120.02
La1420, 516911648−2.54−1.16314.0016403.022.24156.5816403.02−1.96120.02
La1520, 516941685−0.531.09424.001679−0.890.09240.5616771.000.35120.02
La2115, 10204820480.000.1178.0020430.240.2771.4220430.240.04135.01
La2215, 10188719020.800.99142.0018521.85−1.1291.6618521.851.19135.01
La2315, 10203220220.491.4750.0020320.000.71120.5620320.000.14135.01
La2415, 10201520150.000.7798.0019941.04−0.0297.6419941.040.30135.01
La2515, 10191719300.682.0771.0019060.570.5792.5319060.570.57135.01
La2620, 1025532532−0.821.91349.0025061.840.30223.4625061.841.66240.02
La2720, 1027472715−1.170.28388.002674−2.662.62154.8326732.69−2.19240.02
La2820, 10262425602.441.77313.0025602.440.62197.332581−1.640.77240.03
La2920, 10248923674.90−2.48445.002389−4.022.70531.942405−3.37−2.18240.03
La3020, 1026652544−4.54−1.51376.0024527.99−3.00248.2524527.993.50240.03
La3130, 1037453575−4.54−1.403099.003592−4.092.601716.1834797.10−2.35540.16
La3230, 10402838354.790.563314.003913−2.86−0.351590.403877−3.750.68540.19
La3330, 1037493574−4.67−1.523003.0035295.873.371544.343560−5.04−2.51540.18
La3430, 1038243684−3.66−0.883375.0036105.602.761405.053615−5.47−2.55540.20
La3530, 1037603698−1.651.273083.0035934.440.411797.553687−1.940.43540.19
La3615, 15268527361.904.98189.0026850.000.2976.4226850.000.00202.51
La3715, 15296229620.000.1193.002938−0.810.98184.4128314.420.06202.51
La3815, 15261725253.52−1.7391.0025253.52−1.08311.6625253.522.80202.51
La3915, 15269727291.192.43116.0027030.220.88146.8726870.370.34202.51
La4015, 15259425800.540.5461.0025940.000.00190.5125940.000.00202.51
Swv0120, 1023282333 0.220.37516.0023180.43−0.02874.7023180.430.17240.02
Swv0220, 1024182418 0.000.38488.0024170.040.02961.1224170.040.02240.02
Swv0320, 10241523811.41−0.41517.0023811.410.921018.0223811.41−0.89240.02
Swv0420, 10250624621.760.30426.0025060.000.291728.6424621.76−0.10240.02
Swv0520, 10233323330.000.00285.0023330.000.00535.6923330.000.00240.02
Swv0620, 15329132910.001.69747.0032910.000.40885.6732910.000.05360.02
Swv0720, 1532713219−1.59−0.95584.0031882.542.54829.2031882.54−2.43360.01
Swv0820, 15353034233.03−2.21413.0034233.03−1.781150.0934233.032.56360.02
Swv0920, 1533073270−1.12−0.28448.0032461.84−0.861531.0832461.841.12360.02
Swv1020, 15348834511.060.12520.003462−0.75−0.221425.363462−0.750.64360.02
Average −1.250.28654.48 −1.730.64577.40 1.880.64238.16
Publisher’s Note: MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

Share and Cite

MDPI and ACS Style

Xu, M.; Zhang, S.; Deng, G. No-Wait Job Shop Scheduling Using a Population-Based Iterated Greedy Algorithm. Algorithms 2021, 14, 145. https://doi.org/10.3390/a14050145

AMA Style

Xu M, Zhang S, Deng G. No-Wait Job Shop Scheduling Using a Population-Based Iterated Greedy Algorithm. Algorithms. 2021; 14(5):145. https://doi.org/10.3390/a14050145

Chicago/Turabian Style

Xu, Mingming, Shuning Zhang, and Guanlong Deng. 2021. "No-Wait Job Shop Scheduling Using a Population-Based Iterated Greedy Algorithm" Algorithms 14, no. 5: 145. https://doi.org/10.3390/a14050145

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop