Single machine scheduling problems with sequence-dependent setup times and precedence delays

Sequence-dependent setup times and precedence delays occur frequently in various production environments. This study investigates the single machine scheduling problem with setup times and precedence delays that occur in an amplifier assembly company. This study proposes a novel mixed-integer linear programming model and a lean iterated greedy algorithm to minimize the makespan for this problem. Based on the property of delayed precedence constraints, the lean iterated greedy (LIG) algorithm uses a simple but effective lean construction mechanism that can discard infeasible solutions to reduce the waste of unnecessary searches and quickly converge to the (near) global optimum. The computational results show that LIG significantly outperforms the state-of-the-art algorithm in terms of solution quality and computational efficiency. This study mainly contributes to providing a simple, effective, and efficient algorithm that can facilitate industrial applications and serve as a new benchmark approach for future research.

examined an SMSP with release dates, delivery times, and DP constraints without SDSTs constraints. They first pointed out that this problem is a relaxation of the job-shop scheduling problem (JSP) that is tighter than the standard SMSP relaxation. Then, Balas et al. 7 proposed a modified shifting bottleneck procedure that uses relaxation to minimize makespan in JSPs. The computational results showed that this approach could consistently provide better solutions for all classes of JSPs compared to other algorithms, but with more computational time. Finta and Liu 8 investigated an SMSP with PD constraints, with the goal of minimizing the makespan. In a scheduling problem with DP constraints, the release dates (RDs) of jobs are unknown before scheduling. They applied the concept of DP constraints to model the RDs of the jobs and computed them as a function of a given feasible schedule. Finta and Liu 8 proved that the problem is NP-hard in the strong sense when the delay and execution times are integers, it is polynomially solvable with an O(n 2 ) optimal algorithm. However, SDST constraints were not considered in this study either. Du and Han 9 presented an improved heuristic for solving SMSPs with DP constraints. Their research showed that this new approach has a better worst-case performance ratio of 4/3 than the heuristic of Wikum et al. 6 , which provided the best worst-case guarantee among all heuristics searching for insertion schedules. Moreover, the heuristic can optimally solve the corresponding unit execution time problem. Schuurman 10 proposed a pseudo-polynomial algorithm and a fully polynomial approximation scheme to solve an SMSP with PD constraints that has a simple tree-type structure, with the objective of minimizing the makespan. Schuurman proved that the proposed fully polynomial approximation scheme can provide a good approximation to the optimal schedule for the considered problem.
Brucker et al. 11 studied an SMSP with start-start DP constraints that allow positive and negative time-lags between the start times of two jobs. Unfortunately, SDSTs were not considered in their study. They pointed out that some complex job-shop and open-shop scheduling problems involving multiprocessor tasks, general purpose machines, or changeover times can be reduced to such an SMSP. Brucker et al. 11 showed that SMSPs with start-start relations are a complex problem and developed a branch and bound (B&B) algorithm to solve SMSPs with arbitrary time-lags and the reduction problems of the classical job-shop and open-shop scheduling problems. However, the computational results showed that the transformation and the B&B algorithm cannot efficiently solve the classical job-shop and open-shop scheduling problems. Munier and Sourd 12 studied three sub-problems of SMSPs with DP constraints in which each operation has at most one predecessor and one successor. They first presented an algorithm to solve the makespan minimization problem when all operations have the same duration and all delays are equal to a constant. Then, they considered that the length of each delay is smaller than the shortest processing time and presented one algorithm for minimizing the makespan and another for minimizing the flow time when all processing times are equal.
Muthusamy et al. 13 considered an SMSP with fuzzy time delays and fuzzy precedence constraints in which schedules were evaluated on three different performance measures: the makespan, the degree of satisfaction with the time delays, and the degree of satisfaction with the fuzzy precedence. They showed that the problem of finding a set of non-dominated feasible schedules that contains exactly one schedule from each equivalence class of non-dominated feasible schedules can be solved in polynomial time. Brucker et al. 14 studied SMSPs with constant processing times and generalized precedence constraints in the form of chains with constant delays. They showed that the problem of minimizing the total completion time is polynomially solvable. They also gave a compact encoding of an optimal schedule for minimizing the makespan of the problem. Given that a general SMSP with PD constraints is NP-hard, Xie et al. 15 studied an SMSP with fuzzy PD constraints and fuzzy processing times, with the objective of minimizing the makespan. They employed the upper and lower bounds presented by Wikum et al. 6 as parameters of L-R type fuzzy numbers and showed that the problem is polynomially solvable using the modified Lawler's algorithm in O(n 2 ). Yuan and Ou 16 proposed an O(n 2 ) algorithm for solving bi-criteria SMSPs with fuzzy time delays and fuzzy precedence constraints, in which the schedules were evaluated by performance measures of the degree of satisfaction with the fuzzy time delays and the degrees of satisfaction with the fuzzy PD constraints. However, it was left to the decision maker to decide which of the non-dominated schedules is better. Recently, Zhang et al. 17 proposed heuristics and branch-and-bound algorithms to minimize the makespan for SMSPs with PD constraints, release times, and delivery times. Their computational results showed that the proposed approaches could achieve significant improvements in running time and number of iterations on test instances both with and without delayed precedence constraints.
Inspired by a practical problem in a company that assembles amplifiers, Kuo et al. 2 presented the first study of the 1|s ij , prec(d ij )|C max problem. The process of assembling amplifiers consists of several steps, each of which is performed sequentially. Since different tools, fixtures, and assembly components are needed for different parts or products, SDSTs are required for preprocessing all parts or products. Since the covers of amplifiers are assembled with a special adhesive, there are DP constraints on assembly because of the need to wait for the adhesive to dry. Kuo et al. 2 presented a nonlinear programming model, a variable neighborhood search (VNS) metaheuristic, and five simulated annealing (SA) algorithms to solve the 1|s ij , prec(d ij )|C max problem. The computational results, based on 16 randomly generated scenarios, showed that VNS outperformed the five SA algorithms in solving the 1|s ij , prec(d ij )|C max problem and provided robust solutions for different DP scenarios.
The above review of the relevant literature showed there is a dearth of research on SMSPs that considers both SDSTs and DP constraints. To bridge the gap between scheduling theory and practical applications, this study proposed a mixed-integer linear programming (MILP) model and a more effective and efficient lean iterated greedy (LIG) algorithm to solve the 1|s ij , prec(d ij )|C max problem. Since VNS is the best available metaheuristic, it was used as a benchmarking algorithm in this study. The rest of this paper is organized as follows. In "Problem description and MILP model formulation" section , the 1|s ij , prec(d ij )|C max problem was defined, and its MILP model was formulated. Section "The lean iterated greed algorithm" describes the proposed LIG algorithm in detail. The experimental results and statistical analysis based on different scenarios are presented in "Computational experimentation and results" section. Finally, concluding remarks and recommendations for future research are given in Section "Concluding remarks".

Problem description and MILP model formulation
The 1|s ij , prec(d ij )|C max problem consists of a finite set J of n independent jobs to be processed on a single machine. The processing time of job j (j = 1, ..., n) on the machine is p j . An SDST,s ij , is needed before processing job j, if it is processed immediately after job i. A is the set of DP constraints for all jobs. For certain job pairs, (i, j) ∈ A , and the succeeding job j cannot be processed until its predecessor has completed the job and the corresponding delay time, d ij , between the completion time of the preceding job i and the start time of the job has elapsed. The objective is to find a feasible schedule for these n jobs that satisfies the precedence delays to minimize the makespan,C max , i.e., the completion time of the last executed job. In addition, the following assumptions are made in the addressed 1|s ij , prec(d ij )|C max problem: • Processing times, SDSTs, and delay times are assumed to be non-negative integers.
• Each job is assumed to be available for processing immediately at the beginning of the planning period.
• Each job must be processed on the machine exactly once without preemption.
• Each job is independent of the others and its processing time is known, fixed, and finite.
• Each job is processed as early as possible. Thus, there are no intentional waiting times for jobs or idle times of the machine. • The machine is available at the beginning of the planning period.
• The machine can process at most one job at a time.
• The machine is continuously available to process jobs throughout the planning period, and there are no interruptions due to breakdowns, maintenance, or any such cause. • The machine has an adequate waiting area where jobs can wait before being processed.
In this study, a novel MILP model was developed to formulate the 1|s ij , prec(d ij )|C max problem. The following notations were used in the proposed formulation: Indices. j,i Job tags, j = 1, 2, ..., n;i = 0, 1, ..., n , where 0 is a dummy job  (3) and (4) ensure that each job is dispatched to only one position in the sequence. Constraint sets (5) and (6) describe the relationship between the start time of a job and the completion time of its predecessor.

The lean iterated greed algorithm
In recent decades, researchers have proposed various meta-heuristics for solving intractable combinatorial optimization problems. Among these meta-heuristics, the iterative greedy (IG) algorithm 18 is one of the most efficient and effective methods to be successfully used in solving various scheduling problems [19][20][21][22][23] . The original IG algorithm proposed earlier 18 consists of two key phases: destruction and reconstruction. In each iteration, some incumbent solution elements are first selected and removed in the destruction phase. In the subsequent reconstruction phase, all removed elements are sequentially inserted into the remaining partial solution using a greedy heuristic until a new solution is assembled. After a new solution is constructed, some acceptance criteria are used to evaluate whether the incumbent solution will be replaced by it or not. The above process is repeated until certain termination conditions are met. Based on the basic framework of IG and the property of DP constraints, this study presented an LIG algorithm to solve the 1|s ij , prec(d ij )|C max problem. The innovation of the LIG algorithm is the proposed lean construction mechanism. To reduce the waste of unnecessary searches, two properties are used in the lean construction mechanism to discard infeasible positions that violate the DP constraints in the reconstruction phase of LIG, so that the search process can stay within the feasible solution space and quickly converge to the (near) global optimum. The following subsections elaborate on the solution representation, the construction of the DP constraint table, the method for computing the makespan, the lean construction mechanism, and the detailed procedures of the LIG algorithm.
Solution representation. In the proposed LIG algorithm, a feasible solution, , is encoded as a string of n numbers representing the job permutation without violating the DP constraints. For example, a solution encoded as [1 7 2 3 5 8 6 4] means that it has eight jobs, and the job permutation is 1-7-2-3-5-8-6-4. The following subsections explain how to ensure the generated solution does not violate the DP constraints.

Construction of the DP constraints table.
In this study, a DP constraint table was created to quickly determine whether or not inserting a removed job into a specific position in the partial solution would violate the DP constraint. Suppose that each DP constraint is expressed as DPC(i, j) = d ij , which means that job j cannot be processed before job i and its start time should be delayed at least d ij time units after the completion time of job i. Then, the DP constraint table with n jobs can be constructed as follows: Step 1 As shown in Table 1, the grid (i, j) is filled with U (undetermined) as the initial value if the predecessor, job i, is not equal to the successor, job j; otherwise, it is filled with P (prohibited) as the initial value.
Step 2 For each pair of jobs with DPC(i, j) = d ij , the grid (i, j) and the corresponding grid (j, i) are refilled with d ij and P (prohibited), respectively. If any job k must be processed after job j, the grid (k, i) is refilled with P.
For example, suppose there are eight jobs with five DP constraints, as shown in Table 2. Since the first DP constraint is DPC(1, 2) = 35, the grid (1, 2) and the corresponding grid (2, 1) are refilled with 35 and P, respectively. The second DP constraint is DPC(2, 3) = 0 , and grids (2, 3) and (3, 2) are refilled as 0 and P, respectively. Table 1. Initial values fill in the DP constraints table.

Predecessor\successor
Job 1 Job 2 · · · Job n − 1 Job n Table 2. DP constraints of the example. www.nature.com/scientificreports/ Since job 3 also must be processed after job 1, the grid (3, 1) is refilled with P. In the same way, processing the three remaining DP constraints yields the final lag times of the DP constraints table, as shown in Table 3.
Using the DP constraints table and SDST data respectively shown in Tables 3 and 4 as an example, the makespan of a given feasible solution, � = (1, 7, 2, 3, 5, 8, 6, 4) , can be calculated as shown in Table 5.
The lean construction mechanism. To avoid creating infeasible solutions that violate any DP constraints and to converge quickly to the (near) optimal solution, the proposed LIG algorithm implements a simple but effective lean construction mechanism described below.
Assuming there are k jobs in the current partial solution, there are k + 1 possible positions to insert the job that was removed in the previous destruction phase. Some positions may violate the DP constraints. Therefore, it is not necessary to test all positions and select the best position to insert the removed job. The following two properties are implemented in the lean construction mechanism to reduce the waste of unnecessary searches. First, if we insert the removed job at a position immediately before job J b in the partial solution will violate the DP constraints; it also violates the DP constrants if we insert the removed job at any position before J b . On the other hand, if we insert the removed job at a position immediately after job J a in the partial solution will violate the DP constraints; it also violates the DP constraints if we insert the removed job at any position after J a . Using  Figure 1. The procedure of the makespan calculation. www.nature.com/scientificreports/ the lean construction mechanism, infeasible positions that violate the DP constraints can be discarded in the reconstruction phase of LIG, and the solution quickly can converge to the (near) optimum. Procedures of the proposed LIG algorithm. The procedures of the proposed LIG algorithm are described as follows: Step 1 Generate a feasible initial solution The method for generating the initial solution is to add one job at a time to the last position of the current partial solution until a complete schedule is created. To ensure the generated initial solution is feasible, the job with the shortest completion time that satisfies the DP constraints is selected next in each iteration. The detailed procedure for generating the initial solution is shown in Fig. 2, where J c is the set of candidate jobs that satisfies the DP constraints in each iteration and J u denotes the set of unscheduled jobs.
Step 2 Enter the destruction and reconstruction phases (a) Destruction phase: Randomly select D jobs from the incumbent solution incumbent , then move them to d and sort them in the order in which they were selected. Set the remaining jobs in the incumbent solution as the current partial solution, p . (b) Reconstruction phase: Apply the lean construction mechanism to sequentially insert the jobs from d into p until a new complete solution, new , is created.
Step 3 Apply the acceptance criteria Apply the following criteria to evaluate whether or not the incumbent solution incumbent and the bestfound solution best will be updated by new : IF C max (� new ) ≤ C max (� best ) , set best := new and incumbent := new ; ELSE_IF C max (� new ) ≤ C max (� incumbent ) , set incumbent := new ; ELSE_IF C max (� new ) > C max (� incumbent ) , generate r ~ U (0,1); IF r < Exp(−�E) , set incumbent := new . Otherwise, discard new .
wherein SF is a scale factor used to control the probability of accepting a worse solution.
Step 4 Apply the stopping criterion Repeat Steps 2 to 3 until the maximum allowable computational time, T max , is reached. In this study, T max = τ × n (CPU time in seconds), in which τ is a parameter that controls the maximum allowable computational time.
Using the data presented in Tables 2, 3, 4 as an example, one iteration of the proposed LIG algorithm is shown in Fig. 3 to clearly illustrate the procedure. In Step 1, a feasible initial solution, =(1, 7, 2, 3, 5, 8, 6, 4) with C max (�) = 166 , was generated. In Step 2, the destruction and reconstruction phases, which can be considered as the perturbation mechanism, were executed. In Step 2(a), three jobs (i.e., jobs 8, 5, and 1) were randomly selected and sequentially removed from the incumbent solution to d . In Step 2(b), a new complete solution, new =(1, 7, 5, 2, 3, 6, 4, 8) with C max (� new ) = 150, was created by sequentially inserting the jobs in d =(8, 5, 1) into p =(7, 2, 3, 6, 4). Then, in Step 3, best and incumbent were updated by new according to the acceptance criteria. If the quality of new was worse than that of incumbent , the Boltzmann function ( e [C max (� new )−C max (� incumbent )]/[SF×C max (� incumbent )] ) was used to determine whether incumbent could be replaced by new or not. This mechanism is usually implemented in the annealing process of the SA algorithm to make it easier for the incumbent solution to escape from the local optimum.

Computational experimentation and results
An extensive computational experiment was conducted to evaluate the performance of the proposed IG algorithm in solving the 1|s ij , prec(d ij )|C max problem. The following subsections describe the benchmark problem set, parameter calibration, and computational results of LIG compared to the state-of-the-art algorithm.
The benchmark problem set. To fairly compare the performance of the proposed LIG algorithm with that of the existing best solution algorithm, i.e., VNS, the benchmark problem set of a similar approach by Kuo et al. 2 was created and used in this study. The benchmark problem set consisted of 540 test instances created as described here. The number of jobs was n ={10, 15, 20, 25, 50, 75, 100}; the processing times were randomly generated using the uniform distributions [10,20] and [20,30], respectively; the SDSTs were randomly generated using the uniform distributions [5,10] and [10,15], respectively; the delay times were randomly generated using the uniform distributions [20,40] and [40, 60], respectively; and ⌈n/2⌉ number of randomly selected jobs were subject to precedence constraints, in which ⌈n/4⌉ number of jobs had zero delay time. On this basis, ten test instances were generated for each of the 7 × 2 × 2 × 2 × 1 × 1 = 56 configurations to analyze the performance of LIG under different operational scales and workloads. The files of these test instances can be downloaded from http:// swlin. cgu. edu. tw/ data/ SDSTs DP_ Data. 7z.
The proposed LIG algorithm and VNS were coded and compiled in Visual C + + (2017), and the source code of VNS was provided by Kuo et al. 2 . All experiments were performed on a personal computer (PC) with the following specifications: an Intel Core Xeon CPU E5-1620v2 @ 3.70 GHz processor, 64 GB RAM, and the Windows 10 operating system. The MILP mathematical model was solved using Gurobi version 9.0 on the same PC with a maximum computation time of 3600 s for each test instance. The final solution generated by the Gurobi MILP solver was recorded as a feasible solution.
Parameter calibration. Before starting the computational experiments, 12 test instances were generated using the same data generation procedures as described above to calibrate the three parameters, D, SF, and τ , of the  Table 6, four alternatives for each parameter were tested to analyze which results were better. Each of the 12 test instances was solved 20 times in the preliminary tests. The resulting maximum (Max.), average (Ave.), and minimum (Min.) makespan values for each parameter combination were recorded, and their respective relative percent deviations (RPDs) were calculated as follows: where C max (�) P is the makespan value yielded by the parameter combination P, and C max (�) min denotes the minimum makespan value yielded among all parameter combinations. Figure 4 shows the effects of each parameter on the quality of the solutions. The parameter SF affects the probability of accepting a worse solution. In general, the higher the value of SF, the higher the probability of accepting a worse solution, and the slower the convergence speed of the LIG algorithm. However, if the value of SF is too small, the probability that a worse new solution will be accepted will also be very low, and the algorithm will not be able to escape from the local optimum. As can be seen in Fig. 4a, if the value of SF is too small, the corresponding Ave. RPD will be slightly larger. However, there is no significant difference between the different SF values. The value of D indicates the number of jobs removed in each iteration of the destruction phase, which may affect the range of the neighborhood solution search. Figure 4b demonstrates that the average RPD is larger when the value of D is too high or too low. Thus, when the value of D is too small, the search range of the neighborhood solution is too small, resulting in the poor quality of the solution. However, if too many jobs are removed, a better solution may not be obtained because the maximum computation time is limited. Figure 4c shows that the higher the value of τ , the smaller the value of Ave. RPD. This means that a better solution can be obtained with more computation time. Based on the computation time and the quality of the solutions in the preliminary experiments,SF = 100, D = 3, and τ = 0.1 were selected for the final experiments.

Results and discussion
In this study, the average relative percentage deviation (Ave. RPD) was used as a performance measure to compare the performance of the LIG and VNS algorithms. For each small instance ( n = 10 and 15), the RPDs of the solutions obtained using LIG, VNS, and the MILP mathematical model were calculated according to the following expression: where C Method max is the best makespan value of the feasible solution obtained with a given method among five trials, and C LB max is the lower bound (LB) of the makespan value obtained by the MILP mathematical model with a maximum computation time of 3600 s for each test instance. A feasible solution was optimal when the gap between its makespan value and the LB was zero. Table 7 summarizes the computational results for the small instances and shows that the total average RPD value of the solutions obtained with LIG was smaller than those obtained with the VNS and the MILP model. The MILP model obtained optimal solutions in 80 out of 80 and one out of 80 test instances for the test instances using n = 10 and n = 15, respectively. It is noteworthy that all optimal solutions obtained with the MILP model were also obtained with LIG. Overall, LIG obtained eight and 93 better solutions than the MILP model and VNS, respectively, for 160 small instances. The CPU times required by LIG and VNS were significantly shorter than those of the MILP model. It could be concluded that the tested metaheuristics were better for solving small instances when the efficiency of the approach was the most important indicator. These analytical results confirmed that the proposed LIG algorithm had excellent convergence to optimal solutions compared to the VNS algorithm and the MILP model.
The numerical results were also elaborated for solving larger test instances. The 1|s ij , prec(d ij )|C max problem is very complex, so high-quality feasible solutions and LBs could not be obtained with the MILP model for the test instances with n = 20, 25, 50, 75, and 100. Therefore, the RPD value for each larger test instance was calculated using the following expression: where C Method max is the best makespan value of the solution obtained with a given method among five trials, and C best max is the best makespan value among the solutions obtained with LIG and VNS. Table 8 lists the computational results for the larger test instances and shows that the best and mean RPDs of the solutions obtained with LIG were significantly smaller than those obtained with VNS with respect to all www.nature.com/scientificreports/ categories of the larger test instances. The total average best and mean RPDs obtained with the proposed LIG algorithm were 0.000% and 0.050%, respectively, while those obtained with VNS were 3.279 and 3.580%, respectively. The mean RPDs achieved with LIG were smaller than those of VNS, indicating that the performance of LIG was more robust than that of VNS at all larger production scales and workloads. In addition, the computation time required by LIG was much less than that of VNS. It was observed that the gap between the computation times of LIG and VNS increased as the number of jobs increased. As a final step in the numerical analysis, one-sided paired t-tests were performed on the best and mean RPDs to validate whether or not LIG was significantly superior to VNS. The statistical results are summarized in Table 9. From Table 9, it could be seen that the statistical tests at a confidence level of α = 0.05 demonstrated the proposed LIG algorithm was significantly superior to the VNS algorithm in terms of best and mean RPDs for both small and large test instances.

Concluding remarks
The 1|s ij , prec(d ij )|C max problem is a theoretical and practical problem that corresponds to conditions in many existing production systems. This study contributed to the literature by proposing a novel MILP model and an LIG algorithm that filled a gap in the development of solution methods for this understudied problem. Numerical experiments have shown that LIG consistently found better solutions than the benchmarking algorithm in all test instances, at a lower computational cost, making it a viable solution approach for relevant industrial applications. Despite its importance for real-world applications, research on the 1|s ij , prec(d ij )|C max problem is still scarce and can be extended in several directions. First, more effective and efficient exact methods and heuristic algorithms, such as those based on supervised-and unsupervised-learning-based algorithms, should be further explored. Second, an alternative performance measure or multi-criteria SMSP with SDSTs and DP constraints are worthy of research. Third, from a practical point of view, new extensions of the 1|s ij , prec(d ij )|C max problem, such as multi-agent problems, deserve further exploration. Finally, the extension of this deterministic problem to stochastic and dynamic models is also worth further investigating.