Computers & Industrial Engineering 117 (2018) 152–163

Contents lists available at ScienceDirect

Computers & Industrial Engineering

journal homepage: www.elsevier.com/locate/caie

Bicriterion total flowtime and maximum tardiness minimization for an order T

scheduling problem
Chin-Chia Wua, Shang-Chia Liub, Tzu-Yun Lina, Tzu-Hsuan Yanga, I-Hong Chunga,
⁎
Win-Chin Lina,
a
Department of Statistics, Feng Chia University, Taichung 40724, Taiwan
b
Business Administration Department, Fujen Catholic University, Hsinpei City, Taiwan

A R T I C L E I N F O A B S T R A C T

Keywords: An order scheduling problem arises in numerous production scheduling environments. Makespan, mean flow
Order scheduling time, and mean tardiness are the most commonly discussed and studied measurable criteria in the research
Iterated greedy algorithm community. Although the order scheduling model with a single objective has been widely studied, it is at odds
Particle swarm optimization algorithm with real-life scheduling practices. In practice, a typical manager must optimize multiple objectives. A search of
Total completion time
the literature revealed that no articles had addressed the issue of optimizing an order scheduling problem with
Maximum tardiness
multiple objectives. Therefore, an order scheduling model to minimize the linear sum of the total flowtime and
the maximum tardiness is introduced in this study. Specifically, several dominance relations and a lower bound
are derived to expedite the search for the optimal solution. Three modified heuristics are proposed for finding
near-optimal solutions. A hybrid iterated greedy algorithm and a particle swarm colony algorithm are proposed
to solve this problem. Finally, a computational experiment is conducted to evaluate the performances of all
proposed algorithms.

1. Introduction
In many manufacturing environments, the producer meets customer
deadlines and develops efficient production items at the same time
because the demand for production items increases sharply. In light of
encouraging the demand on asking for on-time delivery of high quality
product, producers go through technologies based on dispatching and
scheduling to reduce the production time.
Recently, customer order scheduling has become a popular field of
research. The applications of customer order scheduling can be found in
manufacturing environments: a converting operation in a process in-
dustry by Leung, Li, and Pinedo (2005, 2006b) and a car repair shop by
Yang (2005). In these applications, a planning developer independently
creates one of a set of separate productive parts, each of which is
considered to be finished when the full set of production parts has been
completed. Ahmadi, Bagchi, and Roemer (2005) presented another
example of customer order scheduling in the manufacturing of semi-
finished lenses.
Numerous researchers have studied order scheduling. Regarding the
total completion time criterion, Leung et al. (2005), Leung, Li, and
Pinedo (2006a) and Wagneur and Sriskandarajah (1993) have dis-
cussed the complexity of problems on two or more machines; Ahmadi
et al. (2005), Wang and Cheng (2003), and Sung and Yoon (1998) have
developed approximate algorithms to solve such problems. For the
criterion of total weighted order completion time, Sung and Yoon
(1998) and Ahmadi and Bagchi (1993) have shown that order sche-
duling is NP-hard or strongly NP-hard for the two-machine case.
Ahmadi et al. (2005), Leung, Li, and Pinedo (2007a, 2008), Leung, Li,
Pinedo, and Zhang (2007b), Leung, Lee, Ng, and Young (2008), Wang
and Cheng (2003), and Chen and Hall (2001) have separately proposed
heuristics to find near-optimal solutions. As to the order scheduling
models involving due dates, readers may refer to Blocher, Chhajed, and
Leung (1998), Erel and Ghosh (2007), Hsu and Liu (2009), Lee (2013),
Leung et al. (2006b), Yang (2005), Yang and Posner (2005), Xu et al.
(2016), Lin et al. (2017), and Wu, Liu, Zhao, Wang, and Lin (2017).
The aforementioned works have focused on minimizing a single
objective. However, in competitive markets, producers must focus on
minimizing the production periods and the manufacturing costs.
Production managers must determine how to minimize the tradeoff
costs between short production periods and on-time delivery of cus-
tomer orders. Motivated by the lack of research on the issue of opti-
mizing an order scheduling problem with multiple objectives, this study
addresses an order scheduling problem to minimize a linear sum of the
total flow time and the maximum tardiness.

⁎
Corresponding author.
E-mail address: linwc@fcu.edu.tw (W.-C. Lin).

https://doi.org/10.1016/j.cie.2018.01.011
Received 27 March 2017; Received in revised form 11 January 2018; Accepted 15 January 2018
Available online 31 January 2018
0360-8352/ © 2018 Elsevier Ltd. All rights reserved.
C.-C. Wu et al. Computers & Industrial Engineering 117 (2018) 152–163

The main contribution of this paper is providing an objective that is v1 (Ci (σ1) + Cj (σ1)) + (1−v1)max{Ti (σ1),Tj (σ1)} ⩽ v1 (Cj (σ2) + Ci (σ2))
a weighted average of two performance measures and developing a
+ (1−v1)max{Tj (σ2),Ti (σ2)}
lower bound for the branch-and-bound procedure. This paper also uses
three heuristics and two metaheuristics (iterated greedy algorithm and and Cj (σ1) < Ci (σ2) , for all v1 such that 0 < v1 < 1.
particle swarm optimization algorithm) reported in the literature to
Property 1. Consider two adjacent orders Oi and Oj in which
generate an upper bound for the branch-and-bound procedure. The
sk + tik + t jk ⩽ djmax1 ⩽ k ⩽ m {sk + tik } < max1 ⩽ k ⩽ m {sk + t jk } for all k = 1,
remainder of this paper is organized as follows. Section 2 introduces the
2, …, m, then σ1 dominates σ2 .
notation and problem definition. Section 3 presents some propositions
and a lower bound for the branch-and-bound algorithm. Section 4 Proof. The completion times of orders i and j in schedules σ1 and σ2 are
provides the iterative greedy (IG) algorithm and several heuristics. respectively,
Section 5 reports the experimental simulations of all the proposed al-
Ci (σ1) = max {sk + tik } Cj (σ1) = max {sk + tik + t jk }
gorithms, and Section 6 provides conclusions and suggestions. 1⩽k⩽m 1⩽k⩽m

Cj (σ2) = max {sk + t jk }

2. Notation definition and problem description 1⩽k⩽m

and
The notations used throughout the paper are defined as follows.
Ci (σ2) = max {sk + t jk + tik } = Cj (σ1).
1⩽k⩽m
n: denotes the number of orders;
m: denotes the number of machine; It follows from max1 ⩽ k ⩽ m {sk + tik } < max1 ⩽ k ⩽ m {sk + t jk } for all k = 1,
Mk : denotes the machine codes k, k = 1, 2,…, m; 2, …, m, that Ci (σ1) ⩽ Cj (σ2) , and thus Ci (σ1) + Cj (σ1) ⩽ Cj (σ2) + Ci (σ2) .
Oi : denotes the order codes i, i = 1, 2, …, n. Because Ci (σ1) ⩽ Ci (σ2) ,
σ , σ1, σ2 : denote the schedules of the given n orders; Ti (σ2) = max{Ci (σ2)−di,0} ⩾ Ti (σ1) = max{Ci (σ1)−di,0}.
π1, π2 : denote two partial schedules of the given n orders;
tik : denotes the processing time of order Oi to be operated on ma- In addition, by sk + tik + t jk ⩽ dj for all k = 1, 2, …, m, we have
chine k, k = 1, 2, …, m; dj ⩾ Cj (σ1) . Thus, Ti (σ2) = max{Ci (σ2)−di,0} ⩾ Tj (σ1) = max{Cj
(σ1)−dj,0} = 0 . Consequently max{Tj (σ2),Ti (σ2)} ⩾ Ti (σ2) ⩾ max
sk : denotes the starting time of an order on machine k, k = 1, 2, …,
{Ti (σ1),Tj (σ1)} , as required. □
m;
: denotes the due date of order Oi i = 1, 2, …, n; Property 2. Consider two adjacent orders Oi and Oj in which
Ci (σ1) , Cj (σ1) : denote the completion times of orders Oi and Oj in σ1; max1 ⩽ k ⩽ m {sk + tik } < max1 ⩽ k ⩽ m {sk + t jk } and di ⩽ dj , then σ1 dominates
Cj (σ2),Ci (σ2) : denote the completion times of orders Oj and Oi in σ2 ; σ2 .
[r]: denotes the rth position of orders in a sequence;
Proof. By the proof of Property 1, it suffices to show that Ti (σ2) ⩾ Tj (σ1) .
Ti (σ1),Tj (σ1) : denote the tardiness values of orders Oi and Oj in σ1;
Indeed, with Cj (σ1) = Ci (σ2) and di ⩽ dj , we have Ci (σ2)−di ⩾ Cj (σ1)−dj ,
Tj (σ2),Ti (σ2) : denotes the tardiness values of orders Oj and Oi in σ2 ;
implying that Ti (σ2) = max{Ci (σ2)−di,0} ⩾ Tj (σ1) = max{Cj (σ1)−dj,0} , as
where
required. □
Ti (σ ) = max{0,Ci (σ )−di}
Property 3. Consider two adjacent orders Oi and Oj in which
. sk + tik + t jk ⩽ min{di,dj} for all k = 1, 2, …, m, and
n
∑i = 1 Ci (σ ) : denotes the total completion time of n orders in σ . max1 ⩽ k ⩽ m {sk + tik } < max1 ⩽ k ⩽ m {sk + t jk } , then σ1 dominates σ2 .
Tmax (σ ) : denotes the maximum tardiness of n orders in σ , or
Proof. The condition sk + tik + t jk ⩽ min{di,dj} implies that
Tmax (σ ) = max1 ⩽ i ⩽ n {Ti (σ )} . Ti (σ2) = Tj (σ1) = 0 . Thus, by the proof of Properties 1 and 2, the
n
v1 ∑i = 1 Ci (σ ) + (1−v1) Tmax (σ ) : denotes the objective function of this result holds. □
study, where 0 < v1 < 1.
Property 4. Consider two adjacent orders Oi and Oj in which
The problem under study is as follows. A set of n orders (placed by n max1 ⩽ k ⩽ m {sk + tik }−di ⩾ 0 , max1 ⩽ k ⩽ m {sk + t jk } ⩾ dj , max1 ⩽ k ⩽ m
different clients) must be processed on m machines, which are arranged {sk + tik }−di ⩾ max1 ⩽ k ⩽ m {sk + tik + t jk }−dj ,
in parallel. Each item can be executed on one dedicated machine. max1 ⩽ k ⩽ m {sk + tik } ⩽ (1−v1)max1 ⩽ k ⩽ m {sk + tik + t jk } , then σ1 dominates
Preemption, machine breakdown, and interruption are not allowed. + v1max1 ⩽ k ⩽ m {sk + t jk }
The ready times for the n orders are not included in this problem. The σ2 .
objective function of this problem is to determine a schedule that op-
Proof. By the proof of Property 1, max1 ⩽ k ⩽ m {sk + tik } ⩾ di and
timizes a linear sum of the total flowtime (or total completion time) and
max1 ⩽ k ⩽ m {sk + t jk } ⩾ dj give that Ti (σ1) = Ci (σ1)−di,Tj (σ1) =
maximum tardiness of n orders. Ahmadi et al. (2005) confirmed that the
Cj (σ1)−dj,Tj (σ2) = Cj (σ2)−dj ,and Ti (σ2) = Ci (σ2)−di . Moreover,
problem of minimizing the total flowtime is NP-hard, and thus this
max1 ⩽ k ⩽ m {sk + tik }−di ⩾ max1 ⩽ k ⩽ m {sk + tik + t jk }−dj gives Ci (σ1)−
problem is NP-hard as well. Therefore, this paper introduces several
di ⩾ Cj (σ1)−dj and Ci (σ2)−di ⩾ Cj (σ2)−dj , implying that max
dominance relations and a lower bound to be used in a branch-and- {Ti (σ1),Tj (σ1)} = Ti (σ1) and max {Ti (σ2),Tj (σ2)} = Ti (σ2) . Thus, by
bound method for the optimal solution. Following that, some heuristics max1 ⩽ k ⩽ m
are proposed, and an iterated greedy (IG) algorithm and a particle {sk + tik } ⩽ (1−v1)max1 ⩽ k ⩽ m {sk + tik + t jk } + v1max1 ⩽ k ⩽ m {sk + t jk } , we
swarm optimization algorithm are developed to search for approximate have
solutions.
v1 (Cj (σ2) + Ci (σ2)) + (1−v1)max{Tj (σ2),Ti (σ2)}−v1 (Ci (σ1) + Cj (σ1))
3. Properties and a lower bound −(1−v1)max{Ti (σ1),Tj (σ1)} = v1 Cj (σ2) + (1−v1)(Ci (σ2)−di )−v1 Ci (σ1)
−(1−v1)(Ci (σ1)−di ) = (1−v1) Ci (σ2)
This section derives some properties and a lower bound to speed up
the branch-and-bound search for an approximate solution. Let + v1 Cj (σ2)−Ci (σ1) ⩾ 0
σ1 = (π1,Oi,Oj,π2) and σ2 = (π1,Oj,Oi,π2) be two order schedules in which π1
as required. □
and π2 , respectively, are partial order sequences. To show that σ1
dominates σ2 , it suffices to show the following: Property 5. Consider two adjacent orders Oi and Oj in which

153
C.-C. Wu et al. Computers & Industrial Engineering 117 (2018) 152–163

di ⩽ max1 ⩽ k ⩽ m {sk + tik + t jk } , max1 ⩽ k ⩽ m {sk + t jk } ⩾ dj , max1 ⩽ k ⩽ m l n−l

⎛ ∑ (n−l−i + 1) t(l + i)• ⎞
{sk + t jk }−di ⩾ max1 ⩽ k ⩽ m {sk + tik + t jk }−dj , LB = v1
⎜
∑ C[i] (AS ) + (n−l) C[l] + i =1 ⎟
m
max1 ⩽ k ⩽ m {sk + t jk } ⩾ (1−v1)max1 ⩽ k ⩽ m {sk + tik + t jk } , then σ1 dominates ⎝ i=1 ⎠
+ (1−v1)max{Tmax (AS ),Tmax (US )} (3)
+ v1max1 ⩽ k ⩽ m {sk + tik }
σ2 . m
where tl + i • = ∑k = 1 t[l + i] k for i = 1, 2, …, n − l, t(l + 1)• ⩽ t(l + 2)• ⩽ …⩽t(n)•
Proof. The proof is analogous to that of Property 4. □ denotes the increasing order of {tl + i•}

Property 6. Consider two adjacent orders Oi and Oj in which 4. Some proposed heuristics and metaheuristics
max1 ⩽ k ⩽ m {sk + tik } ⩽ di ⩽ max1 ⩽ k ⩽ m {sk + tik + t jk } ,
max1 ⩽ k ⩽ m {sk + t jk } ⩾ dj , The problem under study is to find schedules that are efficient with
max1 ⩽ k ⩽ m {sk + tik + t jk }−di ⩾ max1 ⩽ k ⩽ m {sk + t jk }−dj ,
respective to mean flow time or total completion time and the max-
max1 ⩽ k ⩽ m {sk + t jk } > max1 ⩽ k ⩽ m {sk + tik }−(1−v1)(di−dj )/ v1, then σ1
imum tardiness. Setting on a single-machine environment, Smith’s al-
dominates σ2 .
gorithm (1956) gave a way of finding a schedule to minimize mean flow
Proof. The proof is analogous to that of Property 4. □ time subject to the condition that Tmax = 0. The rationale underlying
Smith’s algorithm is that it is only willing to consider reducing mean
Let AS denote a subsequence with the first l determined orders and
flow time once we have ensured that Tmax = 0. In other words, penalty
let US denote the unscheduled part with the (n − l) unscheduled orders.
costs have overriding importance. Yet, if we are prepared to allow Tmax
Suppose that code l denotes the last order in AS and Cl denotes its
to rise, we might be able to reduce mean flow time more than suffi-
completion time. One more property can be derived as follows.
ciently to compensate for the penalty costs. Thus, Van Wassenhove and
Property 7. If there exists an order i in US such that di < min{dl,Cl} and Gelders (1980) developed an algorithm to minimize mean flow time
tik ⩽ tlk for all k = 1, 2, …, m, then node (AS, ∼) in the branch trees can subject to no job being finished more than a positive number after its
be eliminated. due date.
Following the same ideas of Smith (1956) and Van Wassenhove and
Furthermore, a lower bound that cuts the partial nodes can also ⌣ ⌣ m
Gelders (1980), taking ti = max1 ⩽ k ⩽ m {tik } , ti = ∑k = 1 tik / m , and
improve the functionality of a branch-and-bound algorithm that seeks ⌣
an optimal solution. In what follows, a simple lower bound is derived ti= min1 ⩽ k ⩽ m {tik } separately as the processing time, three heuristics are
for this problem. Let Tmax (AS ) denote the maximum tardiness among l then proposed and denoted as MaxSPT.VW, MeanSPT.VW, and
orders in AS, Tmax (US ) the maximum tardiness, and d max the longest due MinSPT.VW. The details are specified as follows.
date among (n − l) orders in US. According to the definition of order MaxSPT.VW heuristic:
completion time in a schedule σ = (AS,US ) , the following can be ob- ⌣
tained Step 1: Let ti = max1 ⩽ k ⩽ m {tik } be the processing time and input as its
corresponding due date for Oi , for 1 ⩽ i ⩽ n and i∗ = 1
m n ⌣ ∼ n ⌣
∑k = 1 (s[l + 1] k + t[l + 1] k ) Step 2: Set Δ = ∑i = 1 ti , k = n , di = di + Δ , τ = ∑i = 1 ti , and
C[l + 1] (σ ) = max {s[l + 1] k + t[l + 1] k } >
1⩽k⩽m m U = {O1,O2,.,On} .
∼ ⌣
m
∑k = 1 t[l + 1] k Step 3: Find Oi (k ) in U such that di (k ) ⩾ τ and ti (k ) ⩾ tl for all Ol in U
= C[l] + such that dl ⩾ τ .
m ⌣
Step 4: k = k−1, τ = τ − ti (k ) , and delete Oi (k ) from U.
Step 5: If k ⩾ 1, then go to Step 3. Otherwise, output a complete
C[l + 2] (σ ) = max {s[l + 1] k + t[l + 1] k order schedule, called σi ∗, and its objective function
1⩽k⩽m n n
m c ( ∑i = 1 Ci (σi ∗),Tmax (σi ∗)) = v1 ∑i = 1 Ci (σi ∗) + (1−v1) Tmax (σi ∗) .
∑k = 1 (s[l + 1] k + t[l + 1] k + t[l + 2] k )
+ t[l + 2] k } > Step 6: Let Tmax (σi ∗) = Δ0 and set Δ = Δ0−1.
m Step 7: If Δ ⩾ 0, then let i∗ = i∗ + 1 and go to Step 2. Otherwise, go
m
m
∑k = 1 t[l + 1] k + ∑ t[l + 2] k to Step 8.
k=1 Step 8: Output schedule σi ∗ with the smallest value
= C[l] + n
m v1 ∑i = 1 Ci (σi ∗) + (1−v1) Tmax (σi ∗) among σ1, σ2 , …, and σi ∗.

…. MeanSPT.VW heuristic:
In a similar way, we have
⌣ m
Step 1: Let ti = ∑k = 1 tik / m as the processing time for Oi , for
q m
∑i = 1 ∑k = 1 t[l + i] k 1⩽i⩽n.
C[l + q] (σ ) > C[l] + , q = 1,2,…,n−l.
m (1) Step 2: Repeat Steps 2 to 8 of the MaxSPT.VW heuristic.

∑m s[l + 1] k
where C[l] = k = 1m . MinSPT.VW heuristic:
These equations can be summarized as follows ⌣
Step 1: Let ti = min1 ⩽ k ⩽ m {tik } as the processing time for Oi , for
n−l m
n−l ∑q = 1 (n−l−q + 1) ∑k = 1 t[l + q] k 1⩽i⩽n.
∑ C[l + i] (σ ) > (n−l) C[l] +
m Step 2: Repeat Steps 2 to 8 of the MaxSPT.VW heuristic.
i=1 (2)
Nawaz, Enscore, and Ham (1983) is well known for proposing the
The second term on the right-hand side of (2) can be minimized if
m
the sequences {n−l−q + 1} and { ∑k = 1 t[l + i] k } are scheduled in the op- best heuristic (referred as NEH) for minimizing the makespan in per-
posite way, as has been proven by Hardy, Littlewood, and Polya (1967). mutation flow shops. The main steps of the NEH method are as follows.
⌢ ∑q ∑m t[l + i] k
Furthermore, C[l + q] (σ ) = i = 1 km= 1 and the maximum tardiness can
⌢ Step 1: Arrange the jobs by decreasing sums of their total processing
be derived as Tmax (US ) = max1 ⩽ i ⩽ n − v {0, C[l + i] (σ )−d max } . Therefore, a times.
lower bound can be obtained as follows: Step 2: Consider the first two jobs and choose their order with the

154
C.-C. Wu et al. Computers & Industrial Engineering 117 (2018) 152–163

shorter makespan as the best current subsequence. IG algorithm:

Step 3: Choose the job with the smallest value of their total pro-
cessing times in job set each time, move it to insert between two jobs
in the best current seed including the first position and the last
position, and find the one with the shortest makespan among the
current several subsequences.
Step 4: Repeat this procedure until all jobs are determined.
Meanwhile, in view of the successful applications of an IG algorithm
by Msakni, Khallouli, Al-Salem, and Ladhari (2016), Ribas, Companys,
and Tort-Martorell (2011), and Ruiz and Stützle (2008), this algorithm
seems suitable to solve the problem under study. The basic idea of the
IG algorithm is grounded in a series of cycles. An initial solution is
randomly generated and the destruction and construction cycles are
alternated to improve the initial solution. The process finishes when a
given criterion is satisfied. For the destruction procedure, a sequence σ
is divided into two exclusive subsequences. One is subsequence σn − d
with n − d orders; the other is subsequence σd with d orders. The
schedules in σd and σn − d are subsets of the schedule of sequence σ . For
the construction procedure, each order in subsequence σd is moved and
reinserted into the subsequence σn − d through application of the NEH
method of Nawaz et al. (1983). Following the ideas of Kirkpatrick,
Gellat, and Vecchi (1983) and Ruiz and Stützle (2008), this algorithm
utilizes an acceptance criterion to determine whether a new solution is
updated. The temperature T used in the IG algorithm is given as follows:
n
⎧ ⌢ ⎫ Update σ by σ ′;
T = θ × v1 ∑ (n−i + 1) t(v + i)•/ m + (1−v1) max {0, C[i] (σ )−d max } /(n
⎨ i=1 1⩽i⩽n ⎬ If (the objective function of σ ′ is less than that of σ ∗) then
⎩ ⎭
+ m + 100),
where θ is a controllable variable with 0 < θ < 1.
IG algorithm:
Input a randomly initial sequence σ .
Improve sequence σ by a local search, and let the final sequence be
σ ∗.
Do while {number of the iteration < M}
Perform destruction by partitioning sequence σ into two parts σd
and σn − d .
Perform construction by moving each order in σd to insert in σn − d
using the NEH method, and output the final optimal sequence σ ′.
Improve σ ′ by a local search and let the final sequence σ ∗∗.
Acceptance criterion:
If the objective function of σ ∗∗ is less than that of σ , then
Update σ by σ ∗∗ and its corresponding objective function;
If the objective function of σ is less than that of σ ∗, then
Update σ ∗ by σ and its corresponding objective function;
Else if {exp [objective function (σ )-objective function (σ ∗∗)]/T}⩾ r
then
Update σ by σ ∗∗;
⧹∗ [r is a number that is randomly chosen from U(0,1)].∗⧹
End if
End while.
To optimize the quality of the solution, a local search method is com-
monly embedded when performing the IG algorithm. Consider ex-
tracting order O[r] from its position in sequence σ and reinserting it
forward just after job O[r+k] to form a new sequence σ ′. This yields the
sequence σ ′ = (O[1], …, O[r−1],O[r+1], …, O[r+k],O[r], O[r+k+1], …,
O[n]). If σ ′ is better than σ , then update σ by σ ′. Otherwise, replace σ by
σ ′ when an acceptance probability holds. Keep the best solution and do
the same argument until all orders are determined. This study also
discusses an IG algorithm that executes an embedded insertion-based
local search. The main steps are as follows. For more details on the
insertion-based local search, readers may refer to Msakni et al. (2016),
Ribas et al. (2011), and Ruiz and Stützle (2008).
Insertion local search procedure:
Input sequence σ as the initial sequence;
Input sequence σ ∗ as the current optimal sequence;
For i = 1 to n
For j = 1 to n
/∗Move without repetition an order in the ith position in σ ;∗/
Form σ ′ by removing the order from the ith position in σ and
insert that order at the jth position in σ ;
If (the objective function of σ ′ is less than that of σ ) then
Update σ ∗ by σ ′;
End if
Else if {exp[(the objective function of σ − 0 objective
function of σ ′)/T] ⩾r} then
Update σ by σ ′;
End if
End for
End for
Update σ by σ ∗.
Preliminary instances of the IG algorithm were tested and used to
provide values for the relevant parameters used in the IG algorithm,
namely the controlling temperature parameter (T), the number of
neighborhood improvements (M), and the number of destructions (d).
For n = 12, m = 4, R = 0.5, τ = 0.5, v1 = 0.5, d = n/2 , and T = 0.4,
following the designs of Leung et al. (2006a, 2006b, 2007a, 2007b),
Leung, Lee, et al. (2008), Leung, Li, et al. (2008) and Lee (2013), the
order processing time and due dates were generated separately from
Uniform(1, 100) and TPT × U (1−τ −R/2,1−τ + R/2) , where
m n
TPT = ∑k = 1 ∑i = 1 tik / m , and τ and R denote the tardiness factor and the
range of the due dates respectively. The same instances were tested to
determine the number of neighborhood improvements (M) from 100 to
3000 improvements by increments of 100. As shown in Fig. 1, the best
known M is located at 600 because all of the average error percentages
(AEP) became flat and fluctuated roughly between 0.2% and 0.3% after

0.80 Fig. 1. The performance of M in iterative greedy algo-

rithm at n = 12.

0.60

0.40
AEP

0.20

0.00
100 300 500 700 900 1100 1300 1500 1700 1900 2100 2300 2500 2700 2900
M

155
C.-C. Wu et al. Computers & Industrial Engineering 117 (2018) 152–163

0.40 Fig. 2. The performance of T in iterative greedy algo-

rithm at n = 12.
0.35
0.30
0.25
AEP

0.20
0.15
0.10
0.05
0.00
0.05 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 0.55 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00
T

M = 600, where AEP = [(H −O)/ O] × 100% , H is the solution obtained 2.00
from IG or PSO, and O is the solution obtained from the branch-and- 1.50

AEP
bound method. 1.00
To determine the yield of the optimal T in terms of the AEP, the IG 0.50
algorithm was tested for n = 12, m = 4, R = 0.5, τ = 0.5, v1 = 0.5, 0.00
(N/5)=2 (N/3)=3 (N/2)=5
d = n/2 , and M = 600, by using the same 100 instances over different
values of T starting from 0.05 to 1.0 by an increment of 0.05. As shown
NN
in Fig. 2, the test yielded an optimal known T of 0.75. Fig. 3. The performance of N vs NN in PSO at n = 12 and N = 10.
The solution quality is closely dependent on the value of destruction
size d. However, the higher the value of d is, the more CPU time is 0.90
required. Therefore, for simplicity, this study only reports the experi-

AEP
n
ments that used d = 2 . 0.80
A particle swarm optimization (PSO) algorithm was used to solve
0.70
the problem. The algorithm has been successfully applied to solve a
(N/5)=4 (N/4)=5 (N/3)=7 (N/2)=10
wide variety of discrete optimization problems. Applications can be
found in Poli (2007, 2008). The key point of PSO is that it repeatedly NN
improves a candidate solution with regard to a given measure of quality Fig. 4. The performance of N vs NN in PSO at n = 12 and N = 20.
until the termination condition holds. For details on PSO, readers may
refer to Kennedy and Eberhart (1995, 2001) and Shi and Eberhart
0.70
(1998).
0.65
AEP

The main steps of PSO algorithm:

Input N particles (Yi ) and their velocities (Vi ), for i = 1, 2, …, N . 0.60
Do while (iterations < a given number) 0.55
Update a particle’s velocity: (N/5)=6 (N/4)=7 (N/3)=10 (N/2)=15
Vi,j ← wVi,j + B1rp (pbestij – Yij) + B2rg (gbestj – Yij), j = 1, n
[rp and rg are two random numbers from Uniform(0,1)] NN
Each particle is improved by pairwise interchange. Fig. 5. The performance of N vs NN in PSO at n = 12 and N = 30.
Update the particle’s position: Yi ← Yi + Vi
Replace pbesti with Yi if Yi ≤ pbesti use IG or PSO in numerous scheduling models in the same manner as in
Replace gbest with Yi if Yi ≤ gbest our case. Therefore, it is worth analyzing the strategies employed to
( pbesti and gbest denote the local and global optimal solutions) check their applicability for our problem.
End while The research literature shows that branch-and-bound is commonly
Output the optimal solution gbest. applied to optimize various combinatorial problems. In this study, a
branch-and-bound algorithm with a depth-first policy is adopted to
In the proposed problem, a particle designates a sequence of the n or-
drastically reduce computer storage space. The optimal heuristic of all
ders. To design an order sequence, a group of continuous real numbers
the proposed heuristics is taken as an upper bound in this branch-and-
are discretized by a smallest-to-largest ranking method. For example,
bound. In addition, a lower bound and the previously explained
consider Y = (0.63, 0.91, 0.47, 0.28) as a particle; discretization of Y
Properties are added to improve the performance of the proposed
yields the sequence σ = (3, 4, 2, 1).
branch-and-bound algorithm. The details are summarized as follows.
To determine optimal values for the number of improvements NN
and the number of particles N, 100 PSO instances were generated with
Step Initialization
n = 10, m = 3, τ = 0.5, R = 0.5, v1 = 0.5, iterations (ITRN) = 600, and
1
(w,B1,B2) = (0.5,0.5,0.5) according to Xu et al. (2016), to test three cases
IG, PSO, and three heuristics are performed to obtain a best
at (N; NN/5, NN/3, NN/2) = (10; 2, 3, 5), (N; NN/5, NN/4, NN/3, NN/
schedule as an initial schedule.
2) = (20; 4, 5, 7, 10), and (N; NN/5, NN/4, NN/3, NN/2) = (30; 6, 7,
Step Branching
10, 15).
2
Figs. 3, 4, and 5 show that N: NN = 2: 1 is the optimal combination
The depth-first search strategy from the frontier to the back
because it has the smallest value of AEP. Based on the experimental
is used.
pretests, the PSO parameters (w, B1, B2 , N, NN, ITRN) = (0.5, 0.5, 0.5,
Step Eliminating
N, NN/2, 600) were set for further tests. We are not aware of the ap-
3
plication of IG or PSO to the problem under consideration or other
order scheduling problems. However, the previously cited references

156
C.-C. Wu et al. Computers & Industrial Engineering 117 (2018) 152–163

Properties 1–6 are used to cut the dominated nodes and Table 2
Property 7 is further used to determine the feasible sequence Performances of node and CPU in branch-and-bound changing τ.
for the remaining jobs. For the non-dominated nodes, the
n v1 τ Nodes CPU time FS
lower bound is computed or the objective function is found
when the non-dominated node is completed. 12 0.25 0.25 3,901,916 41.690 900
Step Bounding 0.50 3,759,154 39.950 900
0.50 0.25 3,965,169 42.205 900
4
0.50 3,731,775 39.622 900
If the lower bound is larger than the initial solution, the node 0.75 0.25 3,778,855 36.635 900
and all nodes beyond it in the branch are cut.If the objective 0.50 3,422,989 35.066 900
function is smaller than the initial solution, the initial 14 0.25 0.25 41,173,031 537.135 488
solution is replaced by the current objective function. 0.50 39,383,672 492.945 515
Step Stopping rule 0.50 0.25 39,933,542 527.540 480
5 0.50 37,711,085 481.101 506
0.75 0.25 39,913,873 488.641 489
Repeat Steps 2–4 until all nodes are visited.
0.50 36,338,919 444.862 520

5. The reports on experimental simulations Table 3

Performances of node and CPU in branch-and-bound changing R.
This section reports a computational experiment, coded in Fortran,
n v1 R Nodes CPU time FS
to test the performances of all the proposed algorithms including the
proposed branch-and-bound, MAXSPT.VW, MEANSPT.VW, 12 0.25 0.25 4,043,876 42.317 600
MINSPT.VW, IG, and PSO algorithms. All programs were executed on 0.50 4,163,024 44.502 600
Compaq Visual Fortran version 6.6 with a 2.66-GHz Intel(R) Core(TM)2 0.75 3,284,704 35.641 600
0.50 0.25 3,697,350 39.290 600
Duo E8200 CPU and 1.99-GB RAM in Windows XP. Following the same
0.50 4,229,143 45.023 600
scheme as Leung et al. (2006b), Lee (2013), and Xu et al. (2016), order 0.75 3,618,924 38.427 600
processing times were generated from a uniform distribution U(1, 100) 0.75 0.25 3,376,005 34.665 600
and order due dates from another uniform distribution 0.50 3,965,373 36.348 600
m n
TPT × U (1−τ −R/2,1−τ + R/2) , where TPT = ∑i = 1 ∑ j = 1 tij / m , τ is the 0.75 3,461,387 36.538 600
tardiness and R the range of the due dates. A value of τ close to 1 in- 14 0.25 0.25 43,141,033 537.369 313
dicates that the due dates are tight, while its value close to 0 indicates 0.50 41,688,502 540.554 333
that the due dates are loose. A high value of R indicates a wide range of 0.75 36,005,520 467.198 357
0.50 0.25 40,781,604 533.364 321
due dates, while a low value indicates a narrow range of due dates. For 0.50 39,133,673 509.157 324
more details, readers may refer to Fisher (1976). The values of (τ, R) 0.75 36,551,665 470.441 341
were set at (0.25, 0.25), (0.5, 0.25), (0.5, 0.5), (0.5, 0.75), (0.25, 0.5), 0.75 0.25 38,832,626 481.687 327
and (0.25, 0.75). One hundred instances were tested for each case. In 0.50 39,022,760 477.691 335
0.75 36,523,802 440.875 347
addition, the branch-and-bound algorithm skipped to the next set of
data when the number of nodes exceeded 108, while those with fewer 12 0.25 3,830,535 40.820 1800
0.50 3,848,472 40.914 1800
than 108 nodes are recorded as feasible solutions or FS.
0.75 3,600,922 35.850 1800
To evaluate the performances of the branch-and-bound and five
heuristics for small number of orders, simulations were run for two order 14 0.25 40,278,352 515.040 1003
0.50 38,822,314 504.321 986
sizes, n = 12 and 14 and three machine sizes, m = 2, 3, and 4. In total, 0.75 38,126,396 466.751 1009
3600 instances (n × m × R × τ × 100 = 2 × 3 × 3 × 2 × 100 = 3600 )
were generated for small numbers of orders. Each instances were ex-
amined at different values of v1 (v1 = 0.25, 0.5, and 0.75). Table 1 shows of machines increases. Table 2 displays the effect of τ: for fixed v1, the
the effect of m: the average of node or CPU time increases as the number instances with larger values of τ required fewer nodes and less CPU time
than did those with smaller values of τ. Table 3 indicates no trend for the
Table 1 effect of R on the branch-and-bound method. Regarding the number of
Performances of node and CPU in branch-and-bound changing m. orders, Tables 1–3 demonstrate that the average node or CPU time in-
creases sharply as the number of orders increases slightly, and the
n v1 m Nodes CPU time FS
number of feasible solutions (FSs) declines sharply as the number of
12 0.25 2 943,105 8.167 600 orders increases slightly. On an average, as shown in the bottom six rows
3 3,671,586 34.574 600 of Table 3, average node or CPU time decreases as v1 becomes big.
4 6,876,913 79.720 600
The performances of the five proposed heuristics, namely IG, PSO,
0.50 2 929,218 7.988 600
3 3,637,228 35.704 600 MaxSPT-VW, MeanSPT-VW, and MinSPT-VW, are shown in Table 4. It
4 6,978,971 79.048 600 demonstrates that the AEP of MinSPT-VW increases as the number of
0.75 2 845,699 6.195 600 machines increases. MaxSPT-VW has the same phenomenon. Other
3 3,369,520 29.639 600 heuristics show no trend for fixed values of v1. Table 5 indicates that for
4 6,587,546 71.717 600
fixed value of v1, MinSPT-VW with τ = 0.25 outperforms MinSPT-VW
14 0.25 2 21,645,736 240.956 538 with τ = 0.5 for both n = 12 and n = 14. Other methods did not show
3 42,023,416 535.416 317
the same pattern. Regarding the effect of R, Table 6 indicates that no
4 57,165,904 768.748 148
0.50 2 21,156,929 252.717 538 AEP pattern was evident for the five algorithms. As for CPU time con-
3 41,775,947 546.895 314 sumption, Table 7 shows that MaxSPT-VW, MeanSPT-VW, and MinSPT-
4 53,534,066 713.351 134 VW consumed the least amount of CPU time, IG consumed a slightly
0.75 2 20,539,886 222.263 548
higher amount of CPU time, and PSO consumed the greatest amount of
3 40,850,597 492.971 323
4 52,988,705 685.020 138 CPU time. However, all methods required less than 1.3 s of CPU time.
Fig. 6 shows the AEP boxplots of the five methods for small numbers of

157
C.-C. Wu et al. Computers & Industrial Engineering 117 (2018) 152–163

Table 4 Table 7
Performances of AEP of five algorithms changing m for small number of orders. Performances of CPU time of five algorithms changing m for small number of orders.

n v1 m IG PSO Max SPT- Mean SPT- Min SPT-VW FS n v1 m IG PSO Max SPT- Mean SPT- Min SPT- FS
VW VW VW VW VW

12 0.25 2 0.270 1.015 3.813 2.860 11.278 600 12 0.25 2 0.051 0.603 0.000 0.000 0.000 600
3 0.305 0.878 5.760 3.937 14.962 600 3 0.061 0.611 0.000 0.000 0.000 600
4 0.340 0.868 6.240 4.458 16.270 600 4 0.071 0.576 0.000 0.000 0.000 600
0.50 2 0.243 0.793 3.707 3.068 9.788 600 0.50 2 0.051 0.582 0.000 0.000 0.000 600
3 0.292 0.848 5.515 4.185 12.587 600 3 0.061 0.590 0.000 0.000 0.000 600
4 0.302 0.737 6.133 4.802 13.235 600 4 0.072 0.561 0.000 0.000 0.000 600
0.75 2 0.235 0.728 3.923 3.360 9.700 600 0.75 2 0.051 0.595 0.000 0.000 0.000 600
3 0.278 0.722 5.725 4.500 12.227 600 3 0.061 0.597 0.000 0.000 0.000 600
4 0.297 0.673 6.438 5.160 12.605 600 4 0.072 0.574 0.000 0.000 0.000 600

14 0.25 2 0.622 1.490 4.217 3.247 11.560 538 14 0.25 2 0.079 1.232 0.000 0.000 0.000 531
3 0.660 1.487 5.597 4.182 15.250 317 3 0.095 1.252 0.000 0.000 0.000 299
4 0.653 1.347 6.570 4.198 17.885 148 4 0.113 1.208 0.000 0.000 0.000 130
0.50 2 0.535 1.328 4.070 3.270 10.128 538 0.50 2 0.079 1.244 0.000 0.000 0.000 533
3 0.638 1.278 5.442 4.495 12.795 314 3 0.095 1.241 0.000 0.000 0.000 306
4 0.637 1.200 6.222 4.335 14.382 134 4 0.112 1.112 0.000 0.000 0.000 125
0.75 2 0.502 1.125 4.253 3.530 10.007 548 0.75 2 0.080 1.258 0.000 0.000 0.000 545
3 0.555 1.193 5.630 4.718 12.208 323 3 0.095 1.176 0.000 0.000 0.000 311
4 0.600 1.113 6.198 4.782 13.825 138 4 0.114 1.042 0.000 0.000 0.000 131

Table 5 orders. IG slightly outperformed PSO, but IG notably outperformed

Performances of AEP of five algorithms changing τ for small number of orders. MaxSPT-VW, MeanSPT-VW, and MinSPT-VW regardless of the value of
v1. Furthermore, as shown in the bottom six rows of Table 6, the mean
n v1 τ IG PSO Max SPT- Mean SPT- Min SPT- FS
VW VW VW AEPs of IG, PSO and MinSPT-VW decrease slightly as v1 becomes big.
To evaluate the performances of all five algorithms for large num-
12 0.25 0.25 0.304 0.982 5.677 4.092 16.713 900 bers of orders, simulations were run for orders at n = 50 and 100, for
0.50 0.306 0.859 4.866 3.411 11.627 900
machines at m = 5, 10, and 20, and for the parameter v1 = 0.25, 0.5,
0.50 0.25 0.259 0.807 5.309 4.186 12.806 900
0.50 0.299 0.779 4.928 3.851 10.934 900
and 0.75. The values of (τ, R) were also set at (0.25, 0.25), (0.5, 0.25),
0.75 0.25 0.253 0.719 5.476 4.462 11.984 900 (0.5, 0.5), (0.5, 0.75), (0.25, 0.5), and (0.25, 0.75). One hundred in-
0.50 0.287 0.697 5.249 4.218 11.037 900 stances were tested for each case. Therefore, in total, 3600 instances
14 0.25 0.25 0.672 1.516 5.540 3.907 17.494 488 were tested. For each heuristic method, this paper reports the average
0.50 0.618 1.367 5.382 3.844 12.302 515 computing time and the average relative percentage of deviance (RPD),
0.50 0.25 0.618 1.278 5.253 3.968 13.336 480 where RPD = (HiH ∗)/ H ∗ × 100%, Hi is the objective function yielded by
0.50 0.589 1.260 5.236 4.099 11.534 506
each heuristic, and H ∗ is the smallest value of the objective function
0.75 0.25 0.554 1.143 5.272 4.266 12.471 489
0.50 0.550 1.144 5.449 4.421 11.556 520 among the five proposed algorithms. The relevant experimental results
are summarized in Tables 8–11.
As shown in Table 8, for a fixed value of v1, the RPDs of IG and PSO
Table 6 decrease, but the RPDs of MaxSPT-VW and MeanSPT-VW increase, as
Performances of AEP of five algorithms changing R for small number of orders. the number of machines rises. There was no such pattern with MinSPT-
VW. Regarding the effect of τ , Table 9 shows that for a fixed value of v1,
n v1 r IG PSO Max SPT- Mean SPT- Min SPT- FS
VW VW VW
the IG instances with a small value of τ had a slightly bigger RPD than
those with a large value of τ , but this pattern was not evident in the
12 0.25 0.25 0.240 0.702 4.912 3.860 11.755 600 others. For the effect of R, Table 10 shows no pattern among the five
0.50 0.308 0.920 5.490 3.485 14.573 600 algorithms. As to the CPU time consumption for large orders, Table 11
0.75 0.367 1.140 5.412 3.910 16.182 600
0.50 0.25 0.248 0.733 5.388 4.408 11.618 600
shows that the average computing time of IG increases as the number of
0.50 0.303 0.760 5.233 3.805 12.043 600 machines increases for a fixed v1. There is no particular trend for the
0.75 0.285 0.885 4.733 3.842 11.948 600 other four algorithms. Table 11 also demonstrates that IG consumed the
0.75 0.25 0.250 0.670 5.725 4.712 11.787 600 most computing time, PSO consumed the next highest amount, and the
0.50 0.267 0.733 5.438 4.172 11.575 600
other three algorithms consumed the least. As illustrated in Table 8, the
0.75 0.293 0.720 4.923 4.137 11.170 600
RPDs of IG and PSO increased but those of the three SPT-VW heuristics
14 0.25 0.25 0.495 1.105 4.738 3.762 12.332 313
decreased as n increased from 50 to 100 for fixed v1 and m. This phe-
0.50 0.640 1.433 5.687 3.733 14.955 333
0.75 0.800 1.785 5.958 4.132 17.408 357
nomenon might require larger parameter values of IG and PSO, the
0.50 0.25 0.553 1.088 5.182 4.197 12.097 321 considered two metaheuristics, than those used in the small number of
0.50 0.602 1.273 5.560 4.080 12.280 324 jobs because the search scope increased exponentially in n. The same
0.75 0.655 1.445 4.992 3.823 12.928 341 situations occurred for fixed v1 and τ in Table 9, and for fixed v1 and R in
0.75 0.25 0.537 1.060 5.413 4.468 12.228 327
Table 10. Regarding the impact of v1, as shown in the bottom six rows of
0.50 0.545 1.217 5.583 4.382 11.857 335
0.75 0.575 1.155 5.085 4.180 11.955 347 Table 10, all the five algorithms performed stable in term of the RPD,
only the mean RPD of PSO and MinSPT-VW decreased slightly as v1
12 0.25 0.305 0.921 5.271 3.752 14.170 1800
0.50 0.279 0.793 5.118 4.018 11.870 1800 became big. IG took an average CPU time of about eight seconds at
0.75 0.270 0.708 5.362 4.340 11.511 1800 n = 50 and 63 s at n = 100; PSO took an average CPU time of about
14 0.25 0.645 1.441 5.461 3.876 14.898 1003
48 s at n = 50 and 280 s at n = 100; the other three heuristics took less
0.50 0.603 1.269 5.244 4.033 12.435 986 than one second as displayed at the bottom six rows of Table 11.
0.75 0.552 1.144 5.361 4.343 12.013 1009 We carried out one-way analysis of variance to investigate the dif-
ferences among the performances of the five algorithms for small and

158
C.-C. Wu et al. Computers & Industrial Engineering 117 (2018) 152–163

Fig. 6. Boxplot of AEP of five algorithms for small

number of orders.

Table 8 Table 10
Performances of RPD of five algorithms changing m for big number of orders. Performances of RPD of five algorithms changing R for big number of orders.

n v1 m IG PSO Max SPT- Mean SPT- Min SPT- FS n v1 R IG PSO Max SPT- Mean SPT- Min SPT- FS
VW VW VW VW VW VW

50 0.25 5 0.190 5.197 6.475 2.598 10.820 600 50 0.25 0.25 0.092 3.807 7.347 3.315 10.272 600
10 0.027 4.127 7.983 3.755 11.392 600 0.50 0.070 4.422 7.458 3.698 11.330 600
20 0.002 3.610 8.062 4.712 11.058 600 0.75 0.057 4.705 7.715 4.052 11.668 600
0.50 5 0.175 4.553 6.180 2.410 9.580 600 0.50 0.25 0.082 3.503 7.263 3.398 9.603 600
10 0.033 3.458 7.645 3.585 10.093 600 0.50 0.062 3.663 7.088 3.473 9.862 600
20 0.005 2.812 7.692 4.427 9.663 600 0.75 0.070 3.657 7.165 3.550 9.872 600
0.75 5 0.172 4.193 6.257 2.492 9.380 600 0.75 0.25 0.083 3.318 7.353 3.523 9.508 600
10 0.030 3.108 7.675 3.643 9.827 600 0.50 0.063 3.285 7.155 3.555 9.593 600
20 0.002 2.627 7.755 4.500 9.415 600 0.75 0.057 3.325 7.178 3.557 9.520 600

100 0.25 5 0.702 7.385 5.495 0.947 8.170 600 100 0.25 0.25 0.308 5.287 6.157 1.847 8.052 600
10 0.088 5.097 6.660 2.060 8.485 600 0.50 0.283 5.608 6.368 2.000 8.405 600
20 0.013 4.088 6.895 2.927 8.357 600 0.75 0.212 5.675 6.525 2.087 8.555 600
0.50 5 0.807 6.920 5.357 0.813 7.675 600 0.50 0.25 0.330 4.975 6.077 1.775 7.670 600
10 0.125 4.565 6.452 1.850 7.880 600 0.50 0.340 5.070 6.168 1.777 7.777 600
20 0.017 3.600 6.653 2.662 7.702 600 0.75 0.278 5.040 6.217 1.773 7.810 600
0.75 5 0.827 6.800 5.357 0.803 7.572 600 0.75 0.25 0.333 4.878 6.098 1.793 7.605 600
10 0.122 4.437 6.447 1.833 7.758 600 0.50 0.342 4.945 6.157 1.747 7.635 600
20 0.017 3.453 6.650 2.642 7.573 600 0.75 0.290 4.867 6.198 1.738 7.663 600

50 0.25 0.073 4.311 7.507 3.688 11.090 600

0.50 0.071 3.608 7.172 3.474 9.779 600
Table 9 0.75 0.068 3.309 7.229 3.545 9.540 600
Performances of RPD of five algorithms changing τ for big number of orders.
100 0.25 0.268 5.523 6.350 1.978 8.337 600
n v1 τ IG PSO Max SPT- Mean SPT- Min SPT- FS 0.50 0.316 5.028 6.154 1.775 7.752 600
VW VW VW 0.75 0.322 4.897 6.151 1.759 7.634 600

50 0.25 0.25 0.084 4.368 7.590 3.729 11.352 900

0.50 0.061 4.254 7.423 3.648 10.828 900 and the range of due date (R) were not at the 0.05 level of significance.
0.50 0.25 0.081 3.656 7.214 3.501 9.882 900 This implied that as the value of the n increased from 50 to 100, the
0.50 0.061 3.560 7.130 3.447 9.676 900
optimal solutions were harder and harder to find. This also confirms
0.75 0.25 0.078 3.300 7.228 3.537 9.568 900
0.50 0.058 3.319 7.230 3.553 9.513 900 that the study is a NP-hard problem.
Fisher’s least significant difference tests were carried out to further
100 0.25 0.25 0.243 5.548 6.374 1.939 8.401 900
0.50 0.292 5.499 6.326 2.017 8.273 900 compare the quality of solutions among the five algorithms. Tables 14
0.50 0.25 0.284 4.996 6.138 1.726 7.737 900 and 15 report the results of the tests. The overall averages (for small
0.50 0.348 5.061 6.170 1.824 7.768 900 orders) of AEPs, in increasing order, are 0.4423, 1.0414, 4.0420,
0.75 0.25 0.290 4.871 6.123 1.707 7.593 900 5.2796, and 12.8004 for IG, PSO, MeanSPT-VW, MaxSPT-VW, and
0.50 0.353 4.922 6.179 1.812 7.676 900
MinSPT-VW, respectively. All pairwise comparisons among the five
algorithms are significant at the 0.05 level for small orders. The overall
large orders. Tables 12 and 13 display the results of the analysis. In averages (for big orders) of RPDs, in increasing order, are 0.1862,
view of the fact that the p-values are less than 0.05, one can refer to the 2.7032, 4.4461, 6.7605, and 9.0222 for IG, MeanSPT-VW, PSO,
row “Algorithm” under “Source of Variation” in Tables 12 and 13, to MaxSPT-VW, MinSPT-VW, respectively. All pairwise comparisons
conclude that the performances of the proposed five algorithms are among the five algorithms are significant at the 0.05 level for large
significantly different at the 0.05 level, regardless of the order size. The orders showing similar trend to that of the small orders.
analysis of variance of RPD in Table 13 shows that the size of orders (n) Additionally, by using the same data for small numbers of orders,
was significant while the number of machines (m), the tardy factor (τ), we also evaluated the performances of the branch-and-bound and all

159
C.-C. Wu et al. Computers & Industrial Engineering 117 (2018) 152–163

Table 11 Table 14
Performances of CPU of five algorithms changing m for big number of orders. Fisher's LSD of AEP of five algorithms for small number of orders.

n v1 m IG PSO Max SPT- Mean SPT- Min SPT- FS Pairwise Comparison Pairwise Mean LSD(α = 0.05) = 0.3485
VW VW VW Difference
Between Algorithms |AEPi −AEPj | Difference > LSD?
50 0.25 5 7.867 48.746 0.001 0.000 0.000 600
10 14.035 45.375 0.001 0.001 0.000 600 IG vs. PSO |0.4424–1.0458| Yes
20 25.202 41.674 0.001 0.001 0.000 600 IG vs. Max SPT-VW |0.4424–5.3030| Yes
0.50 5 7.961 44.968 0.001 0.000 0.000 600 IG vs. Mean SPT-VW |0.4424–4.0604| Yes
10 14.132 43.002 0.001 0.001 0.000 600 IG vs. Min SPT-VW |0.4424–12.8162| Yes
20 25.305 43.834 0.001 0.001 0.000 600 PSO vs. Max SPT-VW |1.0458–5.3030| Yes
0.75 5 7.730 45.382 0.000 0.000 0.000 600 PSO vs. Mean SPT-VW |1.0458–4.0604| Yes
10 13.975 43.298 0.001 0.001 0.000 600 PSO vs. Min SPT-VW |1.0458–12.8162| Yes
20 25.013 41.150 0.001 0.001 0.000 600 Max SPT-VW vs. Mean |5.3030–4.0604| Yes
100 0.25 5 61.735 280.091 0.003 0.002 0.000 600 SPT-VW
10 107.447 279.714 0.003 0.002 0.000 600 Max SPT-VW vs. Min SPT- |5.3030–12.8162| Yes
20 197.945 272.761 0.004 0.002 0.000 600 VW
0.50 5 62.543 275.253 0.002 0.002 0.000 600 Mean SPT-VW vs. Min |4.0604–12.8162| Yes
10 107.173 277.630 0.003 0.002 0.000 600 SPT-VW
20 198.183 265.906 0.004 0.002 0.000 600
0.75 5 63.350 280.257 0.002 0.002 0.000 600
10 106.792 278.932 0.003 0.002 0.000 600 Table 15
20 197.233 271.008 0.003 0.002 0.000 600 Fisher's LSD of RDP of five algorithms for big number of orders.
50 0.25 7.867 48.746 0.001 0.000 0.000 600
Pairwise Comparison Pairwise Mean LSD(α = 0.05) = 0.270
0.50 7.961 44.968 0.001 0.000 0.000 600
Difference
0.75 7.730 45.382 0.000 0.000 0.000 600
Between Algorithms |AEPi −AEPj | Difference > LSD?
100 0.25 61.735 280.091 0.003 0.002 0.000 600
0.50 62.543 275.253 0.002 0.002 0.000 600 IG vs. PSO |0.1862–4.4461| Yes
0.75 63.350 280.257 0.002 0.002 0.000 600 IG vs. Max SPT-VW |0.1862–6.7605| Yes
IG vs. Mean SPT-VW |0.1862–2.7032| Yes
IG vs. Min SPT-VW |0.1862–9.0222| Yes
Table 12 PSO vs. Max SPT-VW |4.4461–6.7605| Yes
ANOVA of AEP of five algorithms for small number of orders. PSO vs. Mean SPT-VW |4.4461–2.7032| Yes
PSO vs. Min SPT-VW |4.4461–9.0222| Yes
Source of Variation DF Sum of Squares Mean Square F Value Pr>F Max SPT-VW vs. Mean SPT- |6.7605–2.7032| Yes
VW
Model 12 10947.41 912.28 536.83 < 0.0001 Max SPT-VW vs. Min SPT- |6.7605–9.0222| Yes
v1 2 31.29 15.64 9.21 0.0001 VW
Algorithm 4 10596.94 2649.24 1558.94 < 0.0001 Mean SPT-VW vs. Min SPT- |2.7032–9.0222| Yes
Size 1 12.87 12.87 7.58 0.0061 VW
τ 1 52.01 52.01 30.60 < 0.0001
R 2 11.41 5.70 3.36 0.0356
Machine 2 242.89 121.45 71.47 < 0.0001 Table 16
Error 527 895.57 1.70 The performance of branch-and-bound algorithm at v1 =0 and 1.
Corrected Total 539 11842.99
n v1 Nodes CPU time FS

Table 13 12 0.00 2,381,549 23.41 1800

ANOVA of RPD of five algorithms for big number of orders. 1.00 3,841,347 36.77 1800

14 0.00 31,550,274 370.86 1305

Source of Variation DF Sum of Squares Mean Square F Value Pr>F 1.00 39,431,933 477.33 983

Model 12 5201.55 433.46 420.92 < 0.0001

R
v1 2 22.94 11.47 11.14 < 0.0001
12 0.25 3,897,547 34.77 1200
Algorithm 4 5110.97 1277.74 1240.78 < 0.0001
0.50 3,238,406 31.95 1200
Size 1 62.66 62.66 60.85 < 0.0001
075 2,198,391 23.55 1200
τ 1 0.11 0.11 0.11 0.7438
R 2 3.08 1.54 1.50 0.2248 14 0.25 43,530,369 490.36 627
Machine 2 1.78 0.89 0.87 0.4211 0.50 35,765,545 433.77 765
Error 527 542.7. 1.03 0.75 27,177,396 348.15 896
Corrected Total 539 5744.25
τ
12 0.25 3,151,328 30.50 1800
0.50 3,071,568 29.68 1800
five proposed algorithms at n = 12, 14; m = 2, 3, 4; and v1 = 0.0, 1.0.
This implies that with v1 = 0.0, we only minimized the maximum tar- 14 0.25 35,585,583 433.08 1133
diness while with v1 = 1.0, we only minimized the total completion 0.50 35,396,624 415.11 1155
m
time. As demonstrated in Table 16, the branch-and-bound method took
more nodes and CPU time at v1 = 1.0 than it did at v1 = 0.0 while it had 12 2 750,239 6.32 1200
3 2,946,689 28.59 1200
fewer the number of FS at v1 = 1.0 than it did at v1 = 0.0. The number
4 5,637,415 55.35 1200
of nodes and the CPU time decreased while the number of FS increased
14 2 18,263,248 181.12 1115
as R increased. This implies that the instances with a wide range of due
3 37,174,918 433.29 744
dates were easily solved out. The same phenomena occurred with 4 51,035,145 657.882 429
greater tardiness. Moreover, the number of nodes and the CPU time
increased while the number of FS decreased as m increased. For the

160
C.-C. Wu et al. Computers & Industrial Engineering 117 (2018) 152–163

Table 17
The performance of five algorithms at v1 = 0 and 1.

IG PSO Max SPT-VW Mean SPT-VW Min SPT-VW

AEP CPU AEP CPU AEP CPU AEP CPU AEP CPU
n v1 Mean Mean Mean Mean Mean Mean Mean Mean Mean Mean

12 0.00 0.11 0.07 2.03 0.41 199.79 0.00 144.36 0.00 653.03 0.00
(0.08) (1.45) (59.76) (34.08) (183.54)
1.00 0.26 0.07 0.70 0.59 5.73 0.00 4.71 0.00 11.67 0.00
(0.26) (0.70) (5.73) (4.71) (11.67)

14 0.00 3.32 0.10 17.02 0.71 323.36 0.00 218.46 0.00 907.45 0.00
(0.36) (7.65) (89.88) (53.64) (240.13)
1.00 0.55 0.11 1.04 1.24 5.69 0.00 4.66 0.00 12.08 0.00
(0.55) (1.04) (5.69) (4.66) (12.08)

R
12 0.25 0.13 0.07 0.34 0.49 5.38 0.00 3.29 0.00 17.97 0.00
(0.13) (0.34) (5.38) (3.29) (17.97)
0.50 0.14 0.07 0.56 0.52 20.93 0.00 6.81 0.00 58.63 0.00
(0.14) (0.56) (20.93) (6.81) (58.63)
0.75 0.30 0.07 3.19 0.50 281.97 0.00 213.49 0.00 920.46 0.00
(0.24) (2.32) (71.93) (48.07) (216.21)

14 0.25 0.27 0.11 0.53 0.95 4.76 0.00 2.93 0.00 18.16 0.00
(0.27) (0.53) (4.76) (2.93) (18.16)
0.50 0.26 0.10 0.99 1.01 20.00 0.00 6.98 0.00 65.77 0.00
(0.26) (0.99) (20.00) (6.98) (65.77)
0.75 5.24 0.11 25.57 0.96 468.82 0.00 324.77 0.00 1295.36 0.00
(0.81) (11.51) (118.60) (77.54) (294.39)

τ
12 0.25 0.22 0.07 2.17 0.49 195.84 0.00 144.28 0.00 643.46 0.00
(0.18) (1.59) (55.81) (34.00) (173.96)
0.50 0.16 0.07 0.56 0.51 9.68 0.00 4.78 0.00 21.25 0.00
(0.16) (0.56) (9.68) (4.78) (21.25)

14 0.25 3.54 0.11 16.97 0.96 317.20 0.00 216.66 0.00 896.12 0.00
(0.58) (7.60) (83.72) (51.85) (228.81)
0.50 0.31 0.10 1.09 0.98 11.86 0.00 6.45 0.00 23.40 0.00
(0.31) (1.09) (11.86) (6.45) (23.40)

m
12 2 0.17 0.05 1.88 0.46 135.00 0.00 79.08 0.00 503.62 0.00
(0.19) (0.89) (32.92) (17.13) (96.48)
3 0.24 0.07 0.88 0.51 105.53 0.00 103.05 0.00 301.18 0.00
(0.16) (0.94) (42.06) (26.44) (115.32)
4 0.15 0.08 1.33 0.53 67.76 0.00 41.46 0.00 192.26 0.00
(0.15) (1.39) (23.25) (14.61) (81.02)

14 2 4.83 0.09 15.20 0.94 223.24 0.00 165.95 0.00 643.16 0.00
(0.36) (5.21) (46.94) (38.57) (135.83)
3 0.42 0.11 6.66 0.87 140.17 0.00 105.31 0.00 440.24 0.00
(0.44) (2.24) (36.52) (19.47) (108.98)
4 0.52 0.12 5.22 1.10 130.17 0.00 63.41 0.00 295.89 0.00
(0.54) (5.58) (59.90) (29.41) (133.52)

Grand 1.06 0.09 5.20 0.74 133.64 0.00 93.05 0.00 396.06 0.00
Mean (0.31) (2.71) (40.27) (24.27) (111.86)

The number in (.) denotes that the AEP excludes the case with the optimal value of zero.

performances of five heuristics, as shown in Table 17, all five heuristics
performed better in term of the AEP at cases with v1 = 1.00 than they
did at cases with v1 = 0.0, except the IG at case n = 12. All of the AEPs
among five heuristics increased as R increased, except the IG at case
n = 14. It can be seen that all the five heuristics performed better at
cases with a bigger value of τ . As for the impact of m, only the AEPs of
Max SPT-VW and Min SPT-VW methods decreased as m increased. We
noted that a good near-optimal solution could be difficult to obtain
once the instance had an optimal solution of zero. It might occur when
the instance had a longer due date. Table 14 shows that the overall
mean of AEP of the IG is only 1.06%. It reduced to 0.31% when we
excluded the case at the optimal solution of zero. This confirms that IG
performed the best, followed by PSO, while Max SPT-VW, Mean SPT-
VW, and Min SPT-VW performed the worst at the special case v1 = 0.0
and 1.0. We further conducted additional experiments at n = 10, 11,
m = 2, 3, 4, and v1 = 0.25, 0.5, 0.75, to evaluate the performance of the
B&B technique relative to total enumeration. Table 18 shows that the B
&B performed better than the total enumeration at n = 10, while it
outperformed the total enumeration at n = 11 in term of the CPU time
no matter what m or R or v1 or τ is.
The research literature revealed that IG algorithm was extended
from ILS (iterated local search) by Ruiz and Stützle (2007), and
Lourenco, Martin, & Stutzle (2010, Ch12, p. 386). It was designed and
modified originally for flowshop scheduling problem. Meanwhile, the
PSO was originally developed for continuous search spaces. Therefore,
some adjustments should be made for the PSO to apply on discrete
search spaces. The two main characteristics, position and direction, in
PSO were not very clearly defined in discrete search cases. Aside from

161
C.-C. Wu et al. Computers & Industrial Engineering 117 (2018) 152–163

Table 18
The comparison of the enumeration and B&B at n = 10 and 11.

n m Enumeration B&B R Enumeration B&B v1 Enumeration B&B τ Enumeration B&B

Mean Mean Mean Mean Mean Mean Mean Mean

10 2 2.56 0.25 0.25 2.97 0.59 0.25 2.94 0.64 0.25 3.01 0.62
3 2.99 0.71 0.50 2.93 0.60 0.50 2.91 0.64 0.50 2.81 0.64
4 3.17 0.93 0.75 2.82 0.70 0.75 2.88 0.62 0.25 34.81 5.53

11 2 27.86 1.53 0.25 34.89 5.37 0.25 34.86 5.31 0.50 34.27 4.82
3 35.18 4.95 0.50 34.77 5.27 0.50 34.41 5.27
4 40.58 9.04 0.75 33.96 4.88 0.75 34.34 4.94

Fig. 7. Boxplot of RPD of five algorithms for big

number of orders.

that, the performance of IG algorithm was better than that of PSO in the
variants of (permutation) flow shop problem (Pan and Ruiz (2014),
Wang, Li, Ruiz, and Sui (2017). Overall, the experimental results in-
dicated that the mean AEP (for small orders) and mean RPD (for large
orders) of the IG algorithm is the smallest (best), whereas MinSPT-VW
is the largest (worst) for both of small and big orders at the 0.05 sig-
nificance level. In addition, the IG has the least dispersion of the five
algorithms, as shown in Figs. 6 and 7. These results show that the so-
lutions obtained from the proposed IG have both high accuracy and
high stability.
6. Conclusions and suggestions
may add order setup times to address practical production scheduling
models. Another future issue may provide more powerful dominances
and lower bound used in the branch-and-bound method.
Acknowledgements
The authors thank the Editor and one anonymous referee for their
helpful comments on the three earlier versions of our paper. This paper
was supported in part by the Ministry of Science Technology (MOST) of
Taiwan under Grant Nos. MOST 105-2221-E-035- 053-MY3. In addi-
tion, authors much thank Prof Kunjung Lai who helps us to revise this
paper.

Many researchers have confirmed that order scheduling problems References

exist in numerous manufacturing and service environments. Generally,
for real-world applications, production managers must optimize mul-
tiple objectives instead of a single objective. In particular, minimizing
the total completion time means that the system can yield a task plan of
superior efficiency that can minimize both in-process inventory costs
and maximum tardiness. Therefore, the proposed system can increase
the degree of customer satisfaction. In this research, to determine an
appropriate schedule to minimize the tradeoff between short produc-
tion time and on-time delivery of customer orders, we proposed an
order scheduling model which optimized a linear sum of the total
flowtime and the maximum tardiness. Several properties and a lower
bound were proposed for a branch-and-bound method to obtain the
optimal sequence. Moreover, IG, PSO, MaxSPT-VW, MeanSPT-VW, and
MinSPT-VW methods were proposed to generate approximate solutions.
The test results indicated that the proposed branch-and-bound method
could solve instances of up to 14 orders, but required considerable
amount of computing time. The test results showed that IG yielded a
favorable quality of solutions in terms of their high accuracy and sta-
bility for both small and large numbers of orders. Future research may
consider how to reduce the CPU time consumed by the IG method, or
Ahmadi, R. H. & Bagchi, U. (1993) Coordinated scheduling of customer orders, Working
paper, John E. Anderson Graduate School of Management, University of California,
Los Angeles, 1993.
Ahmadi, R. H., Bagchi, U., & Roemer, T. A. (2005). Coordinated scheduling of customer
orders for quick response. Naval Research Logistics, 52, 493–512.
Blocher, J. D., Chhajed, D., & Leung, M. (1998). Customer order scheduling in a general
job shop environment. Decision Sciences, 29(4), 951–981.
Chen Z. L. & Hall, N. G. (2001) Supply chain scheduling: assembly systems, Working
Paper, Department of Systems Engineering, University of Pennsylvania.
Erel, E., & Ghosh, J. B. (2007). Customer order scheduling on a single machine with
family setup times: Complexity and algorithms. Applied Mathematics and Computation,
185, 11–18.
Fisher, M. L. (1976). A dual algorithm for the one-machine scheduling problem.
Mathematical Programming, 11, 229–251.
Hardy, G. H., Littlewood, J. E., & Polya, G. (1967). Inequalities. London: Cambridge
University Press.
Hsu, S. Y., & Liu, C. H. (2009). Improving the delivery efficiency of the customer order
scheduling problem in a job shop. Computers & Industrial Engineering, 57, 856–866.
Kennedy, J. & Eberhart, R. (1995) Particle swarm optimization. In IEEE international
conference on neural networks (Vol. 4, pp. 1942–1948).
Kennedy, J., & Eberhart, R. C. (2001). Swarm intelligence. Morgan Kaufmann ISBN 1-
55860-595-9.
Kirkpatrick, S., Gellat, C. D., & Vecchi, M. P. (1983). Optimization by simulated annealing
algorithm. Science, 220, 671–680.

162
C.-C. Wu et al.
Lee, I. S. (2013). Minimizing total tardiness for the order scheduling problem.
International Journal of Production Economics, 144, 128–134.
Leung, J. Y. T., Lee, C. Y., Ng, C. W., & Young, G. H. (2008). Preemptive multiprocessor
order scheduling to minimize total weighted flowtime. European Journal of
Operational Research, 190, 40–51.
Leung, J. Y. T., Li, H., & Pinedo, M. (2005). Order scheduling in an environment with
dedicated resources in parallel. Journal of Scheduling, 8, 355–386.
Leung, J. Y. T., Li, H., & Pinedo, M. (2006a). Approximation algorithms for minimizing
total weighted completion time of orders on identical machines in parallel. Naval
Research Logistics, 53, 243–260.
Leung, J. Y. T., Li, H., & Pinedo, M. (2006b). Scheduling orders for multiple product types
with due date related objectives. European Journal of Operational Research, 168,
370–389.
Leung, J. Y. T., Li, H., & Pinedo, M. (2007a). Scheduling orders for multiple product types
to minimize total weighted completion time. Discrete Applied Mathematics, 155,
945–970.
Leung, J. Y. T., Li, H., & Pinedo, M. (2008). Scheduling orders on either dedicated or
flexible machines in parallel to minimize total weighted completion time. Annals of
Operations Research, 159, 107–123.
Leung, J. Y. T., Li, H., Pinedo, M., & Zhang, J. (2007b). Minimizing total weighted
completion time when scheduling orders in a flexible environment with uniform
machines. Information Processing Letters, 103, 119–129.
Lin, W.-C., Yin, Y., Cheng, S. R., Cheng, T. C. E., Wu, C. H., & Wu, C.-C. (2017). Particle
swarm optimization and opposite-based particle swarm optimization for two-agent
multi-facility customer order scheduling with ready times. Applied Soft Computing, 52,
877–884.
Lourenco, H. R., Martin, O. C., & Stutzle, T. (2010). Iterated local search: framework and
applications. In M. Gendreau, J. -Y. Potvin (eds.), Ch12 in Handbook of Metaheuristics.
Msakni, M. K., Khallouli, W., Al-Salem, M., & Ladhari, T. (2016). Minimizing the total
completion time in a two-machine flowshop problem with time delays. Engineering
Optimization, 48(7), 1164–1181.
Nawaz, M., Enscore, E. E., Jr., & Ham, I. (1983). A heuristic algorithm for the m-machine,
n-job ow-shop sequencing problem. Omega, 11(1), 91–95.
Pan, Q.-K., & Ruiz, R. (2014). An effective iterated greedy algorithm for the mixed no-idle
permutation flowshop scheduling problem. Omega, 44(1), 41–50.
Poli, R. (2007). An analysis of publications on particle swarm optimisation applications.
Technical Report CSM-469UK: Department of Computer Science, University of Essex.
163
Computers & Industrial Engineering 117 (2018) 152–163
Poli, R. (2008). Analysis of the publications on the applications of particle swarm opti-
misation. Journal of Artificial Evolution and Applications, 2008, 1–10.
Ribas, I., Companys, R., & Tort-Martorell, X. (2011). An iterated greedy algorithm for the
flowshop scheduling problem with blocking. Omega, 39(3), 293–301.
Ruiz, R., & Stützle, T. (2007). A simple and effective iterated greedy algorithm for the per-
mutation flowshop scheduling problem. European Journal of Operational Research,
177(3), 2033–2049.
Ruiz, R., & Stützle, T. (2008). An Iterated Greedy heuristic for the sequence dependent
setup times flowshop problem with makespan and weighted tardiness objectives.
European Journal of Operational Research, 187(3), 1143–1159.
Shi, Y. & Eberhart, R. C. (1998). A modified particle swarm optimizer. In Proceedings of
IEEE international conference on evolutionary computation (pp. 69–73).
Smith, W. E. (1956). Various optimizers for single state production. Naval Research
Logistic Quarterly, 3, 59–66.
Sung, C. S., & Yoon, S. H. (1998). Minimizing total weighted completion time at a pre-
assembly stage composed of two feeding machines. International Journal of Production
Economics, 54, 247–255.
Van Wassenhove, L. N., & Gelders, F. (1980). Solving a bicriterion scheduling problem.
European Journal of Operational Research, 4, 42–48.
Wagneur, E., & Sriskandarajah, C. (1993). Open shops with jobs overlap. European Journal
of Operational Research, 71, 366–378.
Wang, G. & Cheng, T. C. E. (2003) Customer order scheduling to minimize total weighted
completion time. In Proceedings of the 1st multidisciplinary conference on scheduling
theory and applications (pp. 409–416).
Wang, Y., Li, X., Ruiz, R., & Sui, S. (2017). An iterated greedy heuristic for mixed no-wait
flowshop problems. IEEE Transactions on Cybernetics. http://dx.doi.org/10.1109/
TCYB.2017.2707067.
Wu, C.-C., Liu, S. C., Zhao, C. L., Wang, S. Z., & Lin, W.-C. (2017). A multi-machine order
scheduling with learning using the genetic algorithm and particle swarm optimiza-
tion. The Computer Journal. http://dx.doi.org/10.1093/comjnl/bxx021.
Xu, J., Wu, C.-C., Yin, Y., Zhao, C. L., Chiou, Y. T., & Lin, W. C. (2016). An order sche-
duling problem with position-based learning effect. Computers & Operations Research,
74, 175–186.
Yang, J. (2005). The complexity of customer order scheduling problems on parallel
machines. Computers & Operations Research, 32, 1921–1939.
Yang, J., & Posner, M. E. (2005). Scheduling parallel machines for the customer order
problem. Journal of Scheduling, 8, 49–74.