Computers & Industrial Engineering 67 (2014) 36–43

Contents lists available at ScienceDirect

Computers & Industrial Engineering

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

An improved heuristic to minimize total flow time for scheduling

in the m-machine no-wait flow shop
Dipak Laha ⇑, Sagar U Sapkal
Mechanical Engineering Department, Jadavpur University, Kolkata 700032, India

a r t i c l e i n f o a b s t r a c t

Article history: In this paper, we present a constructive heuristic to minimize total flow time criterion for the well-known
Received 14 January 2012 NP-hard no-wait flow shop scheduling problem. It is based on the assumption that the priority of a job in
Received in revised form 20 May 2013 the initial sequence is given by the sum of its processing times on the bottleneck machines. The initial
Accepted 26 August 2013
sequence of jobs thus generated is further improved using a new job insertion technique. We show,
Available online 8 October 2013
through computational experimentation, that the proposed method significantly outperforms the best-
known heuristics while retaining its time complexity of O(n2). Statistical tests of significance are used
Keywords:
to confirm the improvement in solution quality.
No-wait flow shop
Scheduling
Ó 2013 Elsevier Ltd. All rights reserved.
Heuristic
Total flow time
Optimization

1. Introduction food processing industry, the canning operation immediately fol-

No-wait or continuous flow shop scheduling (Gupta, 1976; Wis-
mer, 1972) deals with scheduling a set of n jobs where each job is
processed continuously through m machines in the same order as
per the technological requirement of the process, that is, once a job
is started on the first machine, it has to be continuously processed
through m machines without interruption. The no-wait flow shop
situation arises due to the processing characteristics of a product
where each process follows immediately the previous one. There-
fore, when needed, the start of a job on the first machine must
be delayed in order to meet the no-wait requirement.
No-wait flow shops find its wide applications in many indus-
tries and real-life situations, particularly in process industries
when the product is hot while processing. Some typical applica-
tions of this problem are frequently encountered in chemical and
pharmaceutical processing, metal processing, and hot rolling
industries (Framinan & Nagano, 2008) as well as in electronic
industry particularly in printed circuit board manufacturing (Ara-
ujo & Nagano, 2010; Nagano, Silva, & Lorena, 2012). For example,
in steel industry, the heated metal continuously moves through a
sequence of operations before it is allowed to cool in order to pre-
vent the defects in the composition of the product. Similarly, in
case of chemical industry, the plastic product requires a series of
processes to immediately follow one another in order to prevent
degradation (Ribeiro Filho, Nagano, & Lorena, 2007). Also, in the
⇑ Corresponding author. Tel.: +91 33 24572842; fax: +91 33 24146890.
E-mail address: dipaklaha_jume@yahoo.com (D. Laha).
lows the cooking operation to ensure freshness (Framinan, Nagano,
& Moccellin, 2010). Apart from these traditional industries, addi-
tional applications can be found in advanced manufacturing envi-
ronments, such as just-in-time, flexible manufacturing systems,
and robotic cells. A detailed survey of the methods and applica-
tions of these scheduling problems is given by Hall and Sriskand-
arajah (1996).
The no-wait flow shop scheduling problems with more than
two machines belong to the class of NP-hard (Papadimitriou &
Kanellakis, 1980; Röck, 1984) and exhaustive enumeration of all
n! sequences is computationally prohibitive. Therefore, heuristic
procedures due to their polynomial time complexity are preferred
as the most suitable optimization methods to solve these schedul-
ing problems, especially involving a large number of jobs. Heuris-
tics for the no-wait flow shop scheduling problems can be
broadly classified into two categories based on their polynomial
time complexity: constructive heuristic and metaheuristic. An effi-
cient constructive heuristic is constructed with the complexity of
O(n2) or at most O(n3) whereas the complexity of a metaheuristic
is normally much higher than that of the constructive method
and also difficult to compute complexity due to its probabilistic
characteristic. Various researchers have developed constructive
heuristics as well as metaheuristics for solving these problems,
with two commonly used optimization (minimization) criteria as
makespan (or maximum completion time) and total flow time
(TFT). It may be noted that the criterion of the total completion
time (or sum of the completion times of the jobs in the schedule)
is equivalent to the criterion of the TFT for the problem under study

0360-8352/$ - see front matter Ó 2013 Elsevier Ltd. All rights reserved.
http://dx.doi.org/10.1016/j.cie.2013.08.026
 D. Laha, S.U Sapkal / Computers & Industrial Engineering 67 (2014) 36–43 37

since we assume that the release times of the jobs are all zeros. For machines in the same technological order without preemption
no-wait flow shop scheduling problems, noteworthy heuristics and interruption on or between any two consecutive machines.
with the TFT criterion have been studied by Rajendran and Chaudh- The problem is to determine a sequence of n jobs that minimizes
uri (1990), Bertolissi (2000), Aldowaisan and Allahverdi (2004), the total flow time criterion.
and Framinan et al. (2010). On the other hand, metaheuristics on Let r = {r1, r2, . . . , rn} represent the sequence of n jobs to be pro-
TFT criterion include genetic algorithm (Chen, Neppalli, & Aljaber, cessed on m machines, and d(i, k) the minimum delay on the first
1996), simulated annealing (Fink & Voß, 2003), artificial immune machine between the start of job i and the start of job k (required
system (Kumar, Prakash, Shankar, & Tiwari, 2006), and particle because of the no-wait restriction). Also, let p(ri, j) represent the
swarm optimization (Pan, Tasgetiren, & Liang, 2008). processing time on machine j of the job in the ith position of a gi-
Rajendran and Chaudhuri (1990) proposed two constructive ven sequence, and let d(ri1, ri) denote the minimum delay on the
heuristics considering two heuristic preference relations as the ba- first machine between the start of two consecutive jobs found in
sis for selecting the initial sequence of jobs. The initial sequence of the (i  1)th and ith position of the sequence. Let C(ri) be the com-
jobs thus generated is then improved further by using the job pletion time of the job in the ith position of a given sequence.
insertion method of NEH (Nawaz, Enscore, & Ham, 1983) in the For i = 1, 2, . . . , n and j = 1, 2, . . . , m
remaining steps of the heuristics. Their heuristics, especially heu-
X
m
ristic 1 performs significantly better than those of Bonney and Cðr1 Þ ¼ pðr1 ; jÞ ð1Þ
Gundry (1976), and King and Spachis (1980). j¼1
Bertolissi (2000) presented a constructive heuristic based on cal- X
m
culating the minimum apparent flow time of each pair of jobs and Cðr2 Þ ¼ dðr1 ; r2 Þ þ pðr2 ; jÞ ð2Þ
then finding the number of times (here, marks) of the starting jobs j¼1

of the pairs as a basis for selecting the initial sequence of jobs. The ..
.
initial sequence thus obtained is then upgraded further using the
job insertion algorithm in the same manner as done by Rajendran X
i X
m
Cðri Þ ¼ dðrk1 ; rk Þ þ pðri ; jÞ ð3Þ
and Chaudhuri (1990). The computational results reveal that the
k¼2 j¼1
Bertolissi heuristic performs better than the heuristics of Rajendran
and Chaudhuri (1990), and Bonney and Gundry (1976). Therefore, TFT of the sequence of n jobs in the no-wait flow shop
Aldowaisan and Allahverdi (2004) proposed six improved heu- scheduling is given by
ristics by making use of NEH (1983) heuristic, Rajendran and Zie-
X
n
gler (1997) heuristic, and the pair-wise neighborhood method to TFT ¼ Cðri Þ
their proposed initial sequence algorithm. They have shown that i¼1
their heuristics, especially the PH1(p) heuristic performs signifi- ( )
X
n Xi X
m X
m
cantly better than the heuristics of Rajendran and Chaudhuri ¼ dðrk1 ; rk Þ þ pðri ; jÞ þ pðr1 ; jÞ
(1990) and the genetic algorithm by Chen et al. (1996). However, i¼2 k¼2 j¼1 j¼1

the heuristics of Aldowaisan and Allahverdi (2004) require more X

n X
n X
m

computational times compared to the existing methods. ¼ ðn þ 1  iÞdðri1 ; ri Þ þ pði; jÞ ð4Þ

Recently, Framinan et al. (2010) developed a constructive heu-
ristic firstly generating an initial sequence of jobs based on com-
paring total flow times of pair of jobs and then improving the
initial sequence by job insertion and job exchange neighborhood
methods. They have shown the superiority of their heuristic over
the heuristics of Rajendran and Chaudhuri (1990), the heuristic
of Bertolissi (2000), the Chins and Pilot-1-Chins heuristics of Fink
and Voß (2003), and the PH1(p) heuristic of Aldowaisan and Allah-
verdi (2004). However, the heuristic of Framinan et al. (2010) takes
much larger computational times compared to those given by the
existing popular heuristics.
Therefore, based on the literature review, it is found that the
PH1(p) heuristic by Aldowaisan and Allahverdi (2004) and the heu-
ristic by Framinan et al. (2010) are the currently best-known heu-
ristics on TFT criterion in no-wait flow shop scheduling problems.
In this paper, we propose a constructive heuristic for minimiz-
ing the TFT which is based on the assumption that the priority of a
job in the sequence is given by the sum of its processing times on
the bottleneck machines and compare with the PH1(p) heuristic
(2004) and the heuristic of Framinan et al. (2010).
The remainder of this paper is organized as follows: Section 2 pro-
vides the description of the problem formulation. Section 3 briefly dis-
cusses the best-known heuristics. The proposed method is presented
in Section 4. Section 5 shows the comparative experimental results,
and finally, concluding remarks are made in Section 6.
2. The problem formulation
Given the processing time p(i, j) of job i on machine j in the
no-wait flow shop scheduling, each of n jobs is processed on m
i¼2 i¼1 j¼1
The delay matrix of n  n provides all the d(i, k) values between
the start of any two consecutive jobs i and k (i – k) in a given se-
quence of n jobs to determine the objective function value. The de-
lay matrix of the d(i, k) values as given by Bertolissi (2000) is
obtained from the following equation:
!
X
r X
r1
dði; kÞ ¼ pði; 1Þ þ max pði; hÞ  pðk; hÞ; 0 with 2 6 r 6 m ð5Þ
h¼2 h¼1
3. The existing heuristics
In this paper, we will consider following two best-known heu-
ristics with the objective of minimizing TFT in the generic no-wait
flow shop scheduling for comparative analysis: The heuristic of
Aldowaisan and Allahverdi (2004) and the heuristic of Framinan
et al. (2010). A brief discussion of the main contribution of these
heuristics is given below.
3.1. Aldowaisan and Allahverdi heuristics (2004)
They proposed six improved heuristics, namely, PH1, PH1(p),
PH3, PH3(p), PH4, and PH4(p) for the no-wait flow shop scheduling
on TFT criterion. These heuristics have an initial stage of construct-
ing a sequence of jobs, followed by an improvement phase by mak-
ing use of NEH (1983) insertion heuristic, Rajendran and Ziegler
(1997) insertion heuristic and the adjacent pair-wise neighbor-
hood method. They have shown that the PHi(p) heuristics perform
better than PHi for i = 1, 3, and 4; and that PH1(p) gives the best er-
38 D. Laha, S.U Sapkal / Computers & Industrial Engineering 67 (2014) 36–43

ror performance amongst all six heuristics. The procedural steps of
the PH1(p) heuristic are described below:
Step 1: Set k = 2, r1 = {all jobs}, r2 = U.
Pm Pm
Step 2: Select job i such that j¼1 pði; jÞ 6 j¼1 pðr; jÞ for 8r.
Remove job i from r1 and place it in the first position of r2.
Step 3: If k = n, go to step 5; otherwise calculate TFT for each job
i 2 r1 after inserting it in position k of r2 and assign the job with
minimum TFT in position k in r2 and remove it from r1; set
k = k + 1.
Step 4: Return to step 3.
Step 5: The best sequence r2 obtained is taken as the initial
sequence and set ro = r2.
Step 6: Let To be the TFT value of the sequence ro. Set Tb = To,
rb = ro, r = 1.
Step 7: Apply NEH (1983) method to the sequence rr1 to pro-
duce rr and calculate Tr.
Step 8: If Tr < Tb, set Tb = Tr and rb = rr.
Step 9: Update r = r + 1. If r > 10, accept the best sequence as rb,
otherwise return to step 7.
Step 10: For k = 1 to (n  1), apply an adjacent pair-wise neigh-
borhood method by exchanging the position of jobs k and
(k + 1) to the sequence rb obtained so far to obtain (n-1)
sequences. If the best sequence among them is better than rb,
accept it as rb.
Step 11: Output the sequence rb as the final solution.
3.2. Framinan et al. heuristic (2010)
Framinan et al. (2010) used a similar concept of distance matrix
as in the heuristic by Bertolissi (2000) for generating an initial job
sequence of two jobs by comparing pairs of all jobs and then to im-
prove the sequence of jobs using both insertion and swap neigh-
borhood techniques. The steps of the heuristic are as follows:
Step 1: Set the current sequence of jobs r = U.
Step 2: Compare the flow times for each pair of jobs i, k
(i = 1, 2, . . . , n; k = 1, 2, . . . , n; i – k) by using the equation
P
Fði; kÞ ¼ 2pði; 1Þ þ m j¼2 pði; jÞ þ RmðikÞ , where Rm(ik) is recursively
P
computed as RmðikÞ ¼ pðk; mÞ þ maxðRm1ðikÞ ; m r¼2 pði; rÞÞ, and
R1ðikÞ ¼ pðk; 1Þ.
Step 3: Select the pair of jobs p, q for which the TFT is minimum,
i.e., Fðp; qÞ 6 Fði; kÞ8i; k: Set the two first positions of the partial
sequence r to p and q i.e., r1 = p and r2 = q.
Step 4: Set i = 2.
Step 5: Obtain a job r not in r such that Fðri ; rÞ 6 Fðri ; kÞ8k and
append job r to r. Insert each job of the sequence r into its rest
possible positions and compute the flow time of the generated
sequences. Among all the sequences obtained, select the best
one as the new sequence r0 . Next, interchange each job of the

Table 1
Performance comparison of the existing heuristics and the proposed method.

n m No. of problem ARPD Percent best

instances
PH1(p) Framinan et al. Proposed PH1(p) Framinan et al. Proposed
(2004) (2010) method (2004) (2010) method
10 5 30 0.7858 0.3492 0.2838 40 63 70
10 30 0.8254 0.3301 0.1136 33 63 83
15 30 0.2271 0.4037 0.2380 63 47 73
20 30 0.4951 0.2648 0.1442 50 67 73
25 30 0.5645 0.2814 0.0664 43 67 83
20 5 30 1.2347 0.3659 0.3953 10 40 63
10 30 1.0025 0.6560 0.2583 13 23 67
15 30 1.0076 0.6787 0.4630 17 33 53
20 30 0.6555 0.5314 0.2924 17 43 47
25 30 1.0893 0.6334 0.2712 10 40 53
30 5 30 2.0341 0.5917 0.3635 13 33 57
10 30 1.2078 0.5123 0.3444 7 37 57
15 30 1.1566 0.6515 0.3707 3 33 67
20 30 1.1745 0.8535 0.1896 7 23 70
25 30 1.0872 1.0842 0.1297 13 20 67
40 5 30 1.8608 0.3171 0.6132 10 53 37
10 30 1.483 0.5825 0.3068 7 37 57
15 30 1.1391 0.6505 0.2590 17 27 57
20 30 1.1314 0.9671 0.2779 23 20 57
25 30 0.9793 0.8942 0.2672 23 23 53
50 5 30 2.1223 0.4305 0.6335 7 57 37
10 30 1.3058 0.7778 0.1574 10 23 67
15 30 0.8823 0.6538 0.1994 10 27 63
20 30 1.0536 0.8288 0.2547 13 27 60
25 30 1.0206 1.0235 0.1245 7 17 77
60 5 30 1.9074 0.2260 0.4952 3 67 30
10 30 1.2919 0.7015 0.1762 3 23 70
15 30 1.1370 0.7222 0.1581 13 20 70
20 30 1.3150 0.8647 0.2480 7 20 73
25 30 1.0043 0.9403 0.1442 17 7 77
70 5 30 2.3682 0.2672 0.6016 0 60 40
10 30 1.5219 0.6698 0.2113 3 23 77
15 30 1.2901 0.6196 0.1079 3 23 70
20 30 1.3530 1.1710 0.0941 13 10 77
25 30 1.1107 0.8472 0.2115 3 20 77
Average 1.1950 0.6384 0.2705 24 35 63
 D. Laha, S.U Sapkal / Computers & Industrial Engineering 67 (2014) 36–43 39

Table 2
Results of statistical tests (PH1(p) (2004) versus proposed method).

n m No. of problem instances PH1(p) (2004) versus proposed method

TFT difference t p-Value
Mean Std. dev.
10 5 30 25.8 63.2 2.23 0.017
10 30 60.2 105.8 3.11 0.002
15 30 1.2 66.4 0.10 0.539
20 30 53.1 128.2 2.27 0.015
25 30 87.8 160.9 2.99 0.003
20 5 30 131.8 243.8 2.96 0.003
10 30 183.9 292.3 3.45 0.001
15 30 173.6 464.1 2.05 0.025
20 30 144.7 300.5 2.64 0.007
25 30 374.1 540.8 3.79 0.000
30 5 30 562.2 496 6.21 0.000
10 30 414.5 453 5.01 0.000
15 30 484 670 3.96 0.000
20 30 722 769 5.14 0.000
25 30 817 864 5.18 0.000
40 5 30 702 708 5.43 0.000
10 30 932 773 6.61 0.000
15 30 872 1089 4.39 0.000
20 30 993 1264 4.31 0.000
25 30 963 1453 3.63 0.001
50 5 30 1234 1261 5.36 0.000
10 30 1339 1345 5.46 0.000
15 30 979 1371 3.91 0.000
20 30 1362 1745 4.27 0.000
25 30 1730 2047 4.63 0.000
60 5 30 1638 1368 6.56 0.000
10 30 1824 1523 6.56 0.000
15 30 1953 1858 5.76 0.000
20 30 2496 1900 7.20 0.000
25 30 2263 2670 4.64 0.000
70 5 30 2754 1615 9.34 0.000
10 30 2829 2282 6.79 0.000
15 30 3095 2050 8.27 0.000
20 30 3815 3213 6.50 0.000
25 30 3097 3734 4.54 0.000

new sequence r0 with its rest jobs and select the best sequence
r0 among the generated sequences. Set r = r0 .
Step 6: Update i = i + 1.
Step 7: If i = n, accept the best sequence as the final solution,
otherwise return to step 5.
4. The proposed heuristic
The shortest processing time (SPT) rule optimizes the mean flow
time of a set of jobs processing on single machine (Haupt, 1989;
Ho, 1995; Ramasesh, 1990) and also, it has been shown to be effec-
tive in m-machine flow shop scheduling (Rajendran & Holthaus,
1999). Based on this idea, we make similar attempt to obtain a se-
quence of jobs considering bottleneck machines (Kalir & Sarin,
2001; Rajendran & Alicke, 2007), which is used as a basis for select-
ing the initial sequence of the proposed method. The proposed
method is based on the assumption that the priority of a job in
the initial sequence is given by the sum of its processing times
on the bottleneck machines. This initial sequence is further im-
proved by a job insertion heuristic.
The proposed heuristic is given as follows:
Step 1: Set z = 1. Consider single bottleneck machine among m
machines with the largest sum of the processing times of n jobs
and determine the sequence of jobs by arranging them in
ascending order of their processing times on it. The tie is broken
arbitrarily if there are more than one single bottleneck
machines.
Step 2: For z = 2 to m do the following.
Consider z adjacent machines as bottlenecks with largest sum
of the processing times of jobs on these machines and obtain
the sequence of jobs in ascending order of the sum of the pro-
cessing times of the individual jobs on these machines. The
tie is broken arbitrarily if there are more than one set of z bot-
tleneck machines.
Step 3: A total of m sequences of jobs are generated from steps 1
and 2 and the best one is selected as the initial sequence of jobs
for the remaining steps of the heuristic.
Step 4: Set r = 1.
Step 5: Set k = 1. Select the first two jobs from the initial
sequence. Obtain the better of the two 2-job partial sequences
and consider it the current sequence.
Step 6: Set k = k + 1. Generate partial sequences, each of 2k jobs,
by inserting the next two (i.e., the kth pair of) jobs as a block
(i.e., without changing the relative positions of jobs while
selecting) from the initial sequence into each of the (2k – 1)
possible positions of the current sequence. Select the best par-
tial sequence as the current sequence (the current sequence
now has 2k jobs). Next, the first job of the kth pair is placed into
all possible positions of the current sequence, producing (2k –
40 D. Laha, S.U Sapkal / Computers & Industrial Engineering 67 (2014) 36–43

Table 3
Results of statistical tests (Framinan et al. (2010) versus proposed method).

n m No. of problem instances Framinan et al. (2010) versus proposed method

TFT difference t p-Value
Mean Std. dev.
10 5 30 2.5 60.8 0.23 0.411
10 30 18.3 66.7 1.50 0.072
15 30 18.6 93.3 1.09 0.142
20 30 18.0 107.5 0.92 0.183
25 30 37.8 97.4 2.13 0.021
20 5 30 5.2 139.9 0.20 0.579
10 30 97.3 268.5 1.99 0.028
15 30 70.3 388.2 0.99 0.165
20 30 92.0 415.0 1.21 0.117
25 30 166.1 481.4 1.89 0.034
30 5 30 77.9 387.7 1.10 0.14
10 30 79.1 477.8 0.91 0.186
15 30 174 743 1.29 0.104
20 30 483 682 3.88 0.000
25 30 813 927 4.81 0.000
40 5 30 161 598 1.48 0.925
10 30 217 752 1.58 0.062
15 30 386 926 2.28 0.015
20 30 799 1561 2.80 0.004
25 30 847 1258 3.69 0.000
50 5 30 179 993 0.99 0.834
10 30 721 1118 3.53 0.001
15 30 649 1121 3.17 0.002
20 30 982 1628 3.30 0.001
25 30 1737 1684 5.65 0.000
60 5 30 326 966 1.85 0.963
10 30 850 1492 3.12 0.002
15 30 1127 1500 4.12 0.000
20 30 1439 2609 3.02 0.003
25 30 2100 2122 5.42 0.000
70 5 30 523 1640 1.75 0.954
10 30 985 2027 2.66 0.006
15 30 1334 2136 3.42 0.001
20 30 3274 2498 7.18 0.000
25 30 2179 3210 3.72 0.000

1.4
set of (2k – 1) partial sequences. If the best of these (2k – 1) par-
1.2 tial sequences is better than the current sequence, use that to
update the current sequence.
95% CI RPD

1.0 Step 7: Repeat step 6 until all jobs are scheduled. If, after pairing
off the jobs taken from the initial sequence, a single job is still
0.8 available to be scheduled, consider it as a block.
Step 8: For i = 1 to (n  1) do the following.
0.6 Insert the ith job of the n-job current sequence into (n  i) pos-
sible positions in forward direction, thereby producing (n  i)
0.4
sequences.
Step 9: A total of n(n  1)/2 sequences are generated in step 8. If
0.2
the best among these sequences yields lower TFT than that of
PH1(p) Framinan et al. Proposed
the current sequence, use it to update the current sequence
Heuristic
and consider as the initial sequence, otherwise consider the
Fig. 1. Means and 95% confidence intervals for the different algorithms. unchanged current sequence as the initial sequence and go to
step 10.
Step 10: If r < 10, set r = r + 1 and return to step 5; otherwise,
stop. Output the best current sequence and its TFT as the final
1) partial sequences. If the best of these (2k – 1) partial solution.
sequences is better than the current sequence, set that as the
current sequence, otherwise the current sequence remains To illustrate the working of the proposed method, let us con-
unaltered. The second job of the kth pair is then placed in all sider the following five jobs, five machines no-wait flow shop prob-
possible positions of the current sequence, producing another lem instance.
 D. Laha, S.U Sapkal / Computers & Industrial Engineering 67 (2014) 36–43 41

is therefore set as the current sequence. Following the next part of

Machines step 6, job 5 (which is the first job of the most recent pair) is in-
1 2 3 4 5 serted into each of the three available positions of {3 2 5 1}, and
as a result, three sequences {5 3 2 1}, {3 5 2 1}, {3 2 1 5} with respec-
Jobs 1 2 5 6 8 7
tive TFTs 164, 136 and 137 are generated. Since none of these three
2 3 7 2 10 4
is better than the current partial sequence, the current sequence
3 1 2 7 6 3
remains unchanged. Next, job 1 (the second job of the most recent
4 4 9 5 7 8
pair) is inserted into each of the three available positions of
5 6 8 4 5 6
{3 2 5 1}, producing three sequences {1 3 2 5}, {3 1 2 5}, and {3 2 1 5}
with respective TFTs 150, 133, and 137. {3 1 2 5} is the best partial
sequence and is therefore updated as the current sequence.
Next, for k = 3, the single remaining job 4 from the initial se-
The delay matrix of d(i, k) values for the given problem are com- quence is appended to the current sequence {3 1 2 5} at five possi-
puted by using Eq. (5) and is shown below. ble positions, producing {4 3 1 2 5}, {3 4 1 2 5}, {3 1 4 2 5}, {3 1 2 4 5},
and {3 1 2 5 4}. The corresponding TFTs are 234, 197, 186, 196,
Jobs and 192 respectively. Among these sequences, {3 1 4 2 5} is the best
1 2 3 4 5
Jobs 1 – 9 12 3 5
Table 5
2 9 – 12 6 4 CPU time (in seconds) of various heuristics.
3 3 4 – 1 1
n m PH1(p) (2004) Framinan et al. (2010) Proposed method
4 12 13 17 – 10
5 12 11 15 10 – 10 5 0.000 0.000 0.000
10 0.000 0.000 0.000
15 0.000 0.000 0.000
20 0.002 0.002 0.002
According to step 1, we first consider the single bottleneck machine 25 0.002 0.002 0.002

as machine 4 with the maximum sum of processing times of jobs on 20 5 0.002 0.004 0.004
it. Then, arranging the jobs in increasing order of their processing 10 0.002 0.004 0.004
15 0.004 0.006 0.006
times on this machine, we get the sequence as {5 3 4 1 2} and the 20 0.006 0.008 0.008
corresponding TFT is 231. Following step 2 (for z = 2), we consider 25 0.006 0.010 0.010
two adjacent machines as bottlenecks as machines 4 and 5 among 30 5 0.006 0.012 0.008
four possible pairs of machines, and the jobs are arranged in 10 0.008 0.018 0.014
increasing order of the sum of processing times of individual jobs 15 0.012 0.028 0.020
to obtain the sequence as {3 5 2 1 4} with the corresponding TFT of 20 0.016 0.038 0.028
25 0.020 0.046 0.032
193. For z = 3, considering the three bottleneck machines and
arranging the jobs in increasing order of sum of processing times 40 5 0.012 0.036 0.018
10 0.018 0.062 0.032
of individual jobs, we determine the sequence {3 5 1 2 4} with the
15 0.028 0.088 0.046
corresponding TFT of 199. Similarly, for z = 4, considering four bot- 20 0.036 0.114 0.062
tleneck machines, the sequence {3 2 5 1 4} is obtained and its corre- 25 0.044 0.142 0.076
sponding TFT is 190. Finally, for z = 5, using five bottleneck 50 5 0.022 0.086 0.034
machines, the sequence {3 2 1 5 4} is obtained and its corresponding 10 0.036 0.148 0.062
TFT is 198. Thus, according to step 3, for the five-machine no-wait 15 0.052 0.212 0.088
flow shop problem, out of 5 generated sequences (using steps 1– 20 0.066 0.276 0.117
25 0.084 0.339 0.142
2), the best sequence {3 2 5 1 4} is selected as the initial sequence
of jobs with the TFT as 190. 60 5 0.036 0.178 0.060
10 0.060 0.305 0.103
Using step 5 (for k = 1), we select first two jobs (3 and 2) from 15 0.086 0.437 0.149
the initial sequence and obtain the best sequence {3 2} with TFT 20 0.112 0.569 0.199
49 from two possible sequences. Consider it as the current 25 0.138 0.701 0.239
sequence. 70 5 0.058 0.329 0.096
Now, using step 6 (for k = 2), we insert the next pair of jobs (5 10 0.096 0.567 0.165
and 1) as a block from the initial sequence into the current se- 15 0.134 0.808 0.235
20 0.172 1.048 0.313
quence {3 2} at the three possible positions, yielding the sequences
25 0.216 1.293 0.375
{5 1 3 2}, {3 5 1 2}, and {3 2 5 1} with TFTs 166, 138, and 134 respec-
Average 0.0455 0.2262 0.0785
tively. {3 2 5 1} is the best partial sequence among these three and

Table 4
Results of Tukey honestly significant difference tests.

Heuristic (I) Heuristic (J) Mean difference (I–J) SE Significance

PH1(p) Framinan et al. 0.5566* 0.052454 0.000
Proposed 0.9245* 0.052454 0.000
Framinan et al. PH1(p) 0.5566* 0.052454 0.000
Proposed 0.3679* 0.052454 0.000
Proposed PH1(p) 0.9245* 0.052454 0.000
Framinan 0.3679* 0.052454 0.000
*
Mean difference is significant at the 0.05 level (95%).
42 D. Laha, S.U Sapkal / Computers & Industrial Engineering 67 (2014) 36–43
current sequence with corresponding TFT 186 and is further im-
proved using an insertion technique in step 8.
Using step 8, the first job, i.e. job 3 is inserted into each possible
position of {3 1 4 2 5} in forward direction to get the sequences as
{1 3 4 2 5}, {1 4 3 2 5}, {1 4 2 3 5}, and {1 4 2 5 3} with TFTs 216, 210,
211, and 209 respectively. Next, job 1 is inserted at each possible
position in forward direction, producing the sequences {3 4 1 2 5},
{3 4 2 1 5}, and {3 4 2 5 1} with respective TFTs 197, 201, and 198.
Similarly, jobs 4 and 2 are inserted at each possible position in for-
ward direction, and as a result, {3 1 2 4 5 }, {3 1 2 5 4}, and {3 1 4 5 2}
with respective TFTs 196, 192, and 187 are generated. Since none
of these generated sequences is better than the current sequence,
the current sequence {3 1 4 2 5} with TFT 186 remains unaltered
and is used for further processing till r = 10 iterations (as stated
in step 10) are completed. Hence, the final sequence is {3 1 4 2 5}
with TFT 186.
Regarding the computational complexity of the proposed meth-
od, the total number of enumerations (partial and complete) gen-
Pn=2 Pbn=2c
erated is equal to
k¼2 3ð2k  1Þ for even n and k¼2 3ð2k  1Þ
2
for odd n. So, its complexity is approximately O(n ). The complex-
ity of the heuristic by Framinan et al. (2010) is clearly dictated by
step 5, which can be executed in O(n3). Therefore, the complexity of
Framinan et al. heuristic is O(n3). Similarly, the complexity of
PH1(p) (2004) is determined by step 6 where the NEH heuristic is
applied. The total number of enumerations for the NEH heuristic
is nðnþ1Þ
2
 1. Therefore, the complexity of the PH1(p) is O(n2). Thus,
the time complexity of the proposed method is less than that of
Framinan et al. heuristic and is same as that required by the
PH1(p) heuristic.
5. Computational experience
The proposed heuristic, the PH1(p) heuristic of Aldowaisan and
Allahverdi (2004), and the heuristic of Framinan et al. (2010) were
coded in C and run on an Intel Core 2 Duo, 2 GB RAM, 2.93 GHz PC.
To compare the proposed heuristic with the existing heuristics, we
carried out the experimentation by considering problem sizes with
number of jobs (n) = 10, 20, 30, 40, 50, 60, and 70 and number of
machines (m) = 5, 10, 15, 20, and 25. Thirty independent problem
instances were considered for each problem size. Each problem in-
stance corresponds to a new processing time matrix where each
processing time was generated from a uniform random discrete
u(1, 99) distribution, commonly used by researchers (Aldowaisan
& Allahverdi, 2004; Bertolissi, 2000; Framinan et al., 2010; Rajen-
dran & Chaudhuri, 1990).
The following performance measures, popular in the scheduling
literature (Aldowaisan & Allahverdi, 2004; Laha & Sarin, 2009;
Rajendran & Chaudhuri, 1990), are used in the present experimen-
tation: average relative percentage deviation (ARPD), and percent
of best heuristic solutions. ARPD is given by
k  
100 X Heuristici  BestHi
ARPD ¼
k i¼1 BestHi
where Heuristici denotes the objective function value obtained for
ith instance by a heuristic, BestHi is the best solution value obtained
for that instance, and k is the number of problem instances for a
problem size.
Table 1 displays comparative evaluation of the proposed heuris-
tic, the PH1(p) heuristic of Aldowaisan and Allahverdi (2004), and
the heuristic of Framinan et al. (2010) based on the ARPD and the
percent of best heuristic solutions. The results show that average
ARPD of the proposed heuristic is significantly less compared to
the existing methods. With respect to ARPD, the proposed method
performs better than either of the existing methods for 29 out of 35
cases. Also, the performance of the proposed heuristic with respect
to the percent best solution has been found to be superior to the
existing methods.
Next, we use the student’s t test (Kreyszig, 1972) to show the
statistical significance of the better results obtained by the pro-
posed method over those given by PH1(p) heuristic, and Framinan
et al. heuristic. The results of statistical tests for PH1(p) heuristic
versus the proposed heuristic and Framinan et al. heuristic versus
the proposed heuristic are presented in Tables 2 and 3 respectively.
The number of problem instances for each problem size is taken as
30. We test the null hypothesis, H0: l = 0 against alternative
hypothesis, H1: l > 0; i.e., if H0 holds true, then, statistically, the
difference betweenpthe ffiffiffiffi  two methods is not significant. The t-statis-
tic is given as t ¼ N xSl0 , where N is the sample size, N  1 is the
degrees of freedom, l0 = 0, and  x and s denote the mean and stan-
dard deviation of the sample. At 5% level of significance, the critical
value, t0.05,m is obtained from the relation Probability (t P t0.05,m) = -
a = 0.05. Using the standard tables of t-distribution, we obtain,
t0.05,m = 1.699 for m = N  1 = 29 degrees of freedom. We also com-
pare the level of significance with the p-value. The proposed heu-
ristic is statistically better than PH1(p) heuristic and Framinan
et al. heuristic.
In addition to the pairwise comparison of the heuristics, we also
applied multi comparison analysis using Tukey honestly significant
test. For this, to observe the statistical significance of the differ-
ences between the heuristics, the means of each heuristic and
the corresponding 95% confidence interval are plotted as shown
in the Fig. 1. A Tukey honestly significant test is used to determine
which means differ as shown in the Table 4. The results indicate
that the differences between the proposed heuristic and the rest
of the heuristics are statistically significant. Framinan et al. showed
better performance than PH1(p) and proposed heuristic showed
better performance than both the heuristics, PH1(p) (2004) and
Framinan et al. (2010).
The average computational times (in seconds) required for solv-
ing each problem instance by the heuristics are also given in Ta-
ble 5. The results show that the proposed heuristic takes less
computational time than that of the Framinan et al. (2010) heuris-
tic and comparable CPU time as that of the PH1(p) heuristic (2004).
6. Concluding remarks
This paper presented a new deterministic constructive heuristic
for the no-wait flow shop scheduling with the objective of mini-
mizing total flow time. The proposed method is based on the prin-
ciple of the sum of processing times of individual jobs on the
bottleneck machines to determine the initial sequence of jobs,
which is further improved using an insertion technique. Our re-
sults have shown to be statistically significantly better than those
produced by the best deterministic methods known to date, while
maintaining the competitive algorithmic complexity.
References
Aldowaisan, T., & Allahverdi, A. (2004). New heuristics for m-machine no-wait
flowshop to minimize total completion time. Omega, 32, 345–352.
Araujo, D. C., & Nagano, M. S. (2010). An effective heuristic for the no-wait flowshop
with sequence-dependent setup times problem. Lecture Notes in Computer
Science, 6437, 187–196.
Bertolissi, E. (2000). Heuristic algorithm for scheduling in the no-wait flow-shop.
Journal of Materials Processing Technology, 107, 459–465.
Bonney, M. C., & Gundry, S. W. (1976). Solutions to the constrained flowshop
sequencing problem. Operational Research Quarterly, 27, 869–883.
Chen, C., Neppalli, V., & Aljaber, N. (1996). Genetic algorithms applied to the
continuous flow shop problem. Computers and Industrial Engineering, 30,
919–929.
Fink, A., & Voß, S. (2003). Solving the continuous flow-shop scheduling problem by
metaheuristics. European Journal of Operational Research, 151, 400–414.
 D. Laha, S.U Sapkal / Computers & Industrial Engineering 67 (2014) 36–43
Framinan, J. M., & Nagano, M. S. (2008). Evaluating the performance for makespan
minimisation in no-wait flowshop sequencing. Journal of Materials Processing
Technology, 197, 1–9.
Framinan, J. M., Nagano, M. S., & Moccellin, J. V. (2010). An efficient heuristic for
total flowtime minimization in no-wait flowshops. International Journal of
Advanced Manufacturing Technology, 46, 1049–1057.
Gupta, J. N. D. (1976). Optimal flowshop schedules with no intermediate storage.
Naval Research Logistics, 23, 235–243.
Hall, N. G., & Sriskandarajah, C. (1996). A survey of machine scheduling problems
with blocking and no-wait in process. Operations Research, 44, 510–525.
Haupt, R. (1989). A survey of priority rule based scheduling. OR Spektrum, 11, 3–16.
Ho, J. C. (1995). Flowshop sequencing with mean flow time objective. European
Journal of Operational Research, 81, 571–578.
Kalir, A. A., & Sarin, S. C. (2001). A near-optimal heuristic for the sequencing
problem in multiple-batch flow-shops with small equal sublots. Omega, 29,
577–584.
King, J. R., & Spachis, A. S. (1980). Heuristics for flowshop scheduling. International
Journal of Production Research, 18, 343–357.
Kreyszig, E. (1972). Advanced engineering mathematics. New York: Wiley.
Kumar, A., Prakash, A., Shankar, R., & Tiwari, M. K. (2006). Psychoclonal algorithm
based approach to solve continuous flowshop scheduling problem. Expert
Systems with Applications, 31, 504–514.
Laha, D., & Sarin, S. C. (2009). A heuristic to minimize total flow time in permutation
flow shop. Omega, 37, 734–739.
Nagano, M. S., Silva, A. A., & Lorena, L. A. N. (2012). A new evolutionary clustering
search for a no-wait flow shop problem with set-up times. Engineering
Applications of Artificial Intelligence, 25(6), 1114–1120.
43
Nawaz, M., Enscore, E. E., Jr., & Ham, I. (1983). A heuristic algorithm for the m
machine, n job flowshop sequencing problem. Omega, 11(1), 91–95.
Pan, Q. K., Tasgetiren, M. F., & Liang, Y. C. (2008). A discrete particle swarm
optimization algorithm for the no-wait flowshop scheduling problem.
Computers and Operations Research, 35, 2807–2839.
Papadimitriou, C. H., & Kanellakis, P. C. (1980). Flowshop scheduling with limited
temporary storage. Journal of Associate Computer Machinery, 31, 343–357.
Rajendran, C., & Alicke, K. (2007). Dispatching in flowshops with bottleneck
machines. Computers and Industrial Engineering, 52, 89–106.
Rajendran, C., & Chaudhuri, D. (1990). Heuristic algorithms for continuous flow-
shop problem. Naval Research Logistic Quarterly, 37, 695–705.
Rajendran, C., & Holthaus, O. (1999). A comparative study of dispatching rules in
dynamic flowshops and jobshops. European Journal of Operational Research, 115,
156–170.
Rajendran, C., & Ziegler, H. (1997). An efficient heuristic for scheduling in a
flowshop to minimize total weighted flowtime of jobs. European Journal of
Operational Research, 103, 129–138.
Ramasesh, R. (1990). Dynamic jobshop scheduling: a survey of simulation research.
Omega, 18, 43–57.
Ribeiro Filho, G., Nagano, M. S., & Lorena, L. A. N. (2007). Hybrid evolutionary
algorithm for flowtime minimisation in no-wait flowshop scheduling. Lecture
Notes in Computer Science, 4827, 1099–1109.
Röck, H. (1984). The three-machine no-wait flow shop is NP-complete. Journal of
Associate Computer Machinery, 31, 336–345.
Wismer, D. A. (1972). Solution of the flowshop-scheduling problem with no
intermediate queues. Operations Research, 20, 689–697.