Effective Heuristic Algorithms Solving the Jobshop Scheduling Problem with Release Dates

Abstract

Manufacturing industry reflects a country’s productivity level and occupies an important share in the national economy of developed countries in the world. Jobshop scheduling (JSS) model originates from modern manufacturing, in which a number of tasks are executed individually on a series of processors following their preset processing routes. This study addresses a JSS problem with the criterion of minimizing total quadratic completion time (TQCT), where each task is available at its own release date. Constructive heuristic and meta-heuristic algorithms are introduced to handle different scale instances as the problem is NP-hard. Given that the shortest-processing-time (SPT)-based heuristic and dense scheduling rule are effective for the TQCT criterion and the JSS problem, respectively, an innovative heuristic combining SPT and dense scheduling rule is put forward to provide feasible solutions for large-scale instances. A preemptive single-machine-based lower bound is designed to estimate the optimal schedule and reveal the performance of the heuristic. Differential evolution algorithm is a global search algorithm on the basis of population, which has the advantages of simple structure, strong robustness, fast convergence, and easy implementation. Therefore, a hybrid discrete differential evolution (HDDE) algorithm is presented to obtain near-optimal solutions for medium-scale instances, where multi-point insertion and a local search scheme enhance the quality of final solutions. The superiority of the HDDE algorithm is highlighted by contrast experiments with population-based meta-heuristics, i.e., ant colony optimization (ACO), particle swarm optimization (PSO) and genetic algorithm (GA). Average gaps 45.62, 63.38 and 188.46 between HDDE with ACO, PSO and GA, respectively, are demonstrated by the numerical results with benchmark data, which reveals the domination of the proposed HDDE algorithm.

1. Introduction

Smart manufacturing has become a new competitive advantage in many countries. Therefore, governments have issued smart-manufacturing-related strategies, such as ‘Made in China 2025’ in China and ‘Industrial 4.0’ in Germany. One goal of smart manufacturing is to improve customer satisfaction by meeting the requirement of customization, which is a common customer demand pattern in the smart era. Jobshop is a manufacturing system that makes products with bespoke productive processes. For example, a gear is a key part in automatic equipment such as transmission. Precision gears are manufactured by computerized numerical control (CNC) machine tools. In accordance with product shape, CNC machine tools handle gear blanks with preset processing routes over time. The manufacturing process of gears can be abstracted as a jobshop scheduling (JSS) model where each job has its own release date. Akers and Friedman [1] were the first to formulate a four-machine JSS problem. Since then, considerable attention has been focused on this research area. A comprehensive survey on the JSS problems can be found in Jain and Meeran [2] and Zhang et al. [3].

Generally, the optimal objectives of the JSS model are makespan that can minimize maximum machine loads, or total completion time (TCT) that can minimize work-in-process inventory. Academically, these criteria are linearized with designated weight factors for substituting bi-objective optimization. However, the error of the weight factors will result in a deviation between linearization and dual objectives. Cheng and Liu [4] indicated the advantage of the total k-power completion time (TKCT) criterion, which balances makespan and TCT. On the one hand, TKCT approaches makespan as k→∞ because only the maximum completion time dominates the objective value in this situation. On the other hand, TKCK is just TCT as k = 1. Therefore, the total quadratic completion time (TQCT) criterion is introduced as a trade-off for machine loads and work-in-process inventory.

Garey et al. [5] reported the strong NP-hardness for the JSS TCT problem even for the two-machine case, indicating that the JSS TQCT problem with release dates is at least as difficult as the former. Therefore, no polynomial time algorithm can solve the studied problem unless P = NP. Constructive heuristic and meta-heuristic algorithms are designed to handle different scale instances. The shortest processing time, dense schedule (SPT-DS) heuristic, is proposed to achieve feasible solutions for large-scale instances. A preemptive single-machine-based lower bound is designed to estimate the optimal solution and reveal the performance of the heuristic. A hybrid discrete differential evolution (HDDE) algorithm is provided to achieve near-optimal solutions for medium-scale instances, where multi-point insertion and a local search scheme enhance the quality of final solutions. The superiority of the presented algorithms are confirmed through conducting extensive contrast experiments.

Compared with the known literature, the contributions of this study mainly include three aspects:

• A JSS model with the TQCT criterion is established, where each job is available at its own release date. This scheduling model simulates the production environment in which jobs arrive to the system over time.
• An HDDE algorithm is presented to achieve high-quality schedules in a given time, where tri-point insertion in crossover operator and local search scheme with exchange neighbourhood enhance the quality of final solutions.
• An innovative heuristic algorithm combining SPT and dense scheduling rule is proposed, which provides dominant feasible solutions on large-scale instances.
• A preemptive single-machine-based lower bound is proposed to estimate the optimal schedule, which can server as an estimation of the optimal solution to evaluate the performance of approximate algorithms.

The remainder of the paper is arranged as follows. A literature survey is presented in Section 2. Section 3 establishes a mixed integer programming (MIP) model for the JSS problem. Section 4 proposes an SPT-DS heuristic algorithm and a new lower bound. Section 5 provides the DDE algorithm to deal with medium-scale instances. Section 6 executes numerical experiments and reports the analysis results. Section 7 concludes the paper and indicates future research directions.

2. Literature Review

The JSS model is one of the most complex problems in combination optimization [6]. Except for several polynomial-solvable cases, most JSS problems are NP-complete [7]. Therefore, related research for JSS problems mainly puts attention on the application of metaheuristic algorithms to achieve near-optimal solutions.

The criterion for most single-objective optimizations is to minimizing makespan. Khadwilard et al. [8] adopted firefly algorithm and used one-third fractional factorial experimental design to set parameters. Gao et al. [9] presented a hybrid particle-swarm tabu search (TS) algorithm, where particle swarm optimization (PSO) with a balanced strategy provides diverse and elite initial solutions for the TS algorithm. Qiu and Lau [10] proposed a novel hybrid algorithm integrating clonal selection, immune network, and PSO concept. Wang and Duan [11] designed a hybrid biogeography-based optimization algorithm that introduced chaos theory and strategy to explore and improve population diversity. Keesari and Rao [12] applied teaching-learning-based optimization (TLBO), in which the learner phase in the original TLBO is modified. Asadzadeh [13] addressed an agent-based local search genetic algorithm (GA). Peng et al. [14] presented a hybrid TS/path relinking algorithm that referred to features including a path construction procedure on the basis of distances of solutions and a special mechanism to select the reference solution. Kurdi [15] proposed a hybrid island model GA with naturally inspired self-adaptation phase strategy, which stroked a balance between diversification and intensification during search. Cheng et al. [16] presented the hybrid evolutionary algorithm (HEA), in which a TS procedure is incorporated into the framework of an evolutionary algorithm. HEA embraces several distinguishing features such as the longest common sequence-based recombination operator and a similarity-and-quality-based replacement criterion for population updating. Dao et al. [17] applied the concept of a parallel processing to bat algorithm.

Some extended studies on JSS problems have been conducted to minimize makespan. Saidi-Mehrabad et al. [18] considered a specific production system constituted by a warehouse, a network guide-path, several machines, and the transportation between machines. They built an integrated mathematical model composed of the JSS and conflict-free routing problems for automated guided vehicles to convey jobs and applied a two-stage ant colony algorithm. Sundar et al. [19] discussed the JSS problem with no-wait constraint and presented a hybrid artificial bee colony (HABC) algorithm where the artificial bee colony algorithm coupled with a local search effectively coordinates the various components of HABC. Kuhpfahl and Bierwirth [20] considered the JSS problem with total weighted tardiness objective and developed an approach on the cornerstone of disjunctive graphs to capture the neighborhood structure. They found a structural classification of neighbourhood operators and some new analytical results. Kundakcı and Kulak [21] introduced efficient hybrid GA methodologies for the dynamic JSS problem. Ku and Beck [22] evaluated four MIP formulations for the classical JSS problem using three modern optimization software.

Some researchers have conducted studies on bi-objective optimization. Phanden et al. [23] applied a simulation-based GA algorithm with restart scheme to handle three special cases to minimize mean tardiness and makespan. Nguyen et al. [24] developed four multi-objective genetic programming-based hyper-heuristic methods for the automatic design of scheduling policies and simultaneous handling of multiple scheduling decisions, owing to the complexity of each scheduling decision as well as the interactions among different decisions. They proposed a diversified multi-objective co-operative coevolution method by which different multiple scheduling decisions can evolve in sub-populations. May et al. [25] merged and upgraded NSGA-II and SPEA-II to build a green GA to optimize productivity and environmental objectives. Salido et al. [26] focused on the JSS problem with machine speed scaling where variable-speed machines have different energy efficiencies to minimize makespan and energy use. They also designed a GA to model and solve the JSS problem. On the basis of the machine speed scaling framework, Zhang and Chiong [27] minimized the total weighted tardiness and the total energy consumption and combined a multi-objective GA incorporated with two problem-specific local improvement strategies.

The known studies on the JSS problems are basically concentrated on makespan criterion for research convenience. However, in an industrial environment, the makespan criterion is too simple to offer insight for complex scheduling event. Therefore, this article focuses on the TQCT criterion, which can effectively balance energy consumption of machines and cost of work-in-process inventory.

3. MIP Model

In a JSS system, a series of m machines handles a number of n jobs following their own preset processing routes. O_i,j denotes the i-th execution of job j. Q_i,j denotes that job j is processed on machine i, i = 1, 2, …, m, j = 1, 2, …, n. The processing time of job j on machine i is denoted as p_i,j, where p_i,j = 0 indicates that operation O_i,j is nothingness. Release date r_j is the earliest time when job j is available. Each machine processes a job at most once and no re-circulation occurs in the system. The intermediate buffer between any adjacent machines has unlimited storage capacity. At any moment, each machine can process at most one job, and each job can access at most one machine. Any preemptive phenomenon is prohibitive, i.e., a starting operation must be continued until it is completed. The optimal objective is to achieve a feasible schedule for minimizing the total quadratic completion time.

The definition of symbol for the MIP model is shown in

Table 1. Model variables.

Variables		Meanings
n		total number of jobs;
m		total number of machines;
rj		release date of job j;
pi,j		processing time of job j on machine i;
Ci,j		completion time of job j on machine i;
Cj		maximum completion time of job j;
aj,i,l	=	1, if job j is processed on machine i before machine l; 0, otherwise.
zi,j,k	=	1, if job k precedes job j immediately on machine i; 0, otherwise.
yi,j	=	1, if the first operation of job j is processed on machine i; 0, otherwise.
M		a large positive number.

.

Therefore, the following MIP model is established.

$$\mathrm{Minimize} {\displaystyle {\sum }_{j=1}^n{C}_j^2}$$

Subject to:

$$C_{i,j}+M\times \left(1-y_{i,j}\right)\ge r_j+p_{i,j},i=1,\dots m, j=1,\dots ,n$$

(1)

$${\displaystyle {\sum }_{j=0}^n{z}_{i,j,j}}=0, i=1,\dots ,m$$

(2)

$${\displaystyle {\sum }_{k=0}^n{z}_{i,j,k}}=1,j=0,\dots ,n, i=1,\dots ,m$$

(3)

$${\displaystyle {\sum }_{k=0}^n{z}_{i,j,k}}=1,j=0,\dots ,n, i=1,\dots ,m$$

(4)

$$z_{i,k,j}+z_{i,j,k}\le 1,i=1,\dots ,m, k=0,\dots ,n, j=0,\dots ,n$$

(5)

$$C_{l,j}-p_{l,j}+M\times (1-a_{j,i,l})\ge C_{i,j}, i,l=1,\dots ,m,j=1,\dots ,n$$

(6)

$$C_{i,j}-C_{i,k}+M\times (1-z_{i,k,j})\ge p_{i,j}, i=1,\dots ,m,k,j=1,\dots ,n$$

(7)

$$C_j\ge C_{i,j}, i=1,\dots ,m,j=1,\dots ,n$$

(8)

$$a_{j,i,l}\in \left\{0,1\right\}, z_{i,j,k}\in \left\{0,1\right\}, C_{i,j}\ge 0, C_j\ge 0,i,l=1,\dots m,j,k=1,\dots ,n$$

(9)

Constraint (1) states that job j must be processed after its release date r_j. Constraints (2) to (5) ensure the uniqueness of decision variable z_i,j,k. Constraint (6) illustrates the relationship of completion time between two adjacent operations of the same job. Constraint (7) defines the relationship between the completion times of two adjacent jobs on the same machine. Constraint (8) explains the meaning of decision variable C_j, which is the maximum completion time of each job. Constraint (9) specifies the 0–1 variables and value ranges for the inputs.

4. SPT-DS Heuristic and Lower Bound

Given that the JSS problem is NP-completed, a heuristic algorithm can effectively achieve feasible solutions in a very short time for massive production setting, in which continuous production is more important than optimal solution. Townsend [28] reported the optimality of the shortest processing first (SPT) rule for the single-machine TQCT problem. An SPT-based heuristic is proposed to handle the JSS TQCT problem with release dates. A preemptive single-machine lower bound based on the optimality of the shortest remaining processing time (SRPT) rule for the preemptive single-machine TQCT problem is presented to evaluate the performance of the heuristic [29].

4.1. SPT-DS Heuristic

Matrix T stores the processing route of each job. According to the precedence of operations in matrix T, all current operations are stored in set A, where current operation means an immediate successor of the operation that has just been processed for a given job. Matrix S and C store the start time and completion time of all operations, respectively, where s_i,j denotes the start time of job j on machine i, i.e., Q_i,j, and c_i,j denotes the completion time of job j on machine i, ∀j ∈ n, ∀i ∈ m, s_i,j ∈ S, c_i,j ∈ C. Each job j has a non-negative release date r_j and processing time p_i,j denotes the execution duration of Q_i,j.

Step 1: Set the start time s_i,j equals to release date r_j and let c_i,j = 0, ∀j ∈ n, ∀i ∈ m, Go to Step 2.

Step 2: Assign operation Q_i,j with the earliest start time s_i,j in set A. If there is more than one job with the earliest start time, then schedule the job with the shortest processing time. Go to Step 3.

Step 3: Update the completion time c_i,j = s_i,j + p_i,j. Delete operation Q_i,j in set A. Check the elements in matrix T to determine the machine on which the next execution of job j is processed. If machine k is the target, then add operation Q_k,j in set A. Go to Step 4.

Step 4: Update the start time of the remaining operations of job j, let s_k,j = max (s_k,j, c_i,j), 1 ≤ k ≤ m, and the start processing time of machine i, s_i,h = max (s_i,h, c_i,j), 1 ≤ h ≤ n. Go to Step 5.

Step 5: If set A ≠ Ø, turn to Step 2. Otherwise, stop the algorithm and calculate the objective value.

A numerical example is provided below to better explain the SPT-DS heuristic.

Example 1.

A JSS problem with three jobs {J₁, J₂, J₃} and three machines {M₁, M₂, M₃} is involved. The input data including processing times, release dates and processing routes are presented in

Table 2. Input data of Example 1.

Jobs	Processing Routes	Processing Times	Release Dates
J1	M2, M3, M1	4, 3, 2	1
J2	M3, M2, M1	6, 2, 2	0
J3	M1, M3, M2	2, 5, 1	2

.

The processing times and the processing routes of three jobs in Table 2 are restored in Matrices P and T. Matrices S and C record the start and completion times of each operation Q_i,j, 1 ≤ i ≤ 3, 1 ≤ j ≤ 3. In initial status, the completion times of all operations are set to zero, and the start times of jobs on all machines are equal to their release dates. The first raw in matrix T is [2, 3, 1] which means the first execution of job j, 1 ≤ j ≤ 3, can be processed on machine M₂, M₃ or M₁. Therefore, the data stored in set A is [Q_2,1, Q_3,2, Q_1,3]. The elements in each matrix are shown as follows.

$$T_{3\times 3}=\left[\begin{array}{ccc}2& 3& 1\\ 3& 2& 1\\ 1& 3& 2\end{array}\right],P_{3\times 3}=\left[\begin{array}{ccc}2& 2& 2\\ 4& 2& 1\\ 3& 6& 5\end{array}\right], C_{3\times 3}=\left[\begin{array}{ccc}0& 0& 0\\ 0& 0& 0\\ 0& 0& 0\end{array}\right],S_{3\times 3}=\left[\begin{array}{ccc}1& 0& 2\\ 1& 0& 2\\ 1& 0& 2\end{array}\right].$$

Schedule the operation in set A with the earliest start time. For example, s_2,1 = 1, s_3,2 = 0, s_1,3 = 2. Therefore, the first operation of job J₂ is scheduled on machine M₃, i.e., Q_3,2. The completion time of Q_3,2 is c_3,2 = s_3,2 + p_3,2 = 0 + 6 = 6. Then update set A and check the elements in matrix T. As the second execution of job J₂ is actually processed on machine M₂, the data stored in set A is updated to [Q_2,1, Q_2,2, Q_1,3]. Then, update matrix S by recalculating the start time of job J₂ and machine M₃. For example, s_2,2 = max (s_2,2, c_3,2) = max (0, 6) = 6, and s_3,1 = max (s_3,1, c_3,2) = max (1, 6) = 6. The elements in each matrix are shown as follows.

$$C_{3\times 3}=\left[\begin{array}{ccc}0& 0& 0\\ 0& 0& 0\\ 0& 6& 0\end{array}\right],S_{3\times 3}=\left[\begin{array}{ccc}1& 6& 2\\ 1& 6& 2\\ 6& 6& 6\end{array}\right].$$

Next, repeat the above steps to select an operation from set A to schedule until set A is empty. The final operation schedules on machines M₁, M₂, and M₃ are {J₃, J₂, J₁,}, {J₁, J₂, J₃} and {J₂, J₁, J₃}, respectively. The Gantt chart of the SPT-DS schedule is provided in Figure 1. The objective value of the schedule is 12² + 10² + 15² = 469.

4.2. Well-Designed Lower Bound

An effective lower bound is proposed for the JSS TQCT problem to estimate the optimal value for large-scale instances. The basic idea of designing the lower bound is to relax the constraints of the relationship between machines and non-preemption for each job. Letting $p_{i,k}^{SRPT}$ denote that operation $O_{i,k}$ is scheduled according to the SRPT rule, lower bound $Z^{LB}$ is shown as follows.

$$Z^{LB}={\max }_{1\le i\le m}\left\{{\displaystyle {\sum }_{j=1}^n{(C_{i,j}^{LB})}^2}\right\}$$

(10)

where

$$C_{i,j}^{LB}={\max }_{1\le x\le j}\left\{r_x+{\displaystyle \sum _{k=x}^j{p}_{i,k}^{SRPT}}\right\}$$

Given the NP-hardness of the JSS TQCT problem, i.e., it cannot be solved in polynomial time for large-scale instances, an effective lower bound is usually served as a substitute of the optimal schedule to evaluate approximation algorithms. Generally, the lower bound is the optimal solution of a relaxation version of the original problem. An m-machine JSS TQCT problem is reduced to m preemptive versions of the single-machine scheduling (SMS) problem to minimize the TQCT criterion with release dates. Bai [29] proved that the SRPT rule is optimal for the preemptive SMS TQCT problem. Therefore, each of these SRPT schedules is a lower bound of the JSS TQCT problem. As a larger lower bound can provide better performance for minimization criteria, the dominative one among the m lower bounds is selected as the final lower bound for the JSS TQCT problem.

To better explain the lower bound, a numerical example is provided as follows.

Example 2.

The input data are similar to those in Example 1. The lower bound schedule with the SRPT rule on the three machines is shown in Figure 2. The scheduling on machine M₂is explained in detail for better understanding. At time t = 0, only job J₂ is available. At time t = 1, job J₁ is released and the remaining time of job J₂ is 5 > p_2,1 = 4. On the basis of the SRPT rule, job J₂ is preempted by job J₁. At time t = 2, similarly, job J₁ is preempted by job J₃. Given that no extra job is released after the completion of job J₃, the remaining parts of jobs J₁ and J₂ are scheduled with the SRPT rule. The full schedule for the lower bound is presented in Figure 2. The associated lower bound value is

$${\mathrm{Z}}^{\mathrm{LB}}=\max \left\{2^2+4^2+6^2,{11}^2+3^2+6^2,9^2+4^2+{14}^2\right\}=293.$$

5. Effective HDDE Algorithm

The SPT-DS heuristic algorithm can quickly output a feasible solution for large-scale instances. However, the quality of the SPT-DS schedule weakens for medium-scale instances. For example, the mean gap is approximately 185% for 20 random instances with the combination m × n = 3 × 30. Relatively, meta-heuristic is a type of higher level heuristic that controls the entire search process. Thus, the global optimal solutions can be achieved systematically and efficiently. The differential evolution (DE) algorithm is a population-based evolutionary algorithm for global optimization in a continuous search space. The DE algorithm improves candidates by executing mutation and crossover operations, and renews the population through greedy one-to-one selection. Compared with the classical evolutionary-based meta-heuristics, the superiority of the DE algorithm involves easy implementation, simple structure, robust, and fast convergence. The traditional DE algorithm was originally used to solve the global optimization problem in the continuous search space, in which individuals were encoded by floating point numbers that are invalid for discrete variables. This section transforms individuals into operation-based sequences and proposes the HDDE algorithm to solve the JSS problem.

5.1. Encoding and Decoding

Given the diversity of process routes for each job in a JSS model, a job-number-based (JNB) representation is introduced to encode and decode between individuals and feasible schedules in the DDE algorithm. The encoding scheme linearizes the operations in a feasible schedule according to their starting times and represents an individual by the corresponding job number. The decoding scheme restores a JNB individual to a feasible schedule, where each operation is assigned in turn to the available machine following the given machine sequence. Matrices $T_{m\times n}$ (operation sequences) and ${\widehat{P}}_{m\times n}$ (processing times of operations) are presented as follows.

$$T_{m\times n}=\left[\begin{array}{cccc}{t}_{11}& t_{12}& \cdots & t_{1n}\\ t_{21}& t_{22}& \cdots & t_{2n}\\ ⋮& ⋮& ⋮& ⋮\\ t_{m1}& t_{m2}& \cdots & t_{mn}\end{array}\right] \mathrm{and} {\widehat{P}}_{m\times n}=\left[\begin{array}{cccc}{\widehat{p}}_{11}& {\widehat{p}}_{12}& \cdots & {\widehat{p}}_{1n}\\ {\widehat{p}}_{21}& {\widehat{p}}_{22}& \cdots & {\widehat{p}}_{2n}\\ ⋮& ⋮& ⋮& ⋮\\ {\widehat{p}}_{m1}& {\widehat{p}}_{m2}& \cdots & {\widehat{p}}_{mn}\end{array}\right]$$

A numerical example is provided below to further describe the encoding and decoding processes.

Example 3.

A JSS model with three jobs {J₁, J₂, J₃} and three machines {M₁, M₂, M₃} is provided to explain the procedure in detail. The input data are similar to those in Example 1. The data in Matrices $T_{3\times 3}$and ${\widehat{P}}_{3\times 3}$are presented as follows.

$$T_{3\times 3}=\left[\begin{array}{ccc}2& 3& 1\\ 3& 2& 3\\ 1& 1& 2\end{array}\right] \mathrm{and} {\widehat{P}}_{3\times 3}=\left[\begin{array}{ccc}4& 6& 2\\ 3& 2& 5\\ 2& 2& 1\end{array}\right]$$

where t₂₃ = 3 indicates that machine M₃ processes operation O_2,3 and ${\widehat{p}}_{23}$ = 5 is its associated processing time. The SPT-DS schedule in Figure 1 can be linearized as π = {O_1,2, O_1,1, O_1,3, O_2,2, O_2,1, O_3,2, O_2,3, O_3,1, O_3,3}. In encoding, the individual of schedule π is denoted as JS = {2, 1, 3, 2, 1, 2, 3, 1, 3}, and the corresponding machine sequence is MS = {3, 2, 1, 2, 3, 1, 3, 1, 2}. In decoding, the operations of individual JS are assigned to permutation MS and scheduled with the dense scheduling rule, which generates a feasible schedule.

5.2. Initialization

The main task of initialization is to generate the initial population and set the parameters. The initial population is randomly generated by swapping adjacent genes in a chromosome. Orthogonal tests are designed to determine four parameters, including population size Λ, the maximum number of iterations τ_max, mutant factor Z, and crossover factor Y, thereby enhancing the performance of the algorithm. The pseudo-code for initialization is provided in Procedure 1.

Procedure 1: Initialization
1	Input: n,Λ,m //n is the number of jobs, m is the number of machines, Λ is the size of the population
2	Output: pop[Λ] [m × n]←Array to store initial population;
3	begin
4	j ← 1;
5	for (i from 0 to m × n − 1) do
6	for (x from i to i + m − 1) do
7	pop[0][x] ← j;
8	end for
9	i ← i + m; j ← j + 1;
10	end for
11	for (i from 1 to Λ) do
12	for (j from 0 to m × n − 1) do
13	P[j] ← pop[i − 1][j];
14	end for
15	t ← rand(1,m × n);
16	f ← rand(1,m × n);
17	if (t ! = f)
18	temp ← P[t − 1];
19	P[t − 1] ← P[f − 1];
20	P[f − 1] ← temp;
21	else
22	i ← i − 1;
23	Continue;
24	end if
25	for (j from 0 to m × n − 1) do
26	pop[i][j]←P[j];
27	end for
28	end for
29	return pop[Λ] [m × n];
30	end

5.3. Mutation and Crossover

The mutation operator is executed on all individuals in the current population to generate the mutant individual $V_h{}^k=[v_{h_1}^k,v_{h_2}^k,\dots ,v_{h_{m\times n}}^k]$ at iteration k, where h ∈ [1, Λ]. Two pairs of target individuals {$X_{{\alpha }_1}^{k-1}$, $X_{{\beta }_1}^{k-1}$} and {$X_{{\alpha }_2}^{k-1}$, $X_{{\beta }_2}^{k-1}$} are randomly selected from the (k−1)th population to implement the mutation operation with current optimal individual $X_{best}^{k-1}$ (the individual with the optimal objective value in the (k−1)th population). The mutation operator is expressed as follows.

$$V_h^k=X_{best}^{k-1}\oplus Z\otimes \left(X_{{\alpha }_1}^{k-1}-X_{{\beta }_1}^{k-1}\right)\oplus Z\otimes \left(X_{{\alpha }_2}^{k-1}-X_{{\beta }_2}^{k-1}\right)$$

(11)

where Z ∈ [0,1] is the mutant factor. In Equality (11), operator $\otimes$ is executed as follows.

$$G_{h_x}^k=Z\otimes \left(X_{{\alpha }_x}^{k-1}-X_{{\beta }_x}^{k-1}\right)=\{\begin{array}{l}{X}_{{\alpha }_x,w}^{k-1}-X_{{\beta }_x,w}^{k-1},\hspace{0.17em}\mathrm{if} rand(·)<Z\\ 0,\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em} \mathrm{otherwise}\end{array},w\in m\times n$$

(12)

where rand (•) is a random number assigned to each element of the difference individual and x = 1, 2. Operator $\oplus$ in Equality (11) is executed as follows.

$$V_h^k=mod\left(\left(X_{best,w}^{k-1}+G_{h_1,w}^k+G_{h_2,w}^k+n-1\right),n\right)+1,w\in m\times n$$

(13)

where mod (•) is the modular operator, which guarantees that each vector in a mutation individual represents a valid job number. The pseudo-code for the mutation operator is provided in Procedure 2.

Procedure 2: Mutation operator
1	Input: pop[Λ] [m × n];//initial population
2	Output:$V_h^k$
3	Begin
4	do
5	{
6	αx, βx ← random(1,Λ);//x = 1,2
7	} while(αx, βx (x = 1,2) is pairwise different);
8	/Operation of operator ⊗ */
9	$X_{\alpha x,j}^{k-1}$←An individual randomly selected from the population;
10	$X_{\beta x,j}^{k-1}$←Another non-repeating individual randomly selected from the population;
11	for (j from 1 to m × n) do   //n is the number of jobs and m is the number of machines
12	γ←random(0,1);
13	if (γ < Z)
14	$G_{h,j}^k$ = $X_{\alpha x,j}^{k-1}$ − $X_{\beta x,j}^{k-1}$;
15	else
16	$G_{h,j}^k$ = 0;
17	end if
18	end for
19	/* Operation of operator ⊕ */
20	for (j from 1 to m × n) do
21	$V_{h,j}^k=\mathrm{mod}((X_{best,j}^{k-1}+G_{h1,j}^k+G_{h2,j}^k+n-1),n)+1$;
22	end for
23	return $V_h^k$;
24	end

The crossover operator selectively inserts a mutation individual into a target individual $X_h^{k-1}$ to generate a trial individual $U_h^k$. A series of random numbers is assigned to the vectors in a mutant individual $V_h^k$. For each element in the mutation individual, if the random number rand (•) < Y, then the element is retained; otherwise, it is removed, where $Y\in (0,1)$ is a crossover factor. Tri-point insertion is executed to obtain a temporary individual, where the remaining elements of a mutation individual are divided into three parts and inserted in three randomly selected positions on target individual $X_h^{k-1}$. The trial individual $U_h^k$ is achieved by deleting the extra elements (repeat more than m times) in the temporary individual from left to right. The pseudo-code for crossover operator is presented in Procedure 3.

Procedure 3: Crossover operator
1	Input:$V_h^k$
2	Output:$U_h^k$
3	Begin
4	for (j from 0 to m × n − 1) do   //n is the number of jobs and m is the number of machines
5	r ← random (0,1);
6	if (r >= Y) do
7	$V_h^{’k}$←Remove $v_{h,j}^k$ ∈ $V_h^k$;
8	end if
9	end for
10	$U_h^k$←$X_h^{k-1}$;
	$V_h^{’k}$←Randomly split $V_h^{’k}$ into three parts;
11	Generate three random insertion points of $U_h^k$;
12	The divided three parts of $V_h^{’k}$ is inserted into the three random insertion points of $U_h^k$ in sequence;
13	$U_h^k$←Remove duplicate operations;
14	return $U_h^k$
15	End

A numerical example is provided below to further describe the mutation and crossover operations.

Example 4.

A JSS model with three jobs {J₁, J₂, J₃} and three machines {M₁, M₂, M₃} is provided to explain the procedure in detail. Letting mutation and crossover factors be set to Z = 0.3 and Y = 0.5, respectively. The procedure of mutation operation is illustrated in

Table 3. Generation of temporary vector $G_{h_1}^k$ (Z = 0.3).

Individual	x1	x2	x3	x4	x5	x6	x7	x8	x9
Xα1	2	1	3	1	2	1	3	2	3
Xβ1	2	3	1	3	2	3	1	1	2
Xα1 − Xβ1	0	−2	2	−2	0	−2	2	1	1
rand	0.20	0.37	0.06	0.18	0.26	0.68	0.86	0.50	0.15
$G_{h_1}^k$	0	0	2	−2	0	0	0	0	1

and

Table 4. Generation of temporary vector $G_{h_2}^k$ (Z = 0.3).

Individual	x1	x2	x3	x4	x5	x6	x7	x8	x9
Xα2	3	2	3	1	2	1	3	1	2
Xβ2	2	1	1	3	2	3	1	3	2
Xα2 − Xβ2	1	1	2	−2	0	−2	2	−2	0
rand	0.56	0.02	0.38	0.26	0.66	0.18	0.59	0.89	0.15
$G_{h_2}^k$	0	1	0	−2	0	−2	0	0	0

, while that of the crossover operation is illustrated in

Table 5. Generation of trial individual (Y = 0.5).

Individual	x1	x2	x3	x4	x5	x6	x7	x8	x9
$X_{best}^{k-1}$	2	3	1	2	1	3	3	1	2
$G_{h_1}^k$	0	0	2	−2	0	0	0	0	1
$G_{h_2}^k$	0	1	0	−2	0	−2	0	0	0
$\oplus$	2	4	3	−2	1	1	3	1	2
$V_h^k$	2	1	3	1	1	1	3	1	2
rand	0.56	0.28	0.32	0.48	0.66	0.18	0.59	0.89	0.15
$V_h^{’k}$		1	3	1		1			2

and Figure 3.

5.4. Hill-Climbing-Based Improvement Strategy

A hill-climbing-based improvement strategy is introduced to enhance the quality of the final solution, aiming to balance diversification and intensification. Hill-climbing is a local search algorithm, which starts with an arbitrary solution of a given problem, then attempts to seek a better solution by making an incremental change to the solution. The change procedure executes continuously until no further improvements can be found.

However, the hill-climbing consumes considerable running time to obtain the local optimal solution in practical settings. For saving computing resource and improving algorithm efficiency, the improvement strategy is presented as follows. If the local optimal solution is found within the specified iterations, the solution is recorded; otherwise, the current best solution is recorded. The dominative parent individual is denoted as $U_h^k$. Ten iterations are conducted for the improvement strategy. Each iteration generates 20 neighborhood solutions by exchanging two elements in the parent individual. The optimal one among the 20 neighborhood solutions is compared with the current optimal individual (COI). If the new optimal solution is dominated, then the COI is updated by it and the next iteration is executed. Otherwise, the improvement strategy will continue to be dominated by the original COI until it reaches the maximum number of iterations. The improvement strategy is performed with probability θ to save computing time. The pseudo-codes for the improvement strategy are shown in Procedure 4.

Procedure 4: Hill-climbing-based improvement strategy
1	Input: θ, ${ U}_h^k$
2	Output:${ U}_h^k$
3	Begin
4	q ← random(0,1);
5	If (q > θ)
6	for (i from 0 to m × n − 1)
7	better[i]←$U_{h,i}^k$; //store better individual;
18	end for
9	for (z from 1 to 10)
10	init ← the value of the objective function corresponding to better individual.
11	for (y from 1 to 20)
12	Neighboor[y]←Randomly exchange the two elements of better to produce neighborhood individual.
13	obj[y]←the value of objective function of Neighboor[y];
14	end for
15	best_nei←the best one from 20 neighborhood individuals;
14	best_obj←the objective value of best_nei;
15	if(best_obj < init)
16	for (i from 0 to m × n − 1)
16	better[i]←best_nei[i];
17	end for
18	end if
19	end for
20	for (i from 0 to m × n − 1)
21	$U_{h,i}^k$←better[i]
22	end for
23	end if
24	return $U_{h,i}^k$;
25	End

5.5. Selection

Population updating simulates the law of natural selection: survival of the fittest. Trial individual $U_h^k$ is decoded as a feasible schedule. If the objective value of $U_h^k$ dominates that of the target individual $X_{h’}^{k-1}$, then the individual in the current population will be updated; otherwise, the target individual will be retrained. Executing the mutation, crossover and selection operations for all target individuals generate a new population. The iteration procedure is repeated until the termination condition is satisfied.

5.6. Framework of the HDDE Algorithm

With the previous procedures combined, the entire framework of the HDDE algorithm is provided in Algorithm 1.

Algorithm 1: the HDDE algorithm:
1	Input: Parameter τmax, Z, Y, Λ, θ
2	Output: $X_{best}^k$
3	Begin
4	/* Initialization phase */
5	pop[Λ] [m × n]←Randomly generate the initial population;
6	Evaluate the initial population;
7	k←1;
8	$X_{best}^k$←Individual with the optimal objective value in the current population;
9	while (k ≤ τmax) do
10	for (h from 1 to Λ) do
11	/* Mutation phase */
12	$V_h^k$←the mutant individual after the mutation operation;
13	/* Crossover phase */
14	$U_h^k$←the variant individual after the crossover operation;
15	/* Improvement strategy phase */
18	Enter the improvement strategy operator to update $U_h^k$;
20	/* Selection Phase */
21	if (F($U_h^k$) < F($X_h^{k-1}$) // F(X) is the objective value corresponding to the individual X;
22	$X_h^k$ = $U_h^k$;
23	else
24	$X_h^k$ = $X_h^{k-1}$;
25	end if
26	end for
27	Update $X_{best}^k$;
28	k = k + 1;
29	end while
30	return $X_{best}^{\tau max}$;
31	End

6. Numerical Simulation Experiment

Numerous simulation experiments were executed to evaluate the effectiveness of the HDDE algorithm and SPT-DS heuristic for medium- and large-scale instances, respectively. The proposed algorithms were implemented in C++ language, and simulations were run on a Dell computer with an Intel Core i5-8400 (2.8 GHz × 6) CPU and 8.00 GB RAM. The input data were generated because no standard benchmark was available for the JSP problem with release dates. Release date r_j was randomly generated from a uniform distribution U[0, 3n]. Without loss of generality, at least one job was released at time zero. Processing time p_i,j was randomly generated from a uniform distribution U[1, 10]. For operation O_i,j, processing time p_i,j = 0 indicates that job j does not pass through machine i. The processing routes of each job were randomly generated, and the job might not pass through all machines. For each machine-job combination, 10 random trials were conducted and the average values are reported in the following tables.

6.1. Performance of SPT-DS Heuristic

This section designs numerical experiments to verify the performance of the SPT-DS heuristic algorithm for large-scale instances. The machine-job combinations m = {3, 5, 8} with n = {100, 300, 500} were tested with the previous input settings. Measure $GAP=\frac{Z^H-Z^{LB}}{Z^{LB}}$ was used for evaluating the error of algorithm, where Z^H and Z^LB are the objective values of the SPT-DS heuristic and lower bound, respectively. Mean GAP values are presented in the following table.

In

Table 6. GAPs of SPT-DA heuristic.

n/m	m = 3	m = 5	m = 8
n = 100	0.7808	1.0644	1.4948
n = 300	0.7349	1.2143	1.4221
n = 500	0.7217	1.1150	1.4003

, the GAPs are stable for the constant machine number. For the five-machine example, the GAP values float between 1.0664 and 1.2134 as the problem scale increases from 100 to 500, where the fluctuation range is about 7.5%. Furthermore, the growth trend of GAP values indicates that the SPT-DS heuristic deteriorates with the increase in m for a fixed problem scale. For the 300-job example, the GAP value increases from 0.7349 to 1.4221 as the machine scale increases from 3 to 8. This phenomenon might be attributed to the large machine scale increasing the idle time between adjacent operations in a feasible schedule, thereby weakening the performance of the heuristic.

6.2. Improvement of the HDDE Algorithm

To highlight the improvement schemes of the tri-insertion and local search, comparative experiments were executed between the standard DDE (SDDE) and the HDDE algorithms. The machine-job combinations m = {3, 5, 8} with n = {50, 100, 150} were tested under the input settings presented at the beginning of this section. The performance of a meta-heuristic mainly depends on the parameter settings. Thus, a series of orthogonal experiments was conducted to determine the parameters of the algorithm (Appendix A), such as mutation factor Z, crossover factor Y, population size Λ, and local search probability θ (

Table A2. HDDE algorithm parameters orthogonal experiment results.

No.	Z	Y	Λ	τmax	θ	MIP
1	1	1	1	1	1	63.047
2	1	2	2	2	2	56.857
3	1	3	3	3	3	62.44
4	1	4	4	4	4	61.173
5	1	5	5	5	5	56.198
6	2	1	2	3	4	68.973
7	2	2	3	4	5	63.566
8	2	3	4	5	1	62.135
9	2	4	5	1	2	51.484
10	2	5	1	2	3	63.784
11	3	1	3	5	2	76.275
12	3	2	4	1	3	48.861
13	3	3	5	2	4	47.98
14	3	4	1	3	5	57.46
15	3	5	2	4	1	56.328
16	4	1	4	2	5	65.379
17	4	2	5	3	1	60.104
18	4	3	1	4	2	57.64
19	4	4	2	5	3	55.235
20	4	5	3	1	4	44.366
21	5	1	5	4	3	58.799
22	5	2	1	5	4	64.755
23	5	3	2	1	5	40.386
24	5	4	3	2	1	42.218
25	5	5	4	3	2	48.76

). The parameters are set as Z = 0.2, Y = 0.1, Λ = 200, τ_max = 300, and θ = 0.8.

Relative difference percentage $RDP=\frac{Z^H-Z^{*}}{Z^{*}}\times 100\%$ was used for evaluation of the effectiveness of the HDDE algorithm, where $Z^H$ is the final objective value obtained by a meta-heuristic for each test, and $Z^{*}$ is the minimum value among all Z^H values.

Table 7. Improvement effect of the HDDE algorithm.

m × n	SDDE				HDDE
	ARDP	MaxRDP	MinRDP	SD	ARDP	MaxRDP	MinRDP	SD
3 × 50	26.11	55.36	16.42	14.98	4.81	48.13	0	14.43
3 × 100	14.64	20.39	9.35	3.91	0	0	0	0
3 × 150	7.38	11.75	0	3.73	0.40	4.04	0	1.21
5 × 50	13.82	23.55	6.59	4.34	0	0	0	0
5 × 100	7.81	15.51	2.36	4.03	0	0	0	0
5 × 150	5.82	12.29	0	3.44	0.06	0.55	0	0.17
8 × 50	4.78	10.8	0	3.66	0.05	0.48	0	0.14
8 × 100	7.32	13.5	3.53	2.91	0	0	0	0
8 × 150	3.95	11.38	0	3.34	0.09	0.91	0	0.27

shows the average RDP (ARDP), minimum RDP (MinRDP), maximum RDP (MaxRDP), and standard deviation (SD) for SDDE and HDDE. ARDP is a performance measure that evaluates an algorithm numerically. The ARDPs of HDDE evidently dominate those of SDDE. For example, the mean values of ARDPs obtained by HDDE and SDDE are 0.6011 and 10.1811, respectively. SD aims to reveal the stability performance of an algorithm. The SD values of HDDE and SDDE are stable in [0, 1.21] and [2.91, 4.34], respectively, except for the maximum values, indicating the robustness of the former relative to the latter. In the minimum objective values of the 90 numerical tests, about 94% (85 out of 90) of the data were obtained by HDDE and about 6% of the data (5 out of 90) were obtained by SDDE. These final experimental outcomes show that the improvement schemes considerably enhance the performance of the HDDE algorithm.

6.3. Comparison between HDDE and Other Optimization Algorithms

6.3.1. Comparison between HDDE and ACO

Ant Colony Optimization (ACO) algorithm is selected as a contrast objective to indicate the superiority of the HDDE algorithm. The machine-job combinations and input parameters are identical with those in Section 6.2. The RDP measure is used in this section. The parameters used in ACO algorithm are presented as follows. $P_{ij}{}^k$ is the probability of selecting operation j when ant k climbs to position i (i.e., the moment when the current operation is selected).

$$P_{ij}^k=\left\{\begin{array}{ll}\frac{{[{\tau }_{ij}]}^{\alpha }\ast {[{\eta }_{ij}]}^{\beta }}{{\displaystyle \sum _{s \notin {\mathsf{\Omega }}_k}{[{\tau }_{is}]}^{\alpha }\ast {[{\eta }_{is}]}^{\beta }}}& , j\notin {\mathsf{\Omega }}_k\\ 0& , j\in {\mathsf{\Omega }}_k\end{array}\right\}$$

(14)

where Ω_k is the tabu list for ant k, which stores operations that have been processed. τ_i,j is the pheromone concentration of operation j. ŋ_i,j is the current heuristic factor of operation j at present.

$${\eta }_{ij}=\frac{1}{d_{ij}}$$

(15)

where d_ij is the processing time of operation j. Parameters α and β indicate the relative importance of pheromones and heuristics.

$$\mathsf{\Delta }{\tau }_{ij}{}^k=\left\{\begin{array}{ll}\frac{Q}{C_k}& , \mathrm{if} \mathrm{operation} j \mathrm{is} \mathrm{machined} \mathrm{in} \mathrm{position} i\\ 0& , \mathrm{others}\end{array}\right\}$$

(16)

where Q is a constant, and C_k is the objective values of the operations in which ant k has been processed.

$$\mathsf{\Delta }{\tau }_{ij}={\displaystyle \sum _{k=1}^{\Lambda }\mathsf{\Delta }{\tau }_{ij}{}^k}$$

(17)

∆τ_ij is the total increment of the pheromone of operation j.

$${\tau }_{ij}=\rho \ast {\tau }_{ij}+\mathsf{\Delta }{\tau }_{ij}$$

(18)

τ_ij is the current pheromone concentration of operation j, ∆τ_ij is the pheromone concentration of operation j in the previous iteration stage, and ρ is the evaporation coefficient.

After previous preparation, a basic framework of the ACO algorithm is presented as follows.

Step 1. Set parameters for the algorithm, such as the ant colony size Λ, the maximum number of iterations t_max, constant Q, evaporation coefficient ρ, and parameters α and β. The initial pheromone concentration of each operation is set to a certain constant. Set the current number of iterations t = 0.

Step 2. Generate the initial colony. With Equation (14), each ant uses roulette method to continuously select the operations that need to be processed. If all operations are included in the sequence of each ant, the initial ant colony is formed. Use Equations (16)–(18) to update the pheromone of each operation.

Step 3. Set h = 1, and start iteration.

Step 4. The current ant uses the roulette method to select an operation with Equation (14). Once an operation is selected, the pheromone increment of the operation is obtained by Equation (16).

Step 5. If h < Λ, set h = h + 1, and then go to Step 4; otherwise go to Step 6.

Step 6. If t < t_max, set t = t + 1. The pheromone increment of each operation is obtained by Equation (16). Update the pheromone of each operation in current iteration with Equation (17), and then go to step 3; otherwise go to step 7.

Step 7. Terminate procedure if the termination condition is satisfied. The optimal individual of the current ant colony is output as the final solution.

Similarly, the parameters of ant colony algorithm are set by orthogonal experiment, as shown in Appendix B. The parameters are set as α = 1.0, β = 0.5, ρ = 0.9, Q = 0.5, Λ = 200 and t_max = 300.

Table 8. Comparison between HDDE and ACO.

m × n	ACO				HDDE
	ARDP	MaxRDP	MinRDP	SD	ARDP	MaxRDP	MinRDP	SD
3 × 50	27.54	50.31	14.36	12.88	0	0	0	0
3 × 100	9.07	22.34	0	7.48	0.81	5.70	0	1.78
3 × 150	2.67	10.76	0	3.75	1.89	12.43	0	3.72
5 × 50	13.62	26.73	0	9.69	0.43	4.32	0	1.29
5 × 100	41.12	55.66	33.50	6.00	0	0	0	0
5 × 150	37.16	43.71	32.24	3.35	0	0	0	0
8 × 50	5.76	16.99	0	6.53	0.28	2.84	0	0.85
8 × 100	34.16	39.27	28.12	3.51	0	0	0	0
8 × 150	30.88	35.04	25.83	3.12	0	0	0	0

shows the average RDP (ARDP), minimum RDP (MinRDP), maximum RDP (MaxRDP), and standard deviation (SD) for ACO and HDDE. The ARDPs of HDDE evidently dominate those of ACO. For example, the mean values of ARDPs obtained by HDDE and ACO are 0.3789 and 22.4422, respectively. The SD values of HDDE and ACO are stable in [0, 1.78] and in [3.12, 9.69], respectively, except for the maximum values, indicating the robustness of the former relative to the latter. In the minimum objective values of the 90 numerical tests, about 92% (83 out of 90) of the data were obtained by HDDE and about 8% of the data (7 out of 90) were obtained by ACO. These numerical results reveal that the HDDE algorithm completely dominates the ACO algorithm.

6.3.2. Comparison between HDDE and PSO

To highlight the dominance of the HDDE algorithm, a series of comparison experiments are conducted between the HDDE and PSO algorithms. The concrete procedure of the PSO algorithm is referred to [30,31]. The parameters of the HDDE algorithm are identical with those in Section 6.3.1. The parameters of the PSO algorithm are set by orthogonal experiment (shown in Appendix C), i.e., population size Λ = 200, maximum number of iterations τ_max = 300, weight w = 5, maximum speed V_max = 4, maximum position S_max = 4, cognitive coefficient c₁ = 3, and social coefficient c₂ = 3.

The data in

Table 9. Comparison between HDDE and PSO.

m × n	PSO				HDDE
	ARDP	MaxRDP	MinRDP	SD	ARDP	MaxRDP	MinRDP	SD
3 × 50	45.96	79.70	19.87	19.89	0	0	0	0
3 × 100	44.23	65.99	23.06	14.33	0	0	0	0
3 × 150	30.60	48.25	13.48	9.878	0	0	0	0
5 × 50	62.99	83.20	44.53	12.414	0	0	0	0
5 × 100	48.66	55.63	40.24	5.29	0	0	0	0
5 × 150	42.89	48.38	37.98	3.353	0	0	0	0
8 × 50	51.02	63.66	41.41	7.13	0	0	0	0
8 × 100	41.63	53.69	33.94	5.52	0	0	0	0
8 × 150	37.70	43.38	32.99	3.34	0	0	0	0

are the values of ARDP, MinRDP, MaxRDP, and SD for PSO and HDDE. The results of HDDE are all 0 for the 90 trials. This phenomenon indicates that the HDDE algorithm completely dominates the PSO algorithm.

6.3.3. Comparison between HDDE and GA

This section conducted comparison experiments on the HDDE and GA algorithms. The experimental parameters of the GA algorithm are set as follows: mutation probability Z₁ = 0.5, crossover probability Y₁ = 0.5, population size Λ = 200, and maximum number of iterations τ_max = 300. The detailed parameter setting process is presented in Appendix D.

The data of ARDP, MinRDP, MaxRDP, and SD for GA and HDDE are shown in

Table 10. Comparison between HDDE and GA.

m × n	GA				HDDE
	ARDP	MaxRDP	MinRDP	SD	ARDP	MaxRDP	MinRDP	SD
3 × 50	29.09	62.36	9.19	16.67	0	0	0	0
3 × 100	20.07	46.35	0.58	12.69	0	0	0	0
3 × 150	10.34	30.00	0	9.04	1.42	8.18	0	3.04
5 × 50	36.05	59.27	18.34	12.91	0	0	0	0
5 × 100	18.02	33.99	0.99	10.70	0	0	0	0
5 × 150	14.92	25.37	4.26	6.73	0	0	0	0
8 × 50	23.23	32.33	16.81	5.70	0	0	0	0
8 × 100	30.18	51.12	13.14	11.54	0	0	0	0
8 × 150	32.02	46	16.94	9.24	0	0	0	0

. It is obvious that HDDE’s ARDPs is superior to GA’s ARDPs. For example, the mean values of ARDPs obtained by HDDE and GA are 0.158 and 23.769, respectively. The SD values of GA are stable in [5.70, 12.91], except for the maximum values, and the SD value of HDDE is only equal to 3.04 at one scale (3 × 150), but equal to zero at all other scales, indicating the robustness of the latter relative to the former. In the minimum objective values of the 90 numerical tests, about 97.8% (88 out of 90) of the data were obtained by HDDE and about 2.2% of the data (2 out of 90) were obtained by GA. These numerical results reveal that the HDDE algorithm completely dominates the GA algorithm.

6.4. Comparison under JSS Problem Benchmarks

Currently, no standard benchmark is provided for the JSS problem with release dates. Therefore, the basic benchmarks proposed by Taillard, E. [32] is combined with generated data of release dates from a uniform distribution [0, 3n] to verify the performance of the proposed algorithm.

To control the meta-heuristics running in an appropriate time, the data of processing times with machine-job combinations m × n = 15 × 50, 20 × 50, and 20 × 100 were selected from the benchmarks. The data in

Table 11. Comparison under JSS problem benchmarks.

m × n	HDDE	ACO	PSO	GA	gap1	gap2	gap3
15 × 50	5.34 × 108	7.88 × 108	9.18 × 108	1.28 × 109	47.68	71.92	139.70
	5.44 × 108	7.87 × 108	9.35 × 108	1.27 × 109	44.52	71.84	132.34
	5.12 × 108	7.54 × 108	8.34 × 108	1.45 × 109	47.17	62.95	182.17
	5.15 × 108	7.99 × 108	8.90 × 108	1.15 × 109	55.23	73.03	123.65
	5.15 × 108	7.92 × 108	8.84 × 108	1.39 × 109	53.94	71.84	170.79
	5.54 × 108	8.36 × 108	9.35 × 108	1.17 × 109	50.98	68.90	111.56
	5.32 × 108	8.22 × 108	8.91 × 108	1.51 × 109	54.50	67.38	183.35
	5.71 × 108	8.40 × 108	9.94 × 108	1.38 × 109	47.06	74.12	142.28
	5.16 × 108	7.43 × 108	8.86 × 108	1.28 × 109	44.02	71.71	147.24
	5.50 × 108	8.13 × 108	8.67 × 108	1.48 × 109	47.87	57.99	168.68
20 × 50	7.56 × 108	1.05 × 109	1.18 × 109	2.01 × 109	39.26	55.67	166.45
	7.81 × 108	1.16 × 109	1.24 × 109	2.31 × 109	47.97	59.22	195.26
	7.08 × 108	1.02 × 109	1.13 × 109	1.79 × 109	43.55	59.82	152.24
	6.49 × 108	9.59 × 109	1.10 × 109	1.77 × 109	47.66	69.11	172.34
	7.01 × 108	1.03 × 109	1.25 × 109	2.04 × 109	46.63	78.74	190.4
	7.16 × 108	1.08 × 109	1.23 × 109	2.07 × 109	50.28	71.38	189.73
	6.92 × 108	1.04 × 109	1.20 × 109	2.20 × 109	50.31	72.82	217.56
	6.91 × 108	9.99 × 108	1.17 × 109	1.82 × 109	44.70	69.10	162.85
	7.21 × 108	1.11 × 109	1.19 × 109	2.29 × 109	53.57	65.19	218.07
	7.57 × 108	1.08 × 109	1.20 × 109	2.08 × 109	42.33	58.00	174.95
20 × 100	4.68 × 109	6.86 × 109	7.54 × 109	1.20 × 1010	46.60	61.20	156.75
	4.31 × 109	6.14 × 109	6.89 × 109	1.55 × 1010	42.60	59.89	260.32
	4.67 × 109	6.62 × 109	7.35 × 109	1.32 × 1010	41.79	57.41	182.91
	4.49 × 109	6.44 × 109	6.99 × 109	1.57 × 1010	43.37	55.8	250.04
	4.58 × 109	6.56 × 109	7.19 × 109	1.53 × 1010	43.01	56.74	233.26
	4.51 × 109	6.41 × 109	6.82 × 109	1.60 × 1010	42.13	51.11	254.59
	4.71 × 109	6.20 × 109	6.94 × 109	1.66 × 1010	31.57	47.45	252.63
	4.44 × 109	6.40 × 109	6.86 × 109	1.64 × 1010	43.91	54.35	268.87
	4.62 × 109	6.16 × 109	6.88 × 109	1.55 × 1010	33.14	48.78	235.07
	4.42 × 109	6.23 × 109	6.97 × 109	1.40 × 1010	41.19	57.91	217.75

were the final objective values of the HDDE, ACO, PSO, and GA algorithms, where gap₁ = (Z^ACO − Z^HDDE)/Z^HDDE × 100%, gap₂ = (Z^PSO − Z^HDDE)/Z^HDDE × 100%, gap₃ = (Z^GA − Z^HDDE)/Z^HDDE × 100%, Z^HDDE, Z^ACO, Z^PSO, and Z^GA are the final objective values obtained by HDDE, ACO, PSO, and GA, respectively. It is obvious that the HDDE algorithm is superior to other population-based meta-heuristics.

However, the tested meta-heuristics consumed different CPU times. For an m × n = 20 × 100 instance, the CPU time expended by the HDDE, ACO, PSO, and GA algorithms are 17,890, 22,055, 837.853, and 238.448 s, respectively. The results reveals that better performance of an algorithm will cost more CPU time. As a trade-off between solution quality and running time, the HDDE algorithm dominates the other meta-heuristics.

7. Conclusions

This study investigates the JSS problem to minimize the total quadratic completion time where each job is available at its release date. No polynomial algorithm can solve the problem because of its NP-hardness. For large-sized instances, the SPT-DS heuristic algorithm is proposed to achieve approximate solutions in a short computing time. For medium-sized instances, the HDDE algorithm is provided to achieve high-quality solutions, where well-designed tri-insertion crossover and lower search schemes significantly enhance the performance of the meta-heuristic. A series of random experiments demonstrates the effectiveness of the proposed algorithms.

Future researches mainly focus on two aspects. On the one hand, the acceleration scheme will be proposed to save running time for the HDDE algorithm. On the other hand, the model will be generalized to a multi-objective version that is more popular in a production scheduling environment. A non-dominated sorting-based meta-heuristic will be presented to obtain Pareto optimal solutions. A high-efficiency improvement scheme, such as variable neighborhood search, will be combined with the meta-heuristic for JSS problems.