The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies

European Journal of Operational Research xxx (2013) xxx–xxx

Contents lists available at SciVerse ScienceDirect

European Journal of Operational Research journal homepage: www.elsevier.com/locate/ejor

Discrete Optimization

The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies Anis Gharbi a,d,⇑, Talel Ladhari a,d, Mohamed Kais Msakni b, Mehdi Serairi c a Princess Fatimah Al-Nijriss Research Chair for Advanced Manufacturing Technologies, Department of Industrial Engineering, College of Engineering, King Saud University, PO Box 800, Riyadh 11421, Saudi Arabia b Ecole Supérieure des Sciences Economiques et Commerciales de Tunis, University of Tunis, Tunisia c LORIA, UMR 7503 Laboratory, University of Lorraine, Campus Scientifique, BP 239, 54506 Vandoeuvre-les-Nancy, France d BEM Bordeaux Management School, France

a r t i c l e

i n f o

Article history: Received 3 August 2010 Accepted 19 May 2013 Available online xxxx Keywords: Scheduling Two-machine flowshop Sequence-independent setup times Total completion time Lower bounds Lagrangian relaxation

a b s t r a c t The two-machine flowshop environment with sequence-independent setup times has been intensely investigated both from theoretical and practical perspectives in the scheduling literature. Nevertheless, very scant attention has been devoted to deriving effective lower bounding strategies. In this paper, we propose new lower bounds for the total completion time minimization criterion. These bounds are based on three relaxation schemes, namely the waiting time-based relaxation scheme, the single machine-based relaxation scheme, and the Lagrangian relaxation scheme. Extensive computational study carried on instances with up to 500 jobs reveals that embedding the waiting time-based bounding strategy within the Lagrangian relaxation framework yields the best performance while requiring negligible CPU time. Ó 2013 Elsevier B.V. All rights reserved.

1. Introduction Due to the increasing competition caused by globalization, manufacturing industries are nowadays forced to minimize costs and reduce delays in order to maintain competitive positions in the fast changing markets. Flexible production systems together with modern scheduling tools, which rely on sophisticated and effective techniques, proved to substantially help in reaching such key success factors. Flexible production systems induce more important setup times during which the tools of each machine of a production line are changed in order to be able to switch from one batch to another. Setup activities include several important tasks such as tools acquirement and adjustment, machine cleaning up, and material inspection. Recent studies show the significant impact of reducing setup times with respect to several performance criteria encompassing production speed increase, competitiveness improvement, lead times shortening, stock reduction, and customer satisfaction increase [5]. For the sake of illustration, Trovinger and Bohn [29] reported that combining the SMED method with IT-based techniques in a printed circuit board assembly ⇑ Corresponding author at: Princess Fatimah Al-Nijriss Research Chair for Advanced Manufacturing Technologies, Department of Industrial Engineering, College of Engineering, King Saud University, PO Box 800, Riyadh 11421, Saudi Arabia. Tel.: +966 14676829. E-mail addresses: [email protected], [email protected] (A. Gharbi).

yielded a setup time reduction of more than 80%, resulting to an annual benefit of $1.8 million. Not only it is crucial to optimize setup times, but more importantly, it is often essential to explicitly take them into account while scheduling numerous production systems. Allahverdi and Souroush [5] listed various real-world scheduling applications where setup times are considered separately from processing times. In addition to industrial applications (e.g. metal processing, brake manufacturing, electronics, etc.), the list covers a wide range of areas including finance, information processing, health care, cosmetics, and satellite imaging, to quote just a few. In the present paper, we investigate a two-machine flowshop scheduling environment with setup time consideration. The setup times are assumed to be sequence-independent, i.e. they only depend on the job to be processed, regardless of its preceding job. The objective is to find a feasible job sequence which minimizes the total completion time. More formally, a set of n jobs has to be processed on machines M1 and M2 in that order. Processing job j 2 {1, . . . , n} on machine Mi (i 2 {1, 2}) requires si,j units of setup time and pi,j units of non-preemptive processing time. At this point, it should be made clear in the reader’s mind that the setup times are separate entities that are not hidden in the processing times. Indeed, the setup time of a given job on M2 can be dealt with during its processing on M1. All data are assumed to be deterministic and integer. Each machine processes at most one job at one time and each job cannot be processed by more than one machine

0377-2217/$ - see front matter Ó 2013 Elsevier B.V. All rights reserved. http://dx.doi.org/10.1016/j.ejor.2013.05.031

Please cite this article in press as: A. Gharbi et al., The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies, European Journal of Operational Research (2013), http://dx.doi.org/10.1016/j.ejor.2013.05.031

2

A. Gharbi et al. / European Journal of Operational Research xxx (2013) xxx–xxx

at one time. According to Allahverdi et al. [8], this strongly NPP hard problem is denoted by F2jST si j C j . It is worth noting that we only focus on permutation schedules, i.e. where both machines have the same job sequence. Indeed, for any regular optimization criterion in a two-machine flowshop environment with sequence-independent setup times, it can be shown that there always exists an optimal schedule where the job sequence is the same for both machines [7]. Also, it should be noted that the total completion time is equivalent to the mean flow time criterion. Interestingly, several real-world industrial applications can be modeled as a two-machine flowshop scheduling problem with sequence-independent setup times. These include scheduling multimedia data objects for World Wide Web applications [9], and scheduling automated manufacturing cells with computer-conP trolled transportation robots [24]. In particular, the F2jST si j C j arises in the context of three-tiered Internet/database connectivity model which provides an interface between the enterprise service and clients [3]. In this model, client requests need to be processed by the application server and then by the database server (which represent M1 and M2, respectively). For the sake of efficiency, the queued requests are to be scheduled so that the average completion time of a client request is minimized. Before a request can be processed, the resources needed for this request are to be made ready in the application server. Also, an access to the database must be preceded by a preprocessing operation which consists in a database query decomposition and a partial optimization. Since this latter preprocessing operation can start while the application server is processing the query, then it can be seen as its setup operation on the second server. From a theoretical point of view, the two-machine flowshop with sequence-independent setup times has been the scope of numerous investigations. One of the pioneering results is that of Yoshida and Hitomi [31] who showed that the minimum makespan can be computed in polynomial time. The last decade witnessed a particular interest arousal in this scheduling environment with various optimization criteria [4,6,9]. Also, thorough studies have been conducted on several variants of the machine/job settings, encompassing the single server variant, the no-wait variant, the assembly variant, and the random setup and/or processing times variants [4,10,12,17]. For an exhaustive overview of scheduling literature that deals with setup times, the reader is referred to the excellent survey papers of Allahverdi et al. [7,8]. Bagga and Khurana [11] were the first to address the P F2jST si j C j problem. They proposed two lower bounds, a dominance rule and a branch-and-bound algorithm which could only solve small-sized instances with up to 9 jobs. The most important P contribution in F2jST si j C j related research is probably that of Allahverdi [6]. He implemented the lower bounds of Bagga and Khurana [11] together with two new dominance rules in a branch-and-bound algorithm which was able to solve instances with up to 35 jobs. He also proved that if s1,j + p1,j 6 s2,j for all j 2 {1, . . . , n}; then the optimal sequence is obtained by sorting the jobs according to the nondecreasing order of s2,j + p2,j. Moreover, he proposed three constructive heuristics which sequence one, two, and three jobs at a time, respectively. These heuristics have been combined with local search procedures by Al-Anzi and Allahverdi [3] and provided better results. Recently, Ladhari et al. [25] proposed a dynamic priority rule-based constructive heuristic which proved to consistently outperform those of [3]. Moreover, Ladhari et al. [25] devised a multiple crossover genetic local search algorithm that provided near-optimal solutions in reasonable CPU time for large-sized instances with up to 500 jobs. Despite the non-negligible research efforts that have been deP voted to the F2jST si j C j , there is still a big hole in the related literature in terms of lower bounding procedures. As far as we know, P the only developed lower bounds for F2jST si j C j are those of Bag-

ga and Khurana [11] and Gharbi et al. [18]. As it will be detailed in the next section and assessed in our experimental analysis, these bounds are much simplistic and prove to have a low performance. Undoubtedly, efficient and tight lower bounds constitute the bedrock of highly performant branch-and-bound algorithms. Consequently, the lack of strong lower bounding procedures considerably obstructs the development of efficient exact methods P for the F2jST si j C j . On the other hand, it is well-known that a critical performance measure of an approximate solution is its relative gap with respect to a lower bound. Therefore, relying on loose lower bounds would yield inaccurate assessments of potentially good P heuristics for the F2jST si j C j . P P Actually, the F2jST si j C j generalizes the classical F2jj C j where the setup times are assumed to be merged with the processing times. Several lower bounds have been proposed for the P F2jj C j so far. The very first machine-based lower bounds have been proposed by Ignall and Schrage [22]. Improved lower bounds that are based on similar bounding schemes have been proposed by Ahmadi and Bagchi [1] and Della Croce et al. [15]. Akkan and Karabati [2] proposed a lower bounding scheme that is based on P a network formulation of the F2jj C j . In particular, numerous Lagrangian-based lower bounds have been proposed so far for P the F2jj C j [14,20,21,30]. In an initial version of this paper [18], two new lower bounding P schemes have been proposed for the F2jST si j C j . The first bounding scheme, baptized the waiting time-based bounding scheme, is based on the minimum time each job has to wait since its finishing time on the first machine until its start time on the second machine. The second one, namely the single machine-based bounding scheme, is based on relaxing the capacity of the first machine. Preliminary computational results have shown that the derived polynomial-time lower bounds outperformed those of Bagga and Khurana [11]. In this paper, we revisit those lower bounding schemes in more details from both theoretical and experimental aspects as detailed in the following points:  Five waiting time-based lower bounds are described, including LB1WT ; LB2WT ; LB3WT of [18] and two newly proposed ones, namely LB4WT and LB5WT . Actually, LB4WT brings a new idea of estimating the minimum required waiting time if one job precedes another, while LB5WT constitutes a promising extension of an P F2jj C j lower bound that was proposed by Della Croce et al. [15]. We provide proof that LB4WT theoretically dominates LB1WT and LB2WT , whilst we show by using simple counter-examples that no dominance relationship exists between LB4WT and LB3WT . However, an empirical pairwise comparison provides evidence that LB4WT consistently dominates LB3WT . On the other hand, LB5WT is shown to only dominate LB1WT from the theoretical point of view. Nevertheless, the computational performance of LB5WT proves to considerably outperform all of the discussed waiting-time based lower bounds.  In addition to the two single machine-based lower bounds of [18], namely LB1SM and LB2SM , two newly derived ones are discussed in this paper. The first one, LB3SM , consists in exactly solving a single machine problem that is obtained through an equivalence result. This latter bound dominates theoretically and empirically both LB1SM and LB2SM . Not surprisingly, due to its exponential nature, LB3SM provides improved results with a higher computational time which seems however to be reasonable. The second lower bound, LB4SM , is inspired-again-from an P F2jj C j lower bound that was proposed by Della Croce et al. [15]. Although we provide evidence that LB1SM is the only single machine-based lower bound that is theoretically dominated by LB4SM , the empirical results show that the latter bound exhibits the best effectiveness/efficiency trade-off among the one machine-based lower bounds.

Please cite this article in press as: A. Gharbi et al., The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies, European Journal of Operational Research (2013), http://dx.doi.org/10.1016/j.ejor.2013.05.031

3

A. Gharbi et al. / European Journal of Operational Research xxx (2013) xxx–xxx

 A more thorough computational analysis of those preliminary lower bounds as well as of the newly derived ones is provided. The experiments have been conducted on a larger set of instances with up to 500 jobs. Moreover, the adopted performance criteria go beyond the percentage of times each bound yields the maximal value over all of the discussed ones. Indeed, a pairwise comparison of the lower bounds has been carried out in order to provide a clear picture of the empirical dominance of each bound with respect to another. Also, the relative distance of each lower bound with respect to the best obtained one and to the state-of-the-art upper bound are provided. These important measures, along with the average CPU time, allow the reader to easily assess the quality-to-effort ratio of each lower bound. Actually, one major finding of this analysis is that the lower bound that seems to have the best performance in our preliminary work (namely LB3WT ) reveals not to be of much interest. Indeed, besides the fact that LB3WT is consistently dominated by LB4WT , it equals LB2WT in 96.33% of the cases while requiring much more computational effort. Finally, the worth of implementing each of the discussed lower bounds is appraised by analyzing the impact of its incorporation within a branch-and-bound algorithm. Furthermore, we investigated two additional bounding techniques, namely the Linear Programming (LP) scheme and the Lagrangian Relaxation (LR) scheme. The LP scheme relies on the P position-based formulation of the F2jST si j C j . Actually, it is important for the reader to know that our computational study revealed that the LP-based bound outperforms all of the discussed lower bounds in terms of effectiveness. However, its huge computation time compared to the other bounds makes it much less competitive in terms of efficiency. Indeed, the LP-based bound was shown to be worthless after having been assessed through two exact procedures, namely a branch-and-bound algorithm and a Mixed Integer Linear Programming (MILP) approach. On the other hand, the LR-based bounds consist of a generalization of the method that has been initially proposed by Van De Velde [30] for the P F2jj C j . Interestingly, embedding the waiting time-based concept within the LR framework enabled to derive promising lower bounds that exhibit a good performance within a branch-andbound algorithm. The remainder of the paper is organized as follows. In Section 2, we describe the lower bounds proposed in the literature. The newly proposed waiting time-based and single machine-based lower bounds are detailed in Sections 3 and 4, respectively. Section 5 displays the mathematical model that computes the LP-based bound. The proposed LR-based lower bounds are discussed in Section 6. Computational experiments on a large set of randomly generated instances are reported in Section 7. Section 8 concludes the paper with some directions for future investigations. 2. Lower bounds of the literature In this section, we describe the lower bounds that are proposed P in the F2jST si j C j literature. We start by describing the two lower bounds of Bagga and Khurana [11]. Then, we present the waiting time-based and the single machine-based lower bounds that have been proposed by Gharbi et al. [18]. 2.1. The lower bounds of Bagga and Khurana [11] Assume that the resource constraint of the second machine is relaxed. Then, M2 can now process any number of jobs at the same time. The obtained problem is thus a single machine one (denoted P by 1jST si ; qj j C j ) with setup times sj = s1,j, processing times pj = p1,j P and delivery times qj = p2,j for all j 2 {1, . . . , n}. Since nj¼1 qj is con-

P

stant, then the obtained problem is equivalent to 1jST si j C j . The optimal total completion time of this latter problem, denoted hereP after by LB1BK , is a valid lower bound for F2jST si j C j . Let C 1j denote the completion time of job j in the Shortest Processing Time (SPT) P sequence of the 1jj C j problem, which is obtained after merging the setup time and the processing time of each job j 2 {1, . . . , n}. Therefore, we have

LB1BK ¼

n n X X C 1j þ qj j¼1

j¼1

The computation of LB1BK requires sorting the jobs according to the nondecreasing order of their s1,j + p1,j. Thus, LB1BK can be computed in O(n log n) time. The second lower bound that has been proposed by Bagga and Khurana [11], denoted hereafter by LB2BK , assumes that s1,j = P p1,j = 0. In this case, a single machine problem 1jST si j C j with setup times sj = s2,j and processing times pj = p2,j(j 2 {1, . . . , n}) is obtained. Then, LB2BK is equal to the corresponding optimal total completion time which is obtained using the SPT rule after merging the setup time and the processing time of each job j 2 {1, . . . , n}. LB2BK can be computed in O(n log n) time. It should be pointed out that LB1BK and LB2BK are straightforward generalizations of the first and second bounds proposed by Ignall P and Schrage [22] for the F2jj C j , respectively. 2.2. Waiting time-based lower bounds The waiting time-based bounding scheme has been initially proposed by Gharbi et al. [18]. It relies on the minimum amount of time, denoted by dj, that a job j 2 {1, . . . , n} has to wait between its finishing time from M1 and its starting time on M2. Since C 1j is a lower bound of the completion time of job j on the first machine, then job j cannot starts before C 1j þ dj on the second machine. Thus, job j cannot end before C 1j þ dj þ p2j . Clearly, a valid lower bound P P P P for F2jST si j C j is LBWT ¼ nj¼1 C 1j þ nj¼1 p2;j þ D, where D ¼ nj¼1 dj denotes the total waiting time. Note that trivially setting dj = 0 for all j 2 {1, . . . , n} yields the first lower bound LB1BK of Bagga and Khurana [11]. Therefore, all the proposed waiting time-based lower bounds dominate LB1BK . Gharbi et al. [18] considered three scenarios on the number of job predecessors: a zero-predecessor, a one-predecessor, and a multiple-predecessor scenario. The first scenario assumes that job j is not preceded by any job, which means that the setup operation of job j on M2 starts at the same time as its setup operation on M1. Consequently, a lower bound on dj is d1j ¼ maxðs2;j  s1;j  p1;j ; 0Þ, P and a valid O(n log n)-time lower bound for the F2jST si j C j , is P P P LB1WT ¼ nj¼1 C 1j þ nj¼1 p2;j þ D1 , where D1 ¼ nj¼1 d1j . The second scenario generalizes the first one by observing that only one job has no predecessor, and any other job j could have a longer waiting time than d1j . Indeed, for each such job j, the setup operation on M2 has to wait until its predecessor, say job h, finishes its processing. Note that there are at least d1h þ p2;h units of time that must elapse between the finishing time of job h on M1 (which corresponds to the starting time of job j on M1) and its finishing time on M2. Consequently, if a job j is not the first scheduled job,  then a better lower bound on dj is d2j ¼ max 0; s2;j  s1;j  p1;j þ  1  minh–j dh þ p2;h Þ. Therefore, if a particular job j0 is the first one to be processed, then a lower bound on the total waiting time is P d1j0 þ j–j0 d2j . Hence, a valid O(nlogn)-time lower bound for the P P P F2jST si j C j is LB2WT ¼ nj¼1 C 1j þ nj¼1 p2;j þ D2 , where D2 ¼   P minj0 2f1;...;ng d1j0 þ j–j0 d2j .

Please cite this article in press as: A. Gharbi et al., The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies, European Journal of Operational Research (2013), http://dx.doi.org/10.1016/j.ejor.2013.05.031

4

A. Gharbi et al. / European Journal of Operational Research xxx (2013) xxx–xxx

The multiple-predecessor scenario advantageously extends the waiting time-based approach in the following way. Let Ci,j denote the completion time of job j on machine Mi(i 2 {1, 2}) in any feasible schedule, and [k] denote the job that is scheduled at position k.    ½k ½k1 Gharbi et al. [18] showed that dj ¼ max minh–j dh þ p2;h þ  s2;j  s1;j  p1;j ; 0 is a valid lower bound on dj if job j is scheduled

Consequently, a lower bound on D can be obtained by solving the assignment problem where the assignment costs are di,j (i 2 {0, . . . , n}; j 2 {1, . . . , n + 1}). Obviously, we set d j,j = 1 for all j 2 {1, . . . , n}. Let D4 denote the minimum total assignment cost. P Therefore, the following lower bound for the F2jST si j C j holds:

LB4WT ¼

j¼1

at position k. Using a dynamic programming algorithm, the computation of

½k dj

2

for all j, k 2 {1, . . . , n} can be performed in O(n )

time. Now, since each job has to be assigned exactly one position, then a better lower bound on D can be obtained by solving the assignment problem where the cost of assigning job j to position ½k

k is dj . If D3 denotes the minimum total assignment cost, then a P valid O(n3)-time lower bound for the F2jST si j C j is LB3WT ¼ Pn 1 Pn It should be noticed that LB3WT P j¼1 C j þ j¼1 p2;j þ D3 . LB2WT

P

LB1WT

P

LB1BK

[18].

2.3. Single machine-based lower bounds The single machine-based bounding scheme [18] assumes that the resource constraint of the first machine is relaxed. As a consequence, M1 can process any number of jobs at the same time. The obtained problem is a single machine scheduling problem, denoted P by 1jST si ; rj j C j , with setup times sj = s2,j and release dates rj = s1,j + p1,j. Therefore, the optimal solution as well as any lower P bound for 1jST si ; rj j C j constitutes a valid lower bound for the P F2jST si j C j . At this level, it should be noticed that the P P 1jST si ; r j j C j is NP-hard, since the 1jr j j C j is NP-hard [27]. Note 2 also that the lower bound LBBK proposed by Bagga and Khurana P [11] can be seen as a trivial lower bound for the 1jST si ; rj j C j where all the release dates are set to zero. Interestingly, Gharbi et al. [18] showed that 1jSTsi,rjjf and 1jrjjf P are equivalent, and that valid lower bounds for the F2jST si j C j P could be obtained through relaxing the derived 1jr j j C j instance. The first single machine-based lower bound, denoted hereafter by LB1SM , is derived by computing the optimal total completion time of P the preemptive version of the obtained 1jr j j C j problem. LB1SM can be computed in O(nlogn) by using the Shortest Remaining Processing Time (SRPT) rule: at any time schedule an available job having the shortest processing time [1]. It is worth noting that LB1SM seems to be similar in spirit to the SRPT-based lower bound proposed by P Ahmadi and Bagchi [1] for the F2jj C j . Nevertheless, it should be pinpointed that designing an SRPT-based lower bound for the P F2jST si j C j would not have been achievable without the key role of the equivalence result. The second single machine-based lower bound, denoted hereafter by LB2SM , is obtained by computing the O(n2)-time improved version of the preemptive lower bound that has been proposed by Della Croce and T’Kindt [16]. It should be noticed that LB2SM P LB1SM P LB2BK [18]. 3. New waiting time-based lower bounds In this section, we propose two new waiting time-based lower P bounds for the F2jST si j C j . The first lower bound is based on the observation that if job j is preceded by a job i, then a lower  bound on the minimum waiting time dj is di;j ¼ max d1i þ p2;i þ s2;j  s1;j  p1;j ; 0Þ. Note that, except the first (resp. last) scheduled job, each job has to be preceded (resp. succeeded) by another one. The first scheduled job is assumed to be preceded by a dummy job, denoted by job 0, with d0;j ¼ d1j for all j 2 {1, . . . , n}. Moreover, the last scheduled job is assumed to be succeeded by a dummy job, denoted by job n + 1, with di,n+1 = 0 for all i 2 {1, . . . , n}. Obviously, since job 0 cannot precede job n + 1, then we set d0,n+1 = 1.

n n X X C 1j þ p2;j þ D4 j¼1

Clearly, the computation of LB4WT requires O(n3) time. Proposition 1. LB4WT P LB2WT . Proof. The result follows since di;j P d2j for all i,j 2 {1, . . . , n}.

h

P Example 1. Table 1 depicts the data of a 5-job F2jST si j C j instance. The values of di,j(i,j 2 {0, . . . , n + 1}) are depicted in Table 2. The bold values correspond to the optimal assignment. We have D4 = 19 and P P LB4WT ¼ nj¼1 C 1j þ nj¼1 p2;j þ D4 ¼ 644 þ 174 þ 19 ¼ 837. Note that LB1WT ¼ 827; LB2WT ¼ 833, and LB3WT ¼ 836. It is worth mentioning that there is no dominance relationship between LB3WT and LB4WT , as shown by the following example. Example 2. Consider the three-job instance defined by s1,j = 2, ½1

½2

p1,j = 2, s2,j = 6, and p2j = 4 (j 2 {1, 2, 3}). We have: dj ¼ 2; dj ¼ ½3

8; dj ¼ 14ðj 2 f1; 2; 3gÞ. Therefore, we get D3 = 2 + 8 + 14 = 24 P P and LB3WT ¼ nj¼1 C 1j þ nj¼1 p2;j þ D3 ¼ ð4 þ 8 þ 16Þ þ ð4 þ 4 þ 4Þþ 24 ¼ 60. On the other hand, we have d0,j = 2(j 2 {0, 1, 2}), d1,1 = d1,2 = d2,0 = d2,2 = d3,0 = d3,1 = 8 and di,3 = 0 (i 2 {1, 2, 3}). The optimal assignment gives D4 = 18. Thus, we have LB4WT ¼ 54. Now, we describe a promising lower bound that can be obtained through the generalization of the lower bound LBDNT 1 of P Della Croce et al. [15] for the F2jj C j . Recall that the latter lower Pn 1 Pn 1 bound is equal to j¼1 C j þ j¼1 p2;j þ c (here C j are computed with zero setup times), where c is a lower bound on the following quantity:

CðSÞ ¼

n1 X

maxð0;p2;½j ðSÞ  p1;½jþ1 ðSÞÞ þ

j¼1

n1 X

maxð0;p1;½j ðSÞ  p1;½jþ1 ðSÞÞ

ð1Þ

j¼1

(pk,[j](S) denotes the processing time of the jth job on machine Mk according to the job sequence S). The value of c is computed by

Table 1 P The five-job F2jST si j C j instance of Example 1. Job

1

2

3

4

5

s1,j p1,j s2,j p2,j

6 22 37 41

21 22 11 38

11 32 19 29

38 24 33 30

42 37 0 36

Table 2 Computation of di,j values of Example 1.

0 1 2 3 4 5

1

2

3

4

5

6

9 1 47 38 39 45

0 18 1 0 0 4

0 26 14 1 6 12

0 21 9 0 1 7

0 0 0 0 0 1

1 0 0 0 0 0

Please cite this article in press as: A. Gharbi et al., The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies, European Journal of Operational Research (2013), http://dx.doi.org/10.1016/j.ejor.2013.05.031

5

A. Gharbi et al. / European Journal of Operational Research xxx (2013) xxx–xxx

P

Table 3 Computation of di,j values of Example 1. Job

1

2

3

4

5

j0

1 2 3 4 5 j0

1 62 53 73 96 9

9 1 0 19 40 0

17 14 1 25 48 0

12 9 0 1 24 0

0 0 0 0 1 0

0 0 0 0 0 1

P

the obtained 1jrj j C j problem. Since the 1jrj j C j is strongly NPhard, then LB3SM requires an exponential computation time. Nonetheless, several efficient branch-and-bound algorithms for the P 1jrj j C j exist in the literature. In our implementation, we used the branch-and-bound algorithm presented in [28]. Proposition 3. LB3SM P LB2SM . Proof. Obvious. h

adding a dummy job j0 and solving an assignment problem where the assignment costs are defined by:

wi;j ¼ maxð0; p2;i  p1;j Þ þ maxð0; p1;i  p1;j Þ 8i; j 2 f1; . . . ; ng; i – j wi;j0 ¼ wj0 ;i ¼ 0 8i 2 f1; . . . ; ng By using similar arguments to those of Della Croce et al. [15], it is P easy to prove that a valid lower bound for F2jST si j C j is

LB5WT ¼

n n X X C 1j þ p2;j þ D5 j¼1

An additional interesting by-product of the single machine equivalence theorem of Gharbi et al. [18] is the generalization of the lower bound LBDNT 2 of Della Croce et al. [15] that has been proP posed for the F2jj C j . We introduce the following notations:

j¼1

where D5 is equal to the optimal value of the assignment problem with the following assignment costs:

di;j ¼ maxð0; p2;i þ s2;j  s1;j  p1;j Þ þ maxð0; s1;i þ p1;i  s1;j  p1;j Þ

8i; j 2 f1; . . . ; ng; i – j di;j0 ¼ 0 8i 2 f1; . . . ; ng dj0 ;i ¼ d1i

Example 1 (Continued). Table 4 provides the data of the obtained P 1jST si ; r j j C j instance after relaxing the capacity of the first P machine. Table 5 depicts the data of the equivalent 1jrj j C j instance. The optimal non-preemptive sequence is 1-5-3-2-4 and we have LB3SM ¼ 843.

8i 2 f1; . . . ; ng

Actually, this result can be intuitively derived from that of Della P P Croce et al. [15] by viewing the F2jST si j C j as an F2jj C j where s1,[j] is merged with p1,[j], and s2,[j+1] is merged with p2,[j], for all j 2 {1, . . . , n  1} (recall that [j] denotes the job that is scheduled in position j). The computation of LB5WT requires O(n3) time. Example 1 (Continued). The values of di,j are depicted in Table 3. The bold values correspond to the optimal assignment. We have D5 = 32 P P and LB5WT ¼ nj¼1 C 1j þ nj¼1 p2;j þ D5 ¼ 644 þ 174 þ 32 ¼ 850.

 C ½j ðSÞ: the completion time of the jth job according to the P sequence S for the 1jST si ; r j j C j instance that is obtained after relaxing the capacity of the first machine.  C[j](S): the completion time of the jth job according to the P sequence S for the 1jr j j C j instance that is derived from the equivalence theorem of Gharbi et al. [18].  C2,[j](S): the completion time of the jth job on M2 according to P the sequence S for the F2jST si j C j instance. We state the following result that is derived from the equivalence theorem of Gharbi et al. [18]: Corollary 1. Let r denote the sequence of jobs obtained by the SRPT P rule on the preemptive version of the derived 1jr j j C j instance. For any sequence S, we have:

C ½j ðrÞ 6 C 2;½j ðSÞ 8j 2 f1; . . . ; ng Proof. For any sequence S, we clearly have

Proposition 2. LB5WT P LB1WT . Proof. Obvious since di;j P

d1j

C ½j ðSÞ 6 C 2;½j ðSÞ 8j 2 f1; . . . ; ng for all i, j 2 {1, . . . , n}. h

The following example shows that there is no dominance relationship between LB2WT and LB5WT . Example 2 (Continued). We have di,j = 6 for all i, j 2 {1, 2, 3}(i – j); and dj0 ;i ¼ 2 for all i 2 {1, 2, 3}. The optimal assignment gives D5 = 14. Thus, we have LB5WT ¼ 50 < LB2WT ¼ 54 (note that LB5WT > LB2WT in Example 1). 4. New single machine-based lower bounds In this section, we propose two new single machine-based lower bounds that outperform those of Gharbi et al. [18]. The first lower bound, denoted by LB3SM , can be derived by optimally solving Table 4 P The obtained 1jST si ; r j j C j instance of Example 1.

From Eqs. (8) and (10) of Gharbi et al. [18], we know that C ½j ðSÞ ¼ C ½j ðSÞ8j 2 f1; . . . ; ng. Therefore, we get

C ½j ðSÞ 6 C 2;½j ðSÞ 8j 2 f1; . . . ; ng The result follows since Chu [13] proved that, for any sequence S, we have

C ½j ðrÞ 6 C ½j ðSÞ 8j 2 f1; . . . ; ng



By using the same arguments of Della Croce et al. [15], along with Corollary 1, a valid single machine-based lower bound for P the F2jST si j C j , denoted hereafter by LB4SM , can be computed in the following way. Let C 1½j denote the completion time of the jth job on M1 according to the SPT rule after merging s1,j and p1,j for

Table 5 P The equivalent 1jr j j C j instance of Example 1.

Job

1

2

3

4

5

rj sj pj

28 37 41

43 11 38

43 19 29

62 33 30

79 0 36

Job r 0j p0j

1

2

3

4

5

0

32

24

29

79

78

49

48

63

36

Please cite this article in press as: A. Gharbi et al., The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies, European Journal of Operational Research (2013), http://dx.doi.org/10.1016/j.ejor.2013.05.031

6

A. Gharbi et al. / European Journal of Operational Research xxx (2013) xxx–xxx Table 6 P The 3-job F2jST si j C j instance of Example 3. Job

1

2

3

s1,j p1,j s2,j p2,j

1 3 4 4

1 3 2 2

1 3 4 4

all j 2 {1, . . . , n}. Denote by U and V the sorted vectors of p2,j and C ½j ðrÞ  C 1½j according to the nondecreasing order, respectively. The lower bound LB4SM is given by the following formula:

LB4SM ¼ LB1SM þ

n X

Eq. (2) minimizes the total completion time on M2. Constraints (3) ensure that each job j 2 {1, . . . , n} is assigned to exactly one position. Constraints (4) guarantee that each position k 2 {1, . . . , n} is held by exactly one job. Constraints (5) take into consideration the completion time of the job’s predecessor on each machine. Exceptional jobs with no predecessors are handled by Constraints (6) and (7). Constraints (8) enforce each job to finish processing on M1 before being processed on M2. The nature of each decision variable is displayed by Constraints (9) and (10). In the following, we denote by LBLP the optimal objective value that is obtained after solving the LP relaxation of the mathematical model (2)–(10). 6. Lagrangian relaxation-based lower bounds

maxð0; U j  V j Þ

j¼1

The computation of LB4SM requires O(nlogn) time. Proposition 4. LB4SM P LB1SM . Proof. Obvious. h Example 1 (Continued). We have U = (29, 30, 36, 38, 41) and Pn V = (19, 35, 43, 44, 44). Therefore, j¼1 maxð0; U j  V j Þ ¼ 10 and LB4SM ¼ 839. The following example shows that no theoretical dominance relationship exists between LB2SM and LB4SM . P Example 3. Consider the 3-job F2jST si j C j instance that is 2 defined in Table 6. We have LBSM ¼ 40 and LB4SM ¼ 38 (note that LB2SM < LB4SM in Example 1).

LR techniques have received a lot of attention in devising promP ising lower bounds for the F2jj C j . To the best of our knowledge, Van de Velde [30] was the first author who developed an LR-based P lower bound for the F2jj C j . Since then, numerous variants of this technique have been proposed in the literature [14,20,21]. In this section, we extend Van de Velde’s lower bound to the P F2jST si j C j and we show how to improve it by incorporating the waiting time concept that is described in Section 3. P First, consider the following F2jST si j C j formulation, where Cij denotes the completion time of job j 2 {1, . . . , n} on machine Mi(i 2 {1, 2}):

min

n X C 2j

ð11Þ

j¼1

C 1j P s1j þ p1j ;

j 2 f1 . . . ng

ð12Þ

C 2j P s2j þ p2j ;

j 2 f1 . . . ng

ð13Þ

C 1h  p1h  s1h P C 1j _ C 1j  p1j  s1j P C 1h ;

8h – j

C 2h  p2h  s2h P C 2j _ C 2j  p2j  s2j P C 2h ;

8h – j

5. A linear programming-based lower bound

C 2j P C 1j þ p2j ;

In this section, we introduce a Mixed Integer Linear ProgramP ming model for the F2jST si j C j problem. For that purpose, let xjk denote the decision variable that is equal to 1 if job j 2 {1, . . . , n} is scheduled at position k 2 {1, . . . , n}, and 0 otherwise. Let Cik denote the completion time of the job scheduled at position P k 2 {1, . . . , n} on machine Mi (i 2 {1, 2}). The F2jST si j C j can be formulated as follows:

The obtained sequence is a permutation one

min

n X C 2k

ð2Þ

k¼1 n X

8j 2 f1; . . . ; ng

xjk ¼ 1;

ð3Þ ð4Þ

j¼1

C iðk1Þ þ

n X

ðsij þ pij Þxjk 6 C ik ;

8k 2 f2; . . . ; ng;

j¼1

8i 2 f1; 2g

ð5Þ

n X ðs1j þ p1j Þxj1 6 C 11

ð6Þ

j¼1 n X ðs2j þ p2j Þxj2 6 C 21

ð7Þ

j¼1

C 1k þ

n X xjk p2j 6 C 2k ;

8k 2 f1; . . . ; ng

ð8Þ

8j; k 2 f1; . . . ; ng 8i 2 f1; 2g; 8k 2 f1; . . . ; ng

ð10Þ

j¼1

xjk 2 f0; 1g; C ik P 0;

ð17Þ

n X ðkj C 1j þ ð1  kj ÞC 2j þ kj p2j Þ

ð18Þ

j¼1

8k 2 f1; . . . ; ng

xjk ¼ 1;

ð15Þ ð16Þ

Constraints (12) and (13) ensure that the first scheduled job cannot start processing before its setup time is finished. Constraints (14) (respectively (15)) verify that M1 (respectively M2) can only setup or process one job at a time. Constraints (16) guarantee that the processing of job j 2 {1, . . .n} on M2 cannot start before its completion on M1. Now, assume that constraints (16) are relaxed and dualized via the vector of nonnegative Lagrange multipliers k = (k1, . . . , kn). Then, the following Lagrangian problem is obtained:

LRðkÞ ¼ min

k¼1 n X

j 2 f1; . . . ; ng

ð14Þ

ð9Þ

Subject to : ð12Þ—ð15Þ; and ð17Þ Using the same arguments of Van de Velde [30], LR(k) can be obtained in O(n log n) time by taking kj = l for all j 2 {1, . . . , n} (with 0 6 l 6 1). Indeed, it suffices to schedule the jobs according to the nondecreasing order of l(s1,j + p1,j) + (1  l) (s2,j + p2,j). Therefore, a P valid LR-based lower bound for the F2jST si j C j is LB0LR ¼ maxl2L LRðlÞ where L is a set of values that are arbitrarily selected from [0, 1]. In our implementation, we adopted the same values as in [30] by setting L ¼ f0; 0:05; 0:10; . . . ; 0:95; 1g. Interestingly, we can improve the value of LR(k) by considering the waiting time dj that is introduced in Section 3. Indeed, constraints (16) can be modified so that each job j 2 {1, . . . , n} has to wait for a minimum amount of time dj after its completion on M1 before starting its processing on M2. Therefore, constraints (16) can be substituted by the following valid ones:

Please cite this article in press as: A. Gharbi et al., The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies, European Journal of Operational Research (2013), http://dx.doi.org/10.1016/j.ejor.2013.05.031

7

A. Gharbi et al. / European Journal of Operational Research xxx (2013) xxx–xxx

C 2j P C 1j þ dj þ p2j ;

j 2 f1; . . . ; ng

ð19Þ

Table 8 Pairwise comparison of the single machine-based lower bounds.

By relaxing and dualizing constraints (19), the following objective function for the Lagrangian problem will be obtained:

LRw ðkÞ ¼ min

n X

ðkj C 1j þ ð1  kj ÞC 2j þ kj p2j Þ þ

j¼1

n X kj dj

ð20Þ

j¼1

Setting kj = l for all j 2 {1, . . .n} yields LRw(l) = LR(l) + lD where P D ¼ nj¼1 dj denotes the total waiting time. Since Di(i 2 {1, . . . , 4}) P is a lower bound on D, then a valid lower bound for F2jST si j C j is LBiLR ¼ maxl2L LRðlÞ þ lDi ði 2 f1; . . . ; 4gÞ. Clearly, LB1LR and LB2LR can be computed in O(n log n) time, whereas LB3LR and LB4LR can be computed in O(n3) time. Proposition 5.

LBiLR

P

LB0LR 8i

LB1SM

Proof. Obvious. h

LB3SM

LB4SM

LB2BK

99.92

99.92

99.92

99.92

LB1SM

–

75.58

87.75

73.46

LB2SM

0.00

–

81.83

72.92

LB3SM

0.00

0.00

–

70.04

LB4SM

0.00

19.00

25.79

–

Table 9 Pairwise comparison of the LR-based lower bounds.

LB0LR LB1LR LB2LR LB3LR LB4LR

2 f1; . . . ; 4g.

LB2SM

LB0LR

LB1LR

LB2LR

LB3LR

LB4LR

–

87.83

89.54

89.71

95.33

0

–

80.13

80.33

92.25

0

0

–

3.17

89.58

0

0

0

–

89.46

0

0

0

0

–

Proposition 6. LBiLR P LBiWT 8i 2 f1; . . . ; 4g. Proof. It suffices to observe that LRðlÞ þ lDi ¼ LBiWT 8i 2 f1; . . . ; 4g. h

for

l = 1,

we

have

7. Computational results All the discussed lower bounds were coded in C and compiled with the Microsoft Visual C++.net 8.0. All the experiments were conducted on a personal computer with an Intel i7 3.4 gigahertz processor and 16 gigabyte RAM. The assignment problems were solved using the code of Goldberg and Kennedy [19] available at http://www.avglab.com/andrew/soft.html. In this section, all the experiments were carried on a test bed of 2400 instances which were randomly generated in a fashion similar to that adopted in [6]. More precisely, the processing times were randomly generated using the discrete uniform distribution on [1, 100]. The setup times were uniformly drawn from [1, 100K], where K 2 {0.25, 0.5, 0.75, 1}. The number of jobs n was taken equal to 10, 15, 20, 25, 30, 35, 50, 70, 100, 200, 300 and 500 jobs. For each combination of n and K, 50 instances were generated. 7.1. Pairwise comparison of the lower bounds Actually, one major aim of this section is to bring a more detailed picture of the performance of the proposed lower bounds. A pairwise comparison between lower bounds belonging to the waiting time-based, single machine-based and LR-based lower bounds is given in Tables 7–9, respectively. In these tables, we provide for each pair of lower bounds LBrow and LBcol that are displayed in some given row and column, respectively, the percentage of times LBcol improves LBrow.

Table 7 Pairwise comparison of the waiting time-based lower bounds.

LB1BK LB1WT LB2WT LB3WT LB4WT LB5WT

LB1WT

LB2WT

LB3WT

LB4WT

LB5WT

89.42

91.17

91.29

96.38

99.96

–

82.46

82.63

93.33

99.88

0.00

–

3.67

90.79

99.88

0.00

0.00

–

90.63

99.79

0.00

0.00

0.04

–

99.46

0.00

0.00

0.08

0.42

–

Clearly, the results depicted in Tables 7–9 strongly support the theoretical dominance results provided by Propositions 1–6. More importantly, this pairwise comparison brings a more detailed picture of the preliminary results that have been obtained in [18]. Indeed, the implementation of the best obtained bound of [18], namely LB3WT , proves not to be worthwhile since it provides the same values as LB2WT in 2312 instances out of 2400. In particular, the two newly derived waiting time-based lower bounds with respect to [18], namely LB4WT and LB5WT , exhibit a much better performance than LB3WT . Indeed, although LB3WT has the ‘‘theoretical’’ advantage of being competitive with LB4WT and LB5WT , it outperforms them in only one and two instances, respectively, while being dominated by LB4WT in 2175 instances, and by LB5WT in 2395 instances. Clearly, LB5WT shows to be the most promising waiting time-based lower bound. On the other hand, LB3SM and LB4SM consistently outperform the single machine-based lower bounds of [18], namely LB1SM and LB2SM . In particular, LB4SM provides the best results since it outperforms LB2SM and LB3SM in 72.92% and 70.04% of the instances, respectively. As for the LR-based lower bounds, it is clear that considering the waiting time in the Lagrangian problem yields consistently better results. Indeed, even embedding the simplest evaluation of dj (namely d1j ) improves LB0LR in 87.83% of the instances. 7.2. Effectiveness/efficiency trade-off of the lower bounds In order to have a better picture of the quality-to-effort ratio of each lower bound LB, we provide the following measures in Tables 10–12:  UBgap: the average deviation of LB with respect to an upper bound UB, where the deviation is defined by 100(UB  LB)/UB. The upper bound is equal to the minimum value that is obtained by the two best heuristics that have been recently developed by Ladhari et al. [25], namely H3LSII and MCGLS.  LBgap: the average deviation of LB with respect to the best obtained lower bound LBmax, where the deviation is defined by 100(LBmax  LB)/LBmax.  Time: the average required CPU time in milliseconds. From Tables 10–12, we observe that all of the displayed lower bounds require extremely short average computation time, never exceeding 0.03 seconds. It should be highlighted that although

Please cite this article in press as: A. Gharbi et al., The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies, European Journal of Operational Research (2013), http://dx.doi.org/10.1016/j.ejor.2013.05.031

8

A. Gharbi et al. / European Journal of Operational Research xxx (2013) xxx–xxx

LB3SM (theoretically) requires an exponential computation time, it only takes 0.2 seconds, on average, for large-sized instances with 500 jobs. In fact, this behavior is due to the fact that all release P dates of the obtained 1jrj j C j problem are condensed at the beginning of the schedule. Consequently, after scheduling some jobs at the first positions, the remaining problem becomes polynomially solvable by the SPT rule. Not surprisingly, LB5WT has the best performance among the waiting time-based lower bounds, while

LB4SM shows the best behavior among the single machine-based lower bounds. Noticeably, the LR-based lower bounds offer the closest values to the upper bound along with very negligible computational effort, outperforming thus all the discussed lower bounds in terms of effectiveness/efficiency trade-off. Table 13 provides a comparative picture between the LP-based lower bound LBLP and the best lower bound of each family, namely LB5WT ; LB4SM ; LB2LR and LB4LR .

Table 10 Effectiveness/efficiency trade-off of the waiting time-based lower bounds. n

10 15 20 25 30 35 50 70 100 200 300 500 Avg.

LB1WT

LB2WT

LB3WT

LB5WT

LB4WT

UBgap

LBgap

Time

UBgap

LBgap

Time

UBgap

LBgap

Time

UBgap

LBgap

Time

UBgap

LBgap

Time

6.85 8.11 8.57 8.59 8.22 8.81 8.98 8.7 8.7 9.11 9.16 9.02 8.57

5.51 6.93 7.45 7.69 7.41 8.12 8.46 8.3 8.37 8.92 9 8.91 7.92

– – – – – – – – – – – 0.02 0.02

6.69 8 8.49 8.55 8.18 8.79 8.97 8.69 8.7 9.11 9.15 9.02 8.53

5.35 6.82 7.37 7.65 7.37 8.09 8.44 8.29 8.37 8.91 9 8.91 7.88

– – – – – – – – – – – 0.02 0.02

6.64 7.97 8.48 8.54 8.18 8.79 8.97 8.69 8.7 9.11 9.15 9.02 8.52

5.3 6.79 7.36 7.64 7.37 8.09 8.44 8.29 8.37 8.91 9 8.91 7.87

– – – – 0.01 0.02 0.03 0.06 0.13 0.49 1.08 3.23 0.63

6.05 7.42 8 8.18 7.87 8.5 8.77 8.56 8.61 9.07 9.13 9.01 8.26

4.7 6.24 6.87 7.27 7.06 7.8 8.25 8.15 8.28 8.87 8.97 8.9 7.61

– – – 0.01 0.02 0.03 0.06 0.12 0.28 1.44 3.67 13.02 2.07

4.85 6.4 7.1 7.38 7.19 7.88 8.3 8.21 8.35 8.93 9.03 8.95 7.71

3.48 5.2 5.96 6.47 6.37 7.18 7.77 7.8 8.02 8.73 8.88 8.84 7.06

– – – 0.02 0.02 0.04 0.1 0.23 0.53 2.87 7.96 29.23 4.56

(–) Means that the average CPU time is less than 0.01 milliseconds.

Table 11 Effectiveness/efficiency trade-off of the single machine-based lower bounds. n

10 15 20 25 30 35 50 70 100 200 300 500 Avg.

LB1SM

LB2SM

LB3SM

LB4SM

UBgap

LBgap

Time

UBgap

LBgap

Time

UBgap

LBgap

Time

UBgap

LBgap

Time

15.76 14.61 13.96 13.29 12.39 11.42 10.65 11.03 10.72 9.53 9.4 9.21 11.83

14.42 13.48 12.89 12.42 11.61 10.75 10.14 10.63 10.4 9.33 9.25 9.1 11.20

– – – – – – – 0.01 0.02 0.05 0.1 0.25 0.09

15.62 14.55 13.93 13.27 12.38 11.42 10.64 11.02 10.72 9.53 9.4 9.21 11.81

14.28 13.42 12.85 12.41 11.6 10.74 10.13 10.63 10.4 9.33 9.25 9.1 11.18

– – – 0.01 0.02 0.02 0.04 0.06 0.11 0.35 0.76 1.75 0.35

15.09 14.12 13.59 13.04 12.19 11.27 10.55 10.97 10.69 9.52 9.4 9.21 11.64

13.73 12.98 12.51 12.17 11.41 10.59 10.04 10.57 10.37 9.32 9.24 9.1 11.00

– 0.02 0.04 0.06 0.1 0.14 0.37 1 2.24 15.97 57.71 230.55 28.02

3.9 4.47 4.9 5.07 5.25 5.45 5.94 6.18 6.59 7.12 7.47 7.68 5.84

2.43 3.23 3.72 4.14 4.42 4.73 5.4 5.76 6.25 6.92 7.32 7.57 5.16

– – – – – – – 0.01 0.02 0.07 0.14 0.33 0.11

(–) Means that the average CPU time is less than 0.01 milliseconds.

Table 12 Effectiveness/Efficiency trade-off of the LR-based lower bounds. n

10 15 20 25 30 35 50 70 100 200 300 500 Avg.

LB0LR

LB1LR

LB2LR

LB3LR

LB4LR

UBgap

LBgap

Time

UBgap

LBgap

Time

UBgap

LBgap

Time

UBgap

LBgap

Time

UBgap

LBgap

Time

3.1 2.81 2.56 2.13 1.92 1.69 1.32 1.07 0.86 0.54 0.4 0.28 1.56

1.59 1.53 1.34 1.16 1.05 0.94 0.75 0.63 0.51 0.32 0.23 0.16 0.85

– – – – 0.01 0.02 0.03 0.06 0.09 0.23 0.4 0.74 0.20

2.92 2.67 2.44 2.04 1.84 1.62 1.27 1.04 0.84 0.52 0.39 0.27 1.49

1.4 1.39 1.23 1.07 0.97 0.87 0.7 0.6 0.48 0.31 0.22 0.15 0.78

– – – – 0.01 0.02 0.03 0.05 0.09 0.23 0.4 0.75 0.20

2.86 2.63 2.41 2.02 1.83 1.61 1.26 1.04 0.84 0.52 0.39 0.27 1.47

1.35 1.35 1.2 1.05 0.96 0.86 0.7 0.6 0.48 0.31 0.22 0.15 0.77

– – – 0.01 0.01 0.02 0.03 0.06 0.09 0.24 0.41 0.78 0.18

2.85 2.63 2.41 2.02 1.83 1.61 1.26 1.04 0.84 0.52 0.39 0.27 1.47

1.34 1.34 1.19 1.05 0.96 0.86 0.7 0.6 0.48 0.31 0.22 0.15 0.77

– – 0.01 0.02 0.03 0.03 0.06 0.12 0.22 0.72 1.5 3.98 0.67

2.63 2.44 2.22 1.88 1.7 1.49 1.18 0.97 0.8 0.5 0.38 0.26 1.37

1.11 1.15 1 0.91 0.83 0.74 0.61 0.54 0.44 0.28 0.21 0.14 0.66

– 0.01 0.02 0.02 0.03 0.04 0.1 0.19 0.37 1.69 4.09 13.8 1.85

(–) Means that the average time is less than 0.01 milliseconds.

Please cite this article in press as: A. Gharbi et al., The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies, European Journal of Operational Research (2013), http://dx.doi.org/10.1016/j.ejor.2013.05.031

9

A. Gharbi et al. / European Journal of Operational Research xxx (2013) xxx–xxx

We observe from Table 13 that LBLP yields the best values, being equal to LBmax for all instances with n P 50. Unfortunately, the required computational effort of LBLP is by far larger than that of the other bounds. For instance, LBLP requires an average computation time of about 358 seconds for n = 500, while LB4LR takes only 0.014 seconds. According to Table 13, the most promising lower bounds are the LR-based bounds LB2LR and LB4LR .

node of the search tree, one unscheduled job is added to the last position of an initial partial sequence. We adopted the depth-first node selection strategy. Moreover, for a better performance, the branch-and-bound algorithm includes the following features:  An upper bound provided by the two state-of-the-art heuristics, namely H3LSII and MCGLS [25], is computed at the root node.  The dominance criteria of [6,11,26] are implemented in order to eliminate a maximum number of nodes.  The search tree is consistently reduced by using the No-Good List pruning technique (see [23,28]).

7.3. Performance of the lower bounds within an exact algorithm The aim of this section is to better appraise the worth of implementing the most competitive lower bounds from each family (namely LB5WT ; LB4SM ; LB2LR ; LB4LR and LBLP) by analyzing the impact of their incorporation within an exact algorithm. For that purpose, we implemented five variants of a branch-and-bound algorithm, each of which corresponding to one selected lower bound. At each

Furthermore, in order to benchmark the implemented exact procedures, the MILP that is defined by Eqs. (2)–(10) has been solved using CPLEX 11.1 software package. A reduced set of generated instances has been considered where the number of jobs n

Table 13 Comparison of best lower bounds with LP. n

10 15 20 25 30 35 50 70 100 200 300 500 Avg.

LB5WT

LB4SM

LB2LR

LBLP

LB4LR

UBgap

LBgap

Time

UBgap

LBgap

Time

UBgap

LBgap

Time

UBgap

LBgap

Time

UBgap

LBgap

Time

4.85 6.4 7.1 7.38 7.19 7.88 8.3 8.21 8.35 8.93 9.03 8.95 7.71

3.48 5.2 5.96 6.47 6.37 7.18 7.77 7.8 8.02 8.73 8.88 8.84 7.06

– – – 0.02 0.02 0.04 0.1 0.23 0.53 2.87 7.96 29.23 4.56

3.9 4.47 4.9 5.07 5.25 5.45 5.94 6.18 6.59 7.12 7.47 7.68 5.84

2.42 3.22 3.72 4.14 4.42 4.73 5.4 5.76 6.25 6.92 7.32 7.57 5.16

– – – – – – – 0.01 0.02 0.07 0.14 0.33 0.11

2.86 2.63 2.41 2.02 1.83 1.61 1.26 1.04 0.84 0.52 0.39 0.27 1.47

1.35 1.35 1.2 1.05 0.96 0.86 0.7 0.6 0.48 0.31 0.22 0.15 0.77

– – – 0.01 0.01 0.02 0.03 0.06 0.09 0.24 0.41 0.78 0.18

2.63 2.44 2.22 1.88 1.7 1.49 1.18 0.97 0.8 0.5 0.38 0.26 1.37

1.11 1.15 1 0.91 0.83 0.74 0.61 0.54 0.44 0.28 0.21 0.14 0.66

– 0.01 0.02 0.02 0.03 0.04 0.1 0.19 0.37 1.69 4.09 13.8 1.85

1.57 1.32 1.24 1 0.88 0.77 0.57 0.44 0.36 0.22 0.17 0.12 0.72

0.03 0.02 0.02 0.02 0.01 0.01 0 0 0 0 0 0 0.01

1.5 3.06 6.43 11.54 18.68 30.93 91.8 272.41 949.46 12189.73 51253.99 358574.7 35283.69

(–) Means that the average time is less than 0.01 milliseconds.

Table 14 Performance comparison of the lower bounds within a branch-and-bound algorithm. B&B5WT

B&B4SM

B&B2LR

B&B4LR

B&BLP

MILP

n = 10 Solved Nodes Time

40 1007.5 0

40 442.2 0

40 306.5 0

40 298.2 0

40 156.6 0.06

40 43.8 0.02

n = 15 Solved Nodes Time

40 66525.7 0.09

40 15,499 0.02

40 4994.4 0.02

40 4744.9 0.02

40 1222.2 0.75

40 807.3 0.26

n = 20 Solved Nodes Time

40 11818602.7 14.8

40 646890.1 0.91

40 72,874 0.31

40 65568.5 0.39

40 15049.6 15.12

40 18985.2 5.46

n = 25 Solved Nodes Time

38 240880317.7 488.36

40 27644132.8 45.85

40 1,381,722 6.77

40 1324718.9 9.05

40 94085.4 157.2

40 156393.5 52.09

n = 30 Solved Nodes Time

26 542087911.1 1568.63

35 415168689.5 891.17

40 17078192.1 82.73

40 15488091.6 105.45

36 462435.3 920.9

35 1286365.7 660.80

n = 35 Solved Nodes Time

8 792126181.8 3054.82

17 830543005.1 2320.99

38 67878538.2 464.9

37 52,646,864 522.61

21 682663.4 2435.57

25 2452299.9 1758.24

n = 40 Solved Nodes Time

2 679253764.8 3443.26

4 1,121,722,359 3344.81

17 326053589.2 2598.32

17 218243809.5 2638.08

6 605447.7 3447.78

9 2916056.7 2998.14

Please cite this article in press as: A. Gharbi et al., The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies, European Journal of Operational Research (2013), http://dx.doi.org/10.1016/j.ejor.2013.05.031

10

A. Gharbi et al. / European Journal of Operational Research xxx (2013) xxx–xxx

does not exceed 40 jobs, and only 10 instances are generated for each pair (n, K). A time limit equal to 3600 seconds has been set for all the algorithms. In Table 14, we provide for each algorithm:  Solved: the number of solved instances within the time limit.  Nodes: the average number of explored nodes.  Time: the average CPU time (in seconds). It can be observed from Table 14 that B&B4SM dominates B&B5WT since it solves more instances while requiring less CPU time. Moreover, although LB4SM is much less effective than LBLP, its extremely short computation time seems to make it more worthwhile for relatively small instances. Indeed, both LP-based algorithms, namely B&BLP and MILP, are outperformed by B&B4SM in terms of average computation time for n 6 25. Beyond this size, MILP does clearly better than both B&B4SM and B&BLP. The best performance of the branch-and-bound algorithms goes with the ones using the LR-based lower bounds. Indeed, both of B&B2LR and B&B4LR exhibit the best behavior in terms of number of solved instances and average CPU time. For instance, for n ¼ 25; B&B2LR and B&B4LR solve all of the instances while requiring 13% and 17% of the CPU time required by MILP, respectively. Moreover, for the largest instances, B&B2LR and B&B4LR solve about 89% more instances than MILP does. A slight advantage is globally observed for B&B2LR . At this point, it should be emphasized that the computational effort of LB2LR can be reduced to O(n) time at each non-root node. This can be done using a preprocessing procedure that stores the sorted list of jobs for each value of l 2 L. 8. Conclusion This paper addresses the total completion time minimization problem on a two-machine flowshop with sequence-independent setup times. This scheduling environment has been intensely investigated from both theoretical and practical sides during the last decade. Several bounding strategies are proposed. In particular, embedding the waiting time-based strategy within a Lagrangian relaxation framework provides the best performance from both effectiveness and efficiency viewpoints. An interesting perspective for future research is to hybridize the single machine-based and the LR-based lower bounds in a suitable and efficient way. Also, a natural future investigation would be to extend the current research to the sequence-dependent environment. Acknowledgements Many thanks to two anonymous referees for their insightful comments that substantially improved the quality of the paper. Dr. Anis Gharbi and Dr. Talel Ladhari are grateful to Princess Fatimah Al-Nijriss Research Chair for Advanced Manufacturing Technologies for supporting this research. Also, the authors would P like to thank Dr. Anis Kooli for providing us with his 1jrj j C j branch-and-bound algorithm implementation. References [1] R.H. Ahmadi, U. Bagchi, Improved lower bounds for minimizing the sum of completion times of n jobs over m machines in a flow shop, European Journal of Operational Research 44 (1990) 331–336. [2] C. Akkan, S. Karabati, The two-machine flowshop total completion time problem: improved lower bounds and a branch-and-bound algorithm, European Journal of Operational Research 159 (2004) 420–429.

[3] F. Al-Anzi, A. Allahverdi, The relationship between three-tiered client-server internet database connectivity and two-machine flowshop, International Journal of Parallel and Distributed Systems and Networks 4 (2001) 94–101. [4] F. Al-Anzi, A. Allahverdi, A self-adaptive differential evolution heuristic for two-stage assembly scheduling problem to minimize maximum lateness with setup times, European Journal of Operational Research 182 (2007) 80–94. [5] A. Allahverdi, H.M. Soroush, The significance of reducing setup times/setup costs, European Journal of Operational Research 187 (2008) 978–984. [6] A. Allahverdi, Minimizing mean flowtime in a two-machine flowshop with sequence-independent setup times, Computers & Operations Research 27 (2000) 111–127. [7] A. Allahverdi, J.N.D. Gupta, T. Aldowaisan, A review of scheduling research involving setup considerations, Omega 27 (1999) 219–239. [8] A. Allahverdi, C.T. Ng, T.C.E. Cheng, M.Y. Kovalyov, A survey of scheduling problems with setup times or costs, European Journal of Operational Research 187 (2008) 985–1032. [9] A. Allahverdi, F. Al-Anzi, Using two-machine flowshop with maximum lateness objective to model multimedia data objects scheduling problem for WWW applications, Computers & Operations Research 29 (2002) 971–994. [10] A. Allahverdi, Two-machine flowshop scheduling problem to minimize maximum lateness with bounded setup and processing times, Kuwait Journal of Science and Engineering 33 (2006) 223–251. [11] P.C. Bagga, K. Khurana, Two-machine flowshop with separated sequenceindependent setup times: mean completion time criterion, Indian Journal of Management and Systems 2 (1986) 47–57. [12] P. Brucker, S. Knust, G. Wang, Complexity results for flow-shop problems with a single server, European Journal of Operational Research 165 (2005) 398–407. [13] C. Chu, A branch-and-bound algorithm to minimize total flow time with unequal release dates, Naval Research Logistics 39 (1992) 859–875. [14] F. Della Croce, M. Ghirardi, R. Tadei, An improved branch-and-bound algorithm for the two machine total completion time flow shop problem, European Journal of Operational Research 139 (2002) 293–301. [15] F. Della Croce, V. Narayan, R. Tadei, The two-machine total completion time flow shop problem, European Journal of Operational Research 90 (1996) 227– 237. [16] F. Della Croce, V. T’kindt, Improving the preemptive bound for the onemachine dynamic total completion time scheduling problem, Operations Research Letters 31 (2003) 142–148. [17] J. Fondrevelle, A. Allahverdi, A. Oulamara, M.-C. Portmann, Permutation flowshops with exact time lags to minimize maximum lateness, International Journal of Production Research 47 (2005) 6759–6775. [18] A. Gharbi, T. Ladhari, M.K. Msakni, M. Serairi, Polynomial lower bounds for the two-machine flowshop problem with sequence-independent setup times, in: Proceedings of the International Symposium on Combinatorial Optimization (ISCO 2010), Electronic Notes in Discrete Mathematics, vol. 36, 2010, pp. 1089–1096. [19] A.V. Goldberg, R. Kennedy, An efficient cost scaling algorithm for the assignment problem, Mathematical Programming 71 (1995) 153–177. [20] H. Hoogeveen, S.L. Van de Velde, Stronger lagrangian bounds by use of slack variables: applications to machine scheduling problems, Mathematical Programming 70 (1995) 173–190. [21] H. Hoogeveen, L.V. Norden, S.L. Van de Velde, Lower bounds for minimizing total completion time in a two-machine flow shop, Journal of Scheduling 9 (2006) 559–568. [22] E. Ignall, L.E. Schrage, Application of the branch and bound technique to some flow-shop scheduling problems, Operations Research 13 (1996) 400–412. [23] A. Jouglet, Ph. Baptiste, J. Carlier, Algorithms for Total Weighted Tardiness, Handbook of Scheduling: Algorithms, Models, and Performance Analysis, Chapman & Hall/CRC, 2004. [24] K. Kogan, E. Levner, A polynomial algorithm for scheduling small-scale manufacturing cells served by multiple robots, Computers and Operations Research 25 (1998) 53–62. [25] T. Ladhari, M.K. Msakni, A. Allahverdi, Minimizing the total completion time in a two-machine flowshop with sequence-independent setup times, Journal of the Operational Research Society 63 (2011) 445–459. [26] C.N. Potts, L.N. Van Wassenhove, A branch and bound algorithm for the total weighted tardiness problem, Operations Research 33 (1985) 363–377. [27] A.H.G. Rinnooy Kan, Machine Sequencing Problem: Classification, Complexity and Computation, Nijhoff, The Hague, 1976. [28] V. T’Kindt, F. Della Croce, C. Esswein, Revisiting branch and bound search strategies for machine scheduling problems, Journal of Scheduling 7 (2004) 429–440. [29] S.C. Trovinger, R.E. Bohn, Setup time reduction for electronics assembly: combining simple (SMED) and IT-based methods, Production and Operations Management 14 (2005) 205–217. [30] S.L. Van de Velde, Minimizing the sum of the job completion times in the twomachine flow shop by lagrangian relaxation, Annals of Operations Research 26 (1990) 257–268. [31] T. Yoshida, K. Hitomi, Optimal two-stage production scheduling with setup times separated, AIIE Transactions 11 (1979) 261–263.

Please cite this article in press as: A. Gharbi et al., The two-machine flowshop scheduling problem with sequence-independent setup times: New lower bounding strategies, European Journal of Operational Research (2013), http://dx.doi.org/10.1016/j.ejor.2013.05.031