- Email: [email protected]
A computational study of the permutation flow shop problem based on a tight lower bound
Computers & Operations Research 32 (2005) 1831 – 1847
www.elsevier.com/locate/dsw
A computational study of the permutation &ow shop problem based on a tight lower bound Talel Ladharia; b , Mohamed Haouaria;∗ a
Laboratory of Mathematical Engineering, Ecole Polytechnique de Tunisie, BP 743, La Marsa 2078, Tunisia b Ecole Sup#erieure des Sciences Economiques et Commerciales, Tunis 1089, Tunisia
Abstract We consider the classical permutation &ow shop problem which requires scheduling n jobs through m machines which are placed in series so as to minimize the makespan. This problem is known to be NP-hard. We describe a branch-and-bound algorithm with a lower bounding procedure based on the so-called two-machine &ow shop problem with time lags, ready times, and delivery times. We present extensive computational results on both random instances, with up to 8000 operations, and well-known benchmarks, with up to 2000 operations, which show that the proposed algorithm solves large-scale instances in moderate CPU time. In particular, we report proven optimal solutions for benchmark problems which have been open for some time. ? 2003 Elsevier Ltd. All rights reserved. Keywords: Scheduling; Permutation &ow shop; Branch-and-bound algorithm
1. Introduction In this paper, we address the Permutation Flow Shop Problem which can be de
Corresponding author.
0305-0548/$ - see front matter ? 2003 Elsevier Ltd. All rights reserved. doi:10.1016/j.cor.2003.12.001
1832
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
exhibit a family of instances for which the value of the optimal permutation √ schedule is worse than that of the optimal nonpermutation schedule by a factor of more than 12 m. However, for the sake of simplicity, we will adhere to a well-established tradition in scheduling theory and restrict our attention solely to permutation schedules. Since the publication of the seminal paper of Johnson [3], the &ow shop problem has become one of the most intensively investigated topics in scheduling theory. This interest is not only motivated by its practical relevance, but also by its deceptive simplicity and challenging hardness. Though, the &ow shop problem is still considered as a very hard nut to crack. Indeed, up to the mid of the 1990s, the best available branch-and-bound algorithms experience diFculty in solving instances with 15 jobs and 4 machines [4, p. 393]. It is interesting to observe that at about the same time, instances of the celebrated traveling salesman problem with few hundreds of vertices could be solved quite routinely. It is well-known that the case of two machines (m = 2), could be easily solved using Johnson’s rule which generates an optimal schedule in O(n log n) time. For m ¿ 3, however, the problem is shown to be strongly NP-hard [5]. Interestingly, one can note that the quest for optimization strategies for the F | prmu | Cmax started about 40 years ago, shortly after the discovery by Land and Doig [6] of the branch-and-bound technique. Indeed, the
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1833
previously implemented by many authors. However, the most innovative aspect of our work lies in the implementation of a (new) tight lower bound that dominates all other previously used ones. Our algorithm has produced proven optimal solutions for a number of (hard) well-known instances with up to 2000 operations (n = 200 and m = 10) that have been open for 10 years, and randomly generated instances with up to 8000 operations (n = 2000 and m = 4). To the best of our knowledge, the solution of such large instances has never been previously reported in the literature. The rest of the paper is structured as follows. Section 2 provides a detailed description of most of the lower bounds that have been used so far. Section 3 describes the proposed branch-and-bound algorithm, including the branching rule, the search strategy, as well as the lower bounding strategy. Computational results are given in Section 4. Finally, some concluding remarks are provided. 2. Lower bounds for the F | prmu | Cmax It is well-known that the quality of the lower bound is one of the most critical components of any branch-and-bound algorithm. Actually, a close examination of the various branch-and-bound algorithms that have been developed so far for the F | prmu | Cmax reveals that the most signi
j ∈J
j ∈J
Hence, a valid lower bound for F | prmu | Cmax is LB1 = max LB1k : 16k 6m
1834
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
LB1 can be computed in O(mn) time. This simple bound has been used by Ignall and Schrage [7], Lomnicki [8], Brown and Lomnicki [9], McMahon and Burton [10], McMahon [27], and Carlier and RebaMN [15]. 2.1.2. LB2 A second relaxation of 1 | rj ; qj | Cmax is obtained by setting for all j ∈ J , qj = minj∈J qkj . This yields for each machine Mk (k = 1; : : : ; m) a lower bound k (J ) + min qkj ; LB2k = Cmax j ∈J
k where Cmax (J ) is the makespan of an optimal solution of the 1 | rj | Cmax problem de
LB2 = max LB2k : 16k 6m
Analogously, we can obtain the symmetric bound of LB2k by setting all release dates to minj∈J rkj and ordering jobs according to nondecreasing delivery times. Obtaining LB2k requires sorting jobs according to their release dates or delivery times. Hence LB2 requires O(mn log n) time. LB2 has been implemented in the branch-and-bound algorithms of Bestwick and Hastings [29] and Ashour [11]. 2.1.3. LB3 A third relaxation of 1 | rj ; qj | Cmax is obtained by allowing preemptive schedules. An optimal makespan of 1 | rj ; qj ; pmtn | Cmax can be found in polynomial time by the Earliest Due Date rule (EDD): at any time schedule an available job with largest delivery time [30]. For each machine Mk (k = 1; : : : ; m) let LB3k denote the makespan of the corresponding optimal preemptive schedule. Clearly, a valid lower bound for F | prmu | Cmax is LB3 = max LB3k : 16k 6m
LB3 is calculated in O(mn log n) time. It has been implemented in the branch-and-bound algorithm of Carlier and RebaMN [15]. 2.1.4. LB4 The fourth lower bound is derived from the computation of the optimal makespan, denoted LB4k , of the 1 | rj ; qj | Cmax on machine Mk (k = 1; : : : ; m). Therefore, a valid lower bound for F | prmu | Cmax is LB4 = max LB4k : 16k 6m
It is noteworthy that although being NP-hard the 1 | rj ; qj | Cmax can be solved eFciently using the branch-and-bound algorithm of Carlier [31]. To the best of our knowledge, LB4 has never been implemented for the F | prmu | Cmax .
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1835
2.2. Two-machine-based lower bound To improve on the one-machine relaxation, a natural step is to use two-machine relaxations. Therefore, lower bounds for the permutation &ow shop problem can be obtained by selecting two diKerent machines Mk and Ml (1 6 k ¡ l 6 m) and relaxing the constraint that each of the other machines can process at most one job at a time. The resulting relaxation is a two-machine permutation &ow shop problem subject to release dates, time lags and delivery times with the objective of minimizing the makespan. This problem is denoted F2 | rj ; lj ; qj ; prmu | Cmax and is obtained by setting for all j ∈ J m l− 1 k −1 pij if l ¡ m; pij if k + 1 ¡ l; pij if k ¿ 1; qj = i=l+1 rj = i=1 lj = i=k+1 0 if l = m: 0 if k = 1; 0 if l = k + 1; By considering various relaxations of this two-machine &ow shop problem the following lower bounds are derived. 2.2.1. LB5 A
j ∈J
kl (J ) is the optimal makespan of the F2 | lj ; prmu | Cmax problem de
LB5 =
max
16k¡l6m
LB5(k; l) :
Clearly, LB5 requires O(m2 n log n) time. This bound has been implemented in the branch-andbound algorithms of McMahon [27], Szwarc [33], Potts [34], Lageweg et al. [12], and Cheng et al. [16]. 2.2.2. LB6 In order to alleviate the computational burden of LB5, one could consider only machine pairs of k the form (Mk ; Mk+1 ) (k = 1; : : : ; m − 1). Let Cmax (J ) denote the optimal makespan of the F2 Cmax problem de
1836
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
F | prmu | Cmax is LB6 =
max
16k 6m−1
min rkj + j ∈J
k Cmax (J )
+ min qk+1; j : j ∈J
LB6 requires O(mn log n) time. It has been used by Nabeshima [35] and Carlier and RebaMN [15]. 2.2.3. LB7 kl∗ Let Cmax (J ) denote the optimal makespan of the F2 | rj ; lj ; qj ; prmu | Cmax problem de
max
16k¡l6m
kl∗ Cmax (J ):
LB7 clearly dominates all previously described lower bounds. Indeed, all other lower bounds are derived from LB7 by relaxing the constraint that one of the two machines can process at most one job at a time, by underestimating the contribution of the release and delivery times, or by allowing preemption. However, contrary to the aforementioned lower bounds (with the exception of LB4), LB7 cannot be computed in polynomial time. Indeed, the NP-hardness of the F2 | rj ; lj ; qj ; prmu | Cmax is an immediate consequence of the NP-hardness of the 1 | rj ; qj | Cmax . Nonetheless, the excellent performance of the branch-and-bound algorithm developed by Haouari and Ladhari [36] for the F2 | rj ; lj ; qj ; prmu | Cmax problem, motivated us to investigate the use of this lower bound for solving the F | prmu | Cmax . Our computational experiments provide evidence that embedding a lower bound based on the exact solution of the F2 | rj ; lj ; qj ; prmu | Cmax problem yields a highly eKective optimization algorithm.
3. Description of the branch-and-bound algorithm In this section we provide a detailed description of our branch-and-bound algorithm. Notation. With each node N of the search tree we associate the following data: JP rkj qkj pkj lkl j ∗ Cmax 1 2 k Ci lev(N )
the set of unscheduled jobs release date of job j (j ∈ JP ) on machine Mk (k = 1; : : : ; m) delivery time of job j (j ∈ JP ) on machine Mk (k = 1; : : : ; m) processing time of job j (j ∈ JP ) on machine Mk (k = 1; : : : ; m) minimum amount of time between the completion time of job j (j ∈ JP ) on machine Mk and its start on machine Ml (1 6 k ¡ l 6 m) the current best upper bound on the optimal makespan a partial sequence of n1 jobs scheduled on the top of the global sequence a partial sequence of n2 (n2 6 n−n1 ) jobs scheduled on the bottom of the global sequence the minimal completion time of i (i = 1; 2) on the machine Mk (k = 1; : : : ; m) level of node N (lev(N ) = n1 + n2 )
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
LB(N ) Np D(Np ) Nc
1837
a lower bound of the optimal makespan of a sequence where the jobs of subset JP are scheduled after the completion of subsequence 1 and before the start of the subsequence 2 the parent node of N the set of candidate nodes descendant of Np ∗ the closest unbranched node to N , such that LB(Nc ) ¡ Cmax
3.1. Branching scheme, search strategy, and upper bound We implemented the following branching rule. The
for k = m − 1; : : : ; 1:
In order to take into account the availability of the machines, we update for each job j ∈ JP its release date and delivery time on each machine Mk (k = 1; 2; : : : ; m) as follows: r1j = C11 ; rkj = max(Ck1 ; rk −1; j + pk −1; j )
for k = 2; : : : ; m;
qmj = Cm2 ; qkj = max(Ck2 ; qk+1; j + pk+1; j )
for k = m − 1; : : : ; 1:
1838
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
3.3. The implemented lower bound In a preliminary version of our branch-and-bound algorithm we implemented the lower bound LB7. We found that using this strong lower bound enables to fathom a relatively large number of nodes. However, the computing time was so large that only small-sized instances were solved to optimality. Therefore, in order to alleviate the computational burden we performed an empirical analysis which led to the computation, for each node N , of a lower bound LB(N ) which depends dynamically on the node level (lev(N )). More precisely, LB(N ) is computed in the following way: • If 0 6 lev(N ) 6 n=3 then LB(N ) = LB1(N ). • If n=3 + 1 6 lev(N ) 6 2n=3 then we compute LB1(N ). If N is not fathomed (i.e. LB1 ¡ UB) then we set LB(N ) = LB5(N ). • If 2n=3 + 1 6 lev(N ) 6 n − 1 then we compute LB1(N ). If N is not fathomed then we compute LB5(N ). Let (Mk ∗ ; Ml∗ ) denote the pair of machines satisfying LB5(k ∗ ; l∗ ) = max16k¡l6m LB5(k; l) (ties are broken arbitrarily). If LB5(k ∗ ; l∗ ) ¡ UB then we call the branch-and-bound algorithm of Haouari and Ladhari [36] to solve the F2 | rj ; lj ; qj ; prmu | Cmax problem de
JP = J ; 1 = ∅; 2 = ∅; lev(N0 ) = 0; UB(N0 ). Np = N0 . Ck1 = 0 (k = 1; : : : ; m). Ck2 = 0 (k = 1; : : : ; m). ∗ = UB(N ). Cmax 0 Step 2: Branching of node Np
• For all j ∈ JP Do. • Begin (creation of node N descendant of Np ) – lev(N ) = lev(Np ) + 1 – If lev(N ) = n − 1, then N corresponds to a feasible sequence ∗ ∗ ∗ If Cmax ( ) ¡ Cmax then update Cmax and go to step 4. – If lev(N ) is odd then ∗ 1 = (1 j) ∗ Update Ck1 (k = 1; : : : ; m)
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1839
– Otherwise ∗ 2 = (j2 ) ∗ Update Ck2 (k = 1; : : : ; m) – Compute LB(N ) ∗ – If LB(N ) ¡ Cmax then D(Np ) = D(Np ) ∪ {N } – Set D(N ) = ∅. Step 3: Node selection • If D(Np ) = ∅ then go to step 4. Otherwise select a node N ∈ D(Np ) which has the smallest lower bound. Set Np = N and go to step 2. Step 4: Backtracking ∗ • If Nc exists, then set Np = Nc , go to step 2. Otherwise, the sequence with makespan equal to Cmax is optimal.
4. Computational results We coded our branch-and-bound algorithm in C and compiled it with Microsoft Visual C++ (version 5.0). All the computational experiments were carried out on a Pentium IV 1:8 GHz PC with 128 MB RAM. In order to assess the performance of the proposed algorithm, we carried out two series of numerical experiments: the
1840
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
Table 1 Computational performance on randomly generated instances n
m
NN
MaxNN
Time
MaxTime
US
100
3 4 5 6 7
20.40 57.80 4173.30 13172.00 73537.25
100 184 32762 117494 273217
0.01 0.01 12.80 21.78 299.25
0.03 0.04 91.00 194.00 1118.00
0 0 0 1 6
200
3 4 5 6 7
20.90 62.20 492.40 4853.40 253.90
200 398 4270 362 1368
0.10 0.60 5.60 12.00 3.80
1.00 4.00 48.00 113.00 22.00
0 0 0 0 0
400
3 4 5 6 7
80.80 60.90 120.70 224.40 623.56
400 600 400 968 2517
2.20 0.50 9.00 13.80 47.67
13.00 3.00 46.00 59.00 186.00
0 0 0 0 1
700
3 4 5 6 7
140.80 140.80 280.80 400.30 409.90
700 700 1398 700 1377
12.50 20.70 59.70 117.30 108.90
72.00 106.00 296.00 265.00 341.00
0 0 0 0 0
1000
3 4 5 6 7
188.40 72.90 203.67 401.00 470.22
1875 720 1825 1000 2225
7.70 28.80 75.22 215.70 268.44
75.00 286.00 677.00 586.00 883.00
0 0 0 0 1
1500
3 4
452.30 302.10
1516 1513
201.70 238.20
717.00 1417.00
0 0
2000
3 4
200.90 316.50
2000 3156
170.70 10.10
1701.00 92.00
0 0
9 instances (out of 290) remained unsolved after reaching the 1 h time limit. Surprisingly, Table 1 suggests that the only problem class where our algorithm experiences serious diFculties is the class with a relatively small number of jobs and a large number of machines (n = 100 and m = 7). For this problem class, only 4 instances (out of 10) where solved within the time limit. For all the remaining classes, at most one instance remained unsolved after reaching the time limit. It is noteworthy, that prior to our work the largest F | prmu | Cmax instances that have ever been solved to optimality involve 3600 operations (n = 900, m = 4). This performance has been reported
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1841
by Cheng et al. [16] who run their branch-and-bound algorithm on a DEC 3000 (35 MFLOPS) workstation. 4.2. Evaluation by benchmark tests The main criticism which is often formulated with regard to computational experiments with instances that are randomly generated is that these instances could make the proposed algorithm look ef
1842
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
Table 2 Computational performance on benchmark instances n×m
Instance
Cmax
20 × 5
tail001 tail002 tail003 tail004 tail005 tail006 tail007 tail008 tail009 tail010
1278 1359 1081 1293 1235 1195 1234 1206 1230 1108
20 × 10
tail011 tail012 tail013 tail014 tail015 tail016 tail017 tail018 tail019 tail020
50 × 5
NN
Time
Gap
1 201218 20 15 191281 57 1 20 479 4
∼0 32 ∼0 ∼0 24 ∼0 ∼0 ∼0 ∼0 ∼0
0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1582 1659 1496 1377 1419 1397 1484 1538 1593 1591
259678 161669 191902 45409 46458 3766 40535661 137452 1794 393147
45 37 40 9 9 1 6937 34 ∼0 1
0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
tail031 tail032 tail033 tail034 tail035 tail036 tail037 tail038 tail039 tail040
2724 2834 2621 2751 2863 2829 2725 2683 2552 2782
1 59 20 14 239 14 6 1 160 1
∼0 ∼0 ∼0 ∼0 ∼0 ∼0 ∼0 ∼0 ∼0 ∼0
0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
50 × 10
tail041 tail042 tail043 tail044 tail045 tail046 tail047 tail048 tail049 tail050
2291 2867 2839 3063 2976 3006 3063a 3037 2897 3046a
80606 4151226 2331212 1081 46501 76 1548521 286 29719 2331233
111 5130 3975 3 111 ∼0 — ∼0 45 —
0.000 0.000 0.000 0.000 0.000 0.000 1.077 0.000 0.000 0.854
100 × 5
tail061 tail062 tail063
5493 5268 5175
1 23037 17
∼0 152 0
0.000 0.000 0.000
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1843
Table 2 (continued) n×m
Instance
Cmax
NN
Time
Gap
tail064 tail065 tail066 tail067 tail068 tail069 tail070
5014 5250 5135 5246 5094 5448 5310a
1180 21 1882 295 88766 1 58548
8 ∼0 13 2 552 ∼0 —
0.000 0.000 0.000 0.000 0.000 0.000 0.226
100 × 10
tail071 tail072 tail073 tail074 tail075 tail076 tail077 tail078 tail079 tail080
5770 5349 5673a 5781 5467 5303 5594a 5617 5871 5845
7 35 24996 4 2175 17 170814 143 109 303643
∼0 ∼0 — ∼0 26 ∼0 — ∼0 ∼0 4175
0.000 0.000 0.053 0.000 0.000 0.000 0.036 0.000 0.000 0.000
200 × 10
tail091 tail092 tail093 tail094 tail095 tail096 tail097 tail098 tail099 tail100
10861a 10480 10922 10863a 10524 10311a 10849a 10730 10438 10675
2136 6036 57 191455 1014 15966 20796 69603 1696 11407
— 341 3 — 237 — — 4839 102 656
0.009 0.000 0.000 0.239 0.000 0.184 0.240 0.000 0.000 0.000
a
This instance remained unsolved after reaching the 3 h time limit.
Table 3 Computational performance on the set of 50 × 20 benchmark instances Instance
NN
tail051 tail052 tail053 tail054 tail055 tail056 tail057 tail058 tail059 tail060
112 119 111 118 117 124 113 111 107 119
458 694 040 043 498 812 172 728 809 919
012 381 003 526 994 602 279 709 214 107
Time
Gap
10800 10800 10800 10800 10800 10800 10800 10800 10800 10800
2.09 0.98 1.39 2.44 1.63 0.49 0.89 1.76 2.68 1.92
1844
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
Table 4 Computational performance of A1 on benchmark instances n×m
Instance
NN
Time
Gap
20 × 10
tail011a tail012a tail013a tail014a tail015a tail016a tail017a tail018a tail019 tail020a
38108633 38845191 36432673 38310345 41206320 37263174 34120097 42162686 284135 41596940
— — — — — — — — 334 —
5.05 4.67 2.47 2.61 5.60 4.25 3.99 9.94 0.00 6.35
50 × 10
tail041a tail042a tail043a tail044 tail045a tail046 tail047a tail048 tail049a tail050a
27612200 13033401 19835829 1081 9262616 76 5047548 286 36654477 8967005
— — — 3 — ∼0 — ∼0 — —
1.01 1.34 0.57 0.00 0.88 0.00 1.08 0.00 0.59 0.85
a
This instance remained unsolved after reaching the three hours CPU time limit.
The performance of the alternative algorithm (hereafter denoted by A1) on 20 medium-sized benchmark instances is displayed in Table 4. We observe from Table 4 that almost all of the instances (16 out of 20) remained unsolved after reaching the 3 h time limit, while the proposed algorithm (A) was able to solve 18 instances (see Table 2). Also, the gap that was obtained after stopping A1 was often large. Pushing the investigation a step further, we evaluated the performance of A1 on 100 randomly generated instances. For all these instances the number of machines was
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1845
Table 5 Relative performance of A1 with respect to A on randomly generated instances n
NNratio (A1)
Timeratio (A1)
US(A1)
100 200 300 400 500
268.25 1748.89 494.98 8454.59 557.96
24.25 42.86 5.92 103.87 6.46
13 8 6 6 7
Table 6 Relative performance of A2 and A3 with respect to A on randomly generated instances n
NNratio (A2)
Timeratio (A2)
US(A2)
NNratio (A3)
Timeratio (A3)
US(A3)
100 200 300 400 500
39.63 10.13 0.85 16.98 1.88
5.83 7.39 1.05 21.56 3.00
3 1 1 1 3
11.34 462.54 2580.32 1811.60 776.37
6.39 14.48 18.63 16.04 5.37
20 20 20 20 20
NEH value of UB is used. In order to investigate this issue, we set the initial value of UB to 1:01×Cmax NEH (where Cmax is the value of the makespan provided by the heuristic of Nawaz et al., and x is the smallest integer that is greater than or equal to x). Let A2 and A3 denote the algorithms that results from deteriorating the initial upper bound of A and A1, respectively. Both algorithms were run on the same set of 100 randomly generated instances that was used to evaluate the performance of A1. Table 6 depicts a summary of the relative performance of A2 and A3 with respect to A. We observe that although the CPU time as well as the mean number of fathomed nodes increased signi
5. Conclusion We presented a branch-and-bound algorithm for the permutation &ow shop problem with a lower bounding procedure based on the exact solution of the F2 | rj ; lj ; qj ; prmu | Cmax problem. The main result of our work is to provide evidence that the NP-hardness of this later does not preclude its eKectivity for lower bound computation. We presented extensive computational results on both random instances, with up to 8000 operations, and well-known benchmarks with up to 2000 operations. In particular, the proposed algorithm has produced proven optimal solutions for a number of diFcult well-known problems which have been open for some time. Future research eKort needs to be focused on the development of new classes of tight lower bounds for instances with a large number of machines. A second issue worthy of future investigation is to develop methods to
1846
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
branching step. These methods have successfully been applied to the job shop problem [38,39]. However, how well this approach would perform computationally for the &ow shop problem remains an open question. References [1] Pinedo M. Scheduling: theory, algorithms, and systems. Englewood CliKs, NJ: Prentice-Hall; 1995. [2] Potts CN, Shmoys DB, Williamson DP. Permutation vs. non-permutation &ow shop schedules. Operations Research Letters 1999;10:281–4. [3] Johnson SM. Optimal two- and three-stage production schedules with setup times included. Naval Research Logistics Quarterly 1954;1:61–8. [4] Anderson EJ, Glass CA, Potts CN. Machine scheduling. In: Aarts E, Lenstra JK, editors. Local search in combinatorial optimization. Chichester: Wiley; 1997. p. 361–414. [5] Garey MR, Johnson DS, Sethi R. The complexity of &ow shop and job shop scheduling. Mathematics of Operations Research 1976;1:117–29. [6] Land AH, Doig AG. An automatic method for solving discrete programming problems. Econometrica 1960;28: 427–520. [7] Ignall E, Schrage LE. Application of the branch-and-bound technique to some &ow shop problems. Operations Research 1965;13:400–12. [8] Lomnicki Z. A branch-and-bound algorithm for the exact solution of the three-machine scheduling problem. Operational Research Quarterly 1965;16:89–100. [9] Brown APG, Lomnicki ZA. Some applications of the branch-and-bound algorithm to the machine sequencing problem. Operational Research Quarterly 1966;17:173–86. [10] McMahon GB, Burton PG. Flowshop scheduling with the branch-and-bound method. Operations Research 1967;15:473–81. [11] Ashour S. A branch-and-bound algorithm for the &ow shop problem scheduling problem. AIIE Transactions 1970;2:172–6. [12] Lageweg BJ, Lenstra JK, Rinnooy Kan AHG. A general bounding scheme for the permutation &ow-shop problem. Operations Research 1978;26:53–67. [13] Potts CN. An adaptive branching rule for the permutation &ow-shop problem. European Journal of Operational Research 1980;5:19–25. [14] Grabowski J. On two-machine scheduling with release dates to minimize maximum lateness. Opsearch 1980;17: 133–54. [15] Carlier J, Rebai MI. Two branch-and-bound algorithms for the permutation &ow shop problem. European Journal of Operational Research 1996;90:238–51. [16] Cheng J, Kise H, Matsumoto H. A branch-and-bound algorithm with fuzzy inference for a permutation &ow shop scheduling problem. European Journal of Operational Research 1997;96:578–90. [17] Campbell HG, Dudek RA, Smith ML. A heuristic algorithm for the n-job m-machine sequencing problem. Management Science 1970;16B:630–7. [18] Dannenbring DG. An evaluation of &ow shop sequencing heuristics. Management Science 1977;23:1174–82. [19] Nawaz M, Enscore Jr. EE, Ham I. A heuristic algorithm for the m-machine, n-job &ow shop sequencing problem. Omega 1983;11:91–5. [20] Osman IH, Potts CN. Simulated annealing for permutation &ow-shop scheduling. Omega 1989;17:551–7. [21] Nowicki E, Smutnicki C. A fast tabu search algorithm for the &ow shop problem. European Journal of Operational Research 1996;91:160–75. [22] Reeves CR. A genetic algorithm for &owshop sequencing. Computers and Operations Research 1995;22:5–13. [23] Haouari M, Ladhari T. A branch-and-bound-based local search method for the &ow shop problem. Journal of the Operational Research Society 2003;54:1076–84. [24] Smutnicki C. Some results of the worst-case analysis for &ow shop scheduling. European Journal of Operational Research 1998;109:66–87.
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1847
[25] Sviridenko MI. A note on permutation &ow shop problem. Annals of Operations Research 2004, to appear. [26] Lenstra JK, Rinnooy Kan AHG, Bruker P. Complexity of machine scheduling problems. Annals of Discrete Mathematics 1977;1:343–62. [27] McMahon GB. A study of algorithms for industrial scheduling problems. PhD thesis, University of New South Wales, Kensington; 1971. [28] Jackson JR. Scheduling a production line to minimize maximum tardiness. Research Report 43, Management Science Research Project, University of California, Los Angeles; 1955. [29] Bestwick PF, Hastings NAJ. A new bound for machine scheduling. Operational Research Quarterly 1976;27: 479–87. [30] Horn WA. Some simple scheduling algorithms. Naval Research Logistics Quarterly 1974;21:177–85. [31] Carlier J. The one-machine sequencing problem. European Journal of Operational Research 1982;11:42–7. [32] Rinnooy Kan AHG. Machine scheduling problems: classi
www.elsevier.com/locate/dsw
A computational study of the permutation &ow shop problem based on a tight lower bound Talel Ladharia; b , Mohamed Haouaria;∗ a
Laboratory of Mathematical Engineering, Ecole Polytechnique de Tunisie, BP 743, La Marsa 2078, Tunisia b Ecole Sup#erieure des Sciences Economiques et Commerciales, Tunis 1089, Tunisia
Abstract We consider the classical permutation &ow shop problem which requires scheduling n jobs through m machines which are placed in series so as to minimize the makespan. This problem is known to be NP-hard. We describe a branch-and-bound algorithm with a lower bounding procedure based on the so-called two-machine &ow shop problem with time lags, ready times, and delivery times. We present extensive computational results on both random instances, with up to 8000 operations, and well-known benchmarks, with up to 2000 operations, which show that the proposed algorithm solves large-scale instances in moderate CPU time. In particular, we report proven optimal solutions for benchmark problems which have been open for some time. ? 2003 Elsevier Ltd. All rights reserved. Keywords: Scheduling; Permutation &ow shop; Branch-and-bound algorithm
1. Introduction In this paper, we address the Permutation Flow Shop Problem which can be de
Corresponding author.
0305-0548/$ - see front matter ? 2003 Elsevier Ltd. All rights reserved. doi:10.1016/j.cor.2003.12.001
1832
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
exhibit a family of instances for which the value of the optimal permutation √ schedule is worse than that of the optimal nonpermutation schedule by a factor of more than 12 m. However, for the sake of simplicity, we will adhere to a well-established tradition in scheduling theory and restrict our attention solely to permutation schedules. Since the publication of the seminal paper of Johnson [3], the &ow shop problem has become one of the most intensively investigated topics in scheduling theory. This interest is not only motivated by its practical relevance, but also by its deceptive simplicity and challenging hardness. Though, the &ow shop problem is still considered as a very hard nut to crack. Indeed, up to the mid of the 1990s, the best available branch-and-bound algorithms experience diFculty in solving instances with 15 jobs and 4 machines [4, p. 393]. It is interesting to observe that at about the same time, instances of the celebrated traveling salesman problem with few hundreds of vertices could be solved quite routinely. It is well-known that the case of two machines (m = 2), could be easily solved using Johnson’s rule which generates an optimal schedule in O(n log n) time. For m ¿ 3, however, the problem is shown to be strongly NP-hard [5]. Interestingly, one can note that the quest for optimization strategies for the F | prmu | Cmax started about 40 years ago, shortly after the discovery by Land and Doig [6] of the branch-and-bound technique. Indeed, the
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1833
previously implemented by many authors. However, the most innovative aspect of our work lies in the implementation of a (new) tight lower bound that dominates all other previously used ones. Our algorithm has produced proven optimal solutions for a number of (hard) well-known instances with up to 2000 operations (n = 200 and m = 10) that have been open for 10 years, and randomly generated instances with up to 8000 operations (n = 2000 and m = 4). To the best of our knowledge, the solution of such large instances has never been previously reported in the literature. The rest of the paper is structured as follows. Section 2 provides a detailed description of most of the lower bounds that have been used so far. Section 3 describes the proposed branch-and-bound algorithm, including the branching rule, the search strategy, as well as the lower bounding strategy. Computational results are given in Section 4. Finally, some concluding remarks are provided. 2. Lower bounds for the F | prmu | Cmax It is well-known that the quality of the lower bound is one of the most critical components of any branch-and-bound algorithm. Actually, a close examination of the various branch-and-bound algorithms that have been developed so far for the F | prmu | Cmax reveals that the most signi
j ∈J
j ∈J
Hence, a valid lower bound for F | prmu | Cmax is LB1 = max LB1k : 16k 6m
1834
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
LB1 can be computed in O(mn) time. This simple bound has been used by Ignall and Schrage [7], Lomnicki [8], Brown and Lomnicki [9], McMahon and Burton [10], McMahon [27], and Carlier and RebaMN [15]. 2.1.2. LB2 A second relaxation of 1 | rj ; qj | Cmax is obtained by setting for all j ∈ J , qj = minj∈J qkj . This yields for each machine Mk (k = 1; : : : ; m) a lower bound k (J ) + min qkj ; LB2k = Cmax j ∈J
k where Cmax (J ) is the makespan of an optimal solution of the 1 | rj | Cmax problem de
LB2 = max LB2k : 16k 6m
Analogously, we can obtain the symmetric bound of LB2k by setting all release dates to minj∈J rkj and ordering jobs according to nondecreasing delivery times. Obtaining LB2k requires sorting jobs according to their release dates or delivery times. Hence LB2 requires O(mn log n) time. LB2 has been implemented in the branch-and-bound algorithms of Bestwick and Hastings [29] and Ashour [11]. 2.1.3. LB3 A third relaxation of 1 | rj ; qj | Cmax is obtained by allowing preemptive schedules. An optimal makespan of 1 | rj ; qj ; pmtn | Cmax can be found in polynomial time by the Earliest Due Date rule (EDD): at any time schedule an available job with largest delivery time [30]. For each machine Mk (k = 1; : : : ; m) let LB3k denote the makespan of the corresponding optimal preemptive schedule. Clearly, a valid lower bound for F | prmu | Cmax is LB3 = max LB3k : 16k 6m
LB3 is calculated in O(mn log n) time. It has been implemented in the branch-and-bound algorithm of Carlier and RebaMN [15]. 2.1.4. LB4 The fourth lower bound is derived from the computation of the optimal makespan, denoted LB4k , of the 1 | rj ; qj | Cmax on machine Mk (k = 1; : : : ; m). Therefore, a valid lower bound for F | prmu | Cmax is LB4 = max LB4k : 16k 6m
It is noteworthy that although being NP-hard the 1 | rj ; qj | Cmax can be solved eFciently using the branch-and-bound algorithm of Carlier [31]. To the best of our knowledge, LB4 has never been implemented for the F | prmu | Cmax .
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1835
2.2. Two-machine-based lower bound To improve on the one-machine relaxation, a natural step is to use two-machine relaxations. Therefore, lower bounds for the permutation &ow shop problem can be obtained by selecting two diKerent machines Mk and Ml (1 6 k ¡ l 6 m) and relaxing the constraint that each of the other machines can process at most one job at a time. The resulting relaxation is a two-machine permutation &ow shop problem subject to release dates, time lags and delivery times with the objective of minimizing the makespan. This problem is denoted F2 | rj ; lj ; qj ; prmu | Cmax and is obtained by setting for all j ∈ J m l− 1 k −1 pij if l ¡ m; pij if k + 1 ¡ l; pij if k ¿ 1; qj = i=l+1 rj = i=1 lj = i=k+1 0 if l = m: 0 if k = 1; 0 if l = k + 1; By considering various relaxations of this two-machine &ow shop problem the following lower bounds are derived. 2.2.1. LB5 A
j ∈J
kl (J ) is the optimal makespan of the F2 | lj ; prmu | Cmax problem de
LB5 =
max
16k¡l6m
LB5(k; l) :
Clearly, LB5 requires O(m2 n log n) time. This bound has been implemented in the branch-andbound algorithms of McMahon [27], Szwarc [33], Potts [34], Lageweg et al. [12], and Cheng et al. [16]. 2.2.2. LB6 In order to alleviate the computational burden of LB5, one could consider only machine pairs of k the form (Mk ; Mk+1 ) (k = 1; : : : ; m − 1). Let Cmax (J ) denote the optimal makespan of the F2 Cmax problem de
1836
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
F | prmu | Cmax is LB6 =
max
16k 6m−1
min rkj + j ∈J
k Cmax (J )
+ min qk+1; j : j ∈J
LB6 requires O(mn log n) time. It has been used by Nabeshima [35] and Carlier and RebaMN [15]. 2.2.3. LB7 kl∗ Let Cmax (J ) denote the optimal makespan of the F2 | rj ; lj ; qj ; prmu | Cmax problem de
max
16k¡l6m
kl∗ Cmax (J ):
LB7 clearly dominates all previously described lower bounds. Indeed, all other lower bounds are derived from LB7 by relaxing the constraint that one of the two machines can process at most one job at a time, by underestimating the contribution of the release and delivery times, or by allowing preemption. However, contrary to the aforementioned lower bounds (with the exception of LB4), LB7 cannot be computed in polynomial time. Indeed, the NP-hardness of the F2 | rj ; lj ; qj ; prmu | Cmax is an immediate consequence of the NP-hardness of the 1 | rj ; qj | Cmax . Nonetheless, the excellent performance of the branch-and-bound algorithm developed by Haouari and Ladhari [36] for the F2 | rj ; lj ; qj ; prmu | Cmax problem, motivated us to investigate the use of this lower bound for solving the F | prmu | Cmax . Our computational experiments provide evidence that embedding a lower bound based on the exact solution of the F2 | rj ; lj ; qj ; prmu | Cmax problem yields a highly eKective optimization algorithm.
3. Description of the branch-and-bound algorithm In this section we provide a detailed description of our branch-and-bound algorithm. Notation. With each node N of the search tree we associate the following data: JP rkj qkj pkj lkl j ∗ Cmax 1 2 k Ci lev(N )
the set of unscheduled jobs release date of job j (j ∈ JP ) on machine Mk (k = 1; : : : ; m) delivery time of job j (j ∈ JP ) on machine Mk (k = 1; : : : ; m) processing time of job j (j ∈ JP ) on machine Mk (k = 1; : : : ; m) minimum amount of time between the completion time of job j (j ∈ JP ) on machine Mk and its start on machine Ml (1 6 k ¡ l 6 m) the current best upper bound on the optimal makespan a partial sequence of n1 jobs scheduled on the top of the global sequence a partial sequence of n2 (n2 6 n−n1 ) jobs scheduled on the bottom of the global sequence the minimal completion time of i (i = 1; 2) on the machine Mk (k = 1; : : : ; m) level of node N (lev(N ) = n1 + n2 )
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
LB(N ) Np D(Np ) Nc
1837
a lower bound of the optimal makespan of a sequence where the jobs of subset JP are scheduled after the completion of subsequence 1 and before the start of the subsequence 2 the parent node of N the set of candidate nodes descendant of Np ∗ the closest unbranched node to N , such that LB(Nc ) ¡ Cmax
3.1. Branching scheme, search strategy, and upper bound We implemented the following branching rule. The
for k = m − 1; : : : ; 1:
In order to take into account the availability of the machines, we update for each job j ∈ JP its release date and delivery time on each machine Mk (k = 1; 2; : : : ; m) as follows: r1j = C11 ; rkj = max(Ck1 ; rk −1; j + pk −1; j )
for k = 2; : : : ; m;
qmj = Cm2 ; qkj = max(Ck2 ; qk+1; j + pk+1; j )
for k = m − 1; : : : ; 1:
1838
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
3.3. The implemented lower bound In a preliminary version of our branch-and-bound algorithm we implemented the lower bound LB7. We found that using this strong lower bound enables to fathom a relatively large number of nodes. However, the computing time was so large that only small-sized instances were solved to optimality. Therefore, in order to alleviate the computational burden we performed an empirical analysis which led to the computation, for each node N , of a lower bound LB(N ) which depends dynamically on the node level (lev(N )). More precisely, LB(N ) is computed in the following way: • If 0 6 lev(N ) 6 n=3 then LB(N ) = LB1(N ). • If n=3 + 1 6 lev(N ) 6 2n=3 then we compute LB1(N ). If N is not fathomed (i.e. LB1 ¡ UB) then we set LB(N ) = LB5(N ). • If 2n=3 + 1 6 lev(N ) 6 n − 1 then we compute LB1(N ). If N is not fathomed then we compute LB5(N ). Let (Mk ∗ ; Ml∗ ) denote the pair of machines satisfying LB5(k ∗ ; l∗ ) = max16k¡l6m LB5(k; l) (ties are broken arbitrarily). If LB5(k ∗ ; l∗ ) ¡ UB then we call the branch-and-bound algorithm of Haouari and Ladhari [36] to solve the F2 | rj ; lj ; qj ; prmu | Cmax problem de
JP = J ; 1 = ∅; 2 = ∅; lev(N0 ) = 0; UB(N0 ). Np = N0 . Ck1 = 0 (k = 1; : : : ; m). Ck2 = 0 (k = 1; : : : ; m). ∗ = UB(N ). Cmax 0 Step 2: Branching of node Np
• For all j ∈ JP Do. • Begin (creation of node N descendant of Np ) – lev(N ) = lev(Np ) + 1 – If lev(N ) = n − 1, then N corresponds to a feasible sequence ∗ ∗ ∗ If Cmax ( ) ¡ Cmax then update Cmax and go to step 4. – If lev(N ) is odd then ∗ 1 = (1 j) ∗ Update Ck1 (k = 1; : : : ; m)
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1839
– Otherwise ∗ 2 = (j2 ) ∗ Update Ck2 (k = 1; : : : ; m) – Compute LB(N ) ∗ – If LB(N ) ¡ Cmax then D(Np ) = D(Np ) ∪ {N } – Set D(N ) = ∅. Step 3: Node selection • If D(Np ) = ∅ then go to step 4. Otherwise select a node N ∈ D(Np ) which has the smallest lower bound. Set Np = N and go to step 2. Step 4: Backtracking ∗ • If Nc exists, then set Np = Nc , go to step 2. Otherwise, the sequence with makespan equal to Cmax is optimal.
4. Computational results We coded our branch-and-bound algorithm in C and compiled it with Microsoft Visual C++ (version 5.0). All the computational experiments were carried out on a Pentium IV 1:8 GHz PC with 128 MB RAM. In order to assess the performance of the proposed algorithm, we carried out two series of numerical experiments: the
1840
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
Table 1 Computational performance on randomly generated instances n
m
NN
MaxNN
Time
MaxTime
US
100
3 4 5 6 7
20.40 57.80 4173.30 13172.00 73537.25
100 184 32762 117494 273217
0.01 0.01 12.80 21.78 299.25
0.03 0.04 91.00 194.00 1118.00
0 0 0 1 6
200
3 4 5 6 7
20.90 62.20 492.40 4853.40 253.90
200 398 4270 362 1368
0.10 0.60 5.60 12.00 3.80
1.00 4.00 48.00 113.00 22.00
0 0 0 0 0
400
3 4 5 6 7
80.80 60.90 120.70 224.40 623.56
400 600 400 968 2517
2.20 0.50 9.00 13.80 47.67
13.00 3.00 46.00 59.00 186.00
0 0 0 0 1
700
3 4 5 6 7
140.80 140.80 280.80 400.30 409.90
700 700 1398 700 1377
12.50 20.70 59.70 117.30 108.90
72.00 106.00 296.00 265.00 341.00
0 0 0 0 0
1000
3 4 5 6 7
188.40 72.90 203.67 401.00 470.22
1875 720 1825 1000 2225
7.70 28.80 75.22 215.70 268.44
75.00 286.00 677.00 586.00 883.00
0 0 0 0 1
1500
3 4
452.30 302.10
1516 1513
201.70 238.20
717.00 1417.00
0 0
2000
3 4
200.90 316.50
2000 3156
170.70 10.10
1701.00 92.00
0 0
9 instances (out of 290) remained unsolved after reaching the 1 h time limit. Surprisingly, Table 1 suggests that the only problem class where our algorithm experiences serious diFculties is the class with a relatively small number of jobs and a large number of machines (n = 100 and m = 7). For this problem class, only 4 instances (out of 10) where solved within the time limit. For all the remaining classes, at most one instance remained unsolved after reaching the time limit. It is noteworthy, that prior to our work the largest F | prmu | Cmax instances that have ever been solved to optimality involve 3600 operations (n = 900, m = 4). This performance has been reported
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1841
by Cheng et al. [16] who run their branch-and-bound algorithm on a DEC 3000 (35 MFLOPS) workstation. 4.2. Evaluation by benchmark tests The main criticism which is often formulated with regard to computational experiments with instances that are randomly generated is that these instances could make the proposed algorithm look ef
1842
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
Table 2 Computational performance on benchmark instances n×m
Instance
Cmax
20 × 5
tail001 tail002 tail003 tail004 tail005 tail006 tail007 tail008 tail009 tail010
1278 1359 1081 1293 1235 1195 1234 1206 1230 1108
20 × 10
tail011 tail012 tail013 tail014 tail015 tail016 tail017 tail018 tail019 tail020
50 × 5
NN
Time
Gap
1 201218 20 15 191281 57 1 20 479 4
∼0 32 ∼0 ∼0 24 ∼0 ∼0 ∼0 ∼0 ∼0
0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1582 1659 1496 1377 1419 1397 1484 1538 1593 1591
259678 161669 191902 45409 46458 3766 40535661 137452 1794 393147
45 37 40 9 9 1 6937 34 ∼0 1
0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
tail031 tail032 tail033 tail034 tail035 tail036 tail037 tail038 tail039 tail040
2724 2834 2621 2751 2863 2829 2725 2683 2552 2782
1 59 20 14 239 14 6 1 160 1
∼0 ∼0 ∼0 ∼0 ∼0 ∼0 ∼0 ∼0 ∼0 ∼0
0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
50 × 10
tail041 tail042 tail043 tail044 tail045 tail046 tail047 tail048 tail049 tail050
2291 2867 2839 3063 2976 3006 3063a 3037 2897 3046a
80606 4151226 2331212 1081 46501 76 1548521 286 29719 2331233
111 5130 3975 3 111 ∼0 — ∼0 45 —
0.000 0.000 0.000 0.000 0.000 0.000 1.077 0.000 0.000 0.854
100 × 5
tail061 tail062 tail063
5493 5268 5175
1 23037 17
∼0 152 0
0.000 0.000 0.000
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1843
Table 2 (continued) n×m
Instance
Cmax
NN
Time
Gap
tail064 tail065 tail066 tail067 tail068 tail069 tail070
5014 5250 5135 5246 5094 5448 5310a
1180 21 1882 295 88766 1 58548
8 ∼0 13 2 552 ∼0 —
0.000 0.000 0.000 0.000 0.000 0.000 0.226
100 × 10
tail071 tail072 tail073 tail074 tail075 tail076 tail077 tail078 tail079 tail080
5770 5349 5673a 5781 5467 5303 5594a 5617 5871 5845
7 35 24996 4 2175 17 170814 143 109 303643
∼0 ∼0 — ∼0 26 ∼0 — ∼0 ∼0 4175
0.000 0.000 0.053 0.000 0.000 0.000 0.036 0.000 0.000 0.000
200 × 10
tail091 tail092 tail093 tail094 tail095 tail096 tail097 tail098 tail099 tail100
10861a 10480 10922 10863a 10524 10311a 10849a 10730 10438 10675
2136 6036 57 191455 1014 15966 20796 69603 1696 11407
— 341 3 — 237 — — 4839 102 656
0.009 0.000 0.000 0.239 0.000 0.184 0.240 0.000 0.000 0.000
a
This instance remained unsolved after reaching the 3 h time limit.
Table 3 Computational performance on the set of 50 × 20 benchmark instances Instance
NN
tail051 tail052 tail053 tail054 tail055 tail056 tail057 tail058 tail059 tail060
112 119 111 118 117 124 113 111 107 119
458 694 040 043 498 812 172 728 809 919
012 381 003 526 994 602 279 709 214 107
Time
Gap
10800 10800 10800 10800 10800 10800 10800 10800 10800 10800
2.09 0.98 1.39 2.44 1.63 0.49 0.89 1.76 2.68 1.92
1844
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
Table 4 Computational performance of A1 on benchmark instances n×m
Instance
NN
Time
Gap
20 × 10
tail011a tail012a tail013a tail014a tail015a tail016a tail017a tail018a tail019 tail020a
38108633 38845191 36432673 38310345 41206320 37263174 34120097 42162686 284135 41596940
— — — — — — — — 334 —
5.05 4.67 2.47 2.61 5.60 4.25 3.99 9.94 0.00 6.35
50 × 10
tail041a tail042a tail043a tail044 tail045a tail046 tail047a tail048 tail049a tail050a
27612200 13033401 19835829 1081 9262616 76 5047548 286 36654477 8967005
— — — 3 — ∼0 — ∼0 — —
1.01 1.34 0.57 0.00 0.88 0.00 1.08 0.00 0.59 0.85
a
This instance remained unsolved after reaching the three hours CPU time limit.
The performance of the alternative algorithm (hereafter denoted by A1) on 20 medium-sized benchmark instances is displayed in Table 4. We observe from Table 4 that almost all of the instances (16 out of 20) remained unsolved after reaching the 3 h time limit, while the proposed algorithm (A) was able to solve 18 instances (see Table 2). Also, the gap that was obtained after stopping A1 was often large. Pushing the investigation a step further, we evaluated the performance of A1 on 100 randomly generated instances. For all these instances the number of machines was
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1845
Table 5 Relative performance of A1 with respect to A on randomly generated instances n
NNratio (A1)
Timeratio (A1)
US(A1)
100 200 300 400 500
268.25 1748.89 494.98 8454.59 557.96
24.25 42.86 5.92 103.87 6.46
13 8 6 6 7
Table 6 Relative performance of A2 and A3 with respect to A on randomly generated instances n
NNratio (A2)
Timeratio (A2)
US(A2)
NNratio (A3)
Timeratio (A3)
US(A3)
100 200 300 400 500
39.63 10.13 0.85 16.98 1.88
5.83 7.39 1.05 21.56 3.00
3 1 1 1 3
11.34 462.54 2580.32 1811.60 776.37
6.39 14.48 18.63 16.04 5.37
20 20 20 20 20
NEH value of UB is used. In order to investigate this issue, we set the initial value of UB to 1:01×Cmax NEH (where Cmax is the value of the makespan provided by the heuristic of Nawaz et al., and x is the smallest integer that is greater than or equal to x). Let A2 and A3 denote the algorithms that results from deteriorating the initial upper bound of A and A1, respectively. Both algorithms were run on the same set of 100 randomly generated instances that was used to evaluate the performance of A1. Table 6 depicts a summary of the relative performance of A2 and A3 with respect to A. We observe that although the CPU time as well as the mean number of fathomed nodes increased signi
5. Conclusion We presented a branch-and-bound algorithm for the permutation &ow shop problem with a lower bounding procedure based on the exact solution of the F2 | rj ; lj ; qj ; prmu | Cmax problem. The main result of our work is to provide evidence that the NP-hardness of this later does not preclude its eKectivity for lower bound computation. We presented extensive computational results on both random instances, with up to 8000 operations, and well-known benchmarks with up to 2000 operations. In particular, the proposed algorithm has produced proven optimal solutions for a number of diFcult well-known problems which have been open for some time. Future research eKort needs to be focused on the development of new classes of tight lower bounds for instances with a large number of machines. A second issue worthy of future investigation is to develop methods to
1846
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
branching step. These methods have successfully been applied to the job shop problem [38,39]. However, how well this approach would perform computationally for the &ow shop problem remains an open question. References [1] Pinedo M. Scheduling: theory, algorithms, and systems. Englewood CliKs, NJ: Prentice-Hall; 1995. [2] Potts CN, Shmoys DB, Williamson DP. Permutation vs. non-permutation &ow shop schedules. Operations Research Letters 1999;10:281–4. [3] Johnson SM. Optimal two- and three-stage production schedules with setup times included. Naval Research Logistics Quarterly 1954;1:61–8. [4] Anderson EJ, Glass CA, Potts CN. Machine scheduling. In: Aarts E, Lenstra JK, editors. Local search in combinatorial optimization. Chichester: Wiley; 1997. p. 361–414. [5] Garey MR, Johnson DS, Sethi R. The complexity of &ow shop and job shop scheduling. Mathematics of Operations Research 1976;1:117–29. [6] Land AH, Doig AG. An automatic method for solving discrete programming problems. Econometrica 1960;28: 427–520. [7] Ignall E, Schrage LE. Application of the branch-and-bound technique to some &ow shop problems. Operations Research 1965;13:400–12. [8] Lomnicki Z. A branch-and-bound algorithm for the exact solution of the three-machine scheduling problem. Operational Research Quarterly 1965;16:89–100. [9] Brown APG, Lomnicki ZA. Some applications of the branch-and-bound algorithm to the machine sequencing problem. Operational Research Quarterly 1966;17:173–86. [10] McMahon GB, Burton PG. Flowshop scheduling with the branch-and-bound method. Operations Research 1967;15:473–81. [11] Ashour S. A branch-and-bound algorithm for the &ow shop problem scheduling problem. AIIE Transactions 1970;2:172–6. [12] Lageweg BJ, Lenstra JK, Rinnooy Kan AHG. A general bounding scheme for the permutation &ow-shop problem. Operations Research 1978;26:53–67. [13] Potts CN. An adaptive branching rule for the permutation &ow-shop problem. European Journal of Operational Research 1980;5:19–25. [14] Grabowski J. On two-machine scheduling with release dates to minimize maximum lateness. Opsearch 1980;17: 133–54. [15] Carlier J, Rebai MI. Two branch-and-bound algorithms for the permutation &ow shop problem. European Journal of Operational Research 1996;90:238–51. [16] Cheng J, Kise H, Matsumoto H. A branch-and-bound algorithm with fuzzy inference for a permutation &ow shop scheduling problem. European Journal of Operational Research 1997;96:578–90. [17] Campbell HG, Dudek RA, Smith ML. A heuristic algorithm for the n-job m-machine sequencing problem. Management Science 1970;16B:630–7. [18] Dannenbring DG. An evaluation of &ow shop sequencing heuristics. Management Science 1977;23:1174–82. [19] Nawaz M, Enscore Jr. EE, Ham I. A heuristic algorithm for the m-machine, n-job &ow shop sequencing problem. Omega 1983;11:91–5. [20] Osman IH, Potts CN. Simulated annealing for permutation &ow-shop scheduling. Omega 1989;17:551–7. [21] Nowicki E, Smutnicki C. A fast tabu search algorithm for the &ow shop problem. European Journal of Operational Research 1996;91:160–75. [22] Reeves CR. A genetic algorithm for &owshop sequencing. Computers and Operations Research 1995;22:5–13. [23] Haouari M, Ladhari T. A branch-and-bound-based local search method for the &ow shop problem. Journal of the Operational Research Society 2003;54:1076–84. [24] Smutnicki C. Some results of the worst-case analysis for &ow shop scheduling. European Journal of Operational Research 1998;109:66–87.
T. Ladhari, M. Haouari / Computers & Operations Research 32 (2005) 1831 – 1847
1847
[25] Sviridenko MI. A note on permutation &ow shop problem. Annals of Operations Research 2004, to appear. [26] Lenstra JK, Rinnooy Kan AHG, Bruker P. Complexity of machine scheduling problems. Annals of Discrete Mathematics 1977;1:343–62. [27] McMahon GB. A study of algorithms for industrial scheduling problems. PhD thesis, University of New South Wales, Kensington; 1971. [28] Jackson JR. Scheduling a production line to minimize maximum tardiness. Research Report 43, Management Science Research Project, University of California, Los Angeles; 1955. [29] Bestwick PF, Hastings NAJ. A new bound for machine scheduling. Operational Research Quarterly 1976;27: 479–87. [30] Horn WA. Some simple scheduling algorithms. Naval Research Logistics Quarterly 1974;21:177–85. [31] Carlier J. The one-machine sequencing problem. European Journal of Operational Research 1982;11:42–7. [32] Rinnooy Kan AHG. Machine scheduling problems: classi