The two-machine total completion time flow shop problem

EUROPEAN JOURNAL OF OPERATIONAL RESEARCH

!11 ELSEVIER

European Journal of Operational Research 90 (1996) 227-237

The two-machine total completion time flow shop problem F. Della Croce a,,, V. Narayan b, R. Tadei a a D~A.L, Politecnico di Torino, 10129 Torino, Italy b G.S.LA., Carnegie Mellon University, Pittsburgh, PA, USA

Received July 1994;revised November 1995

Abstract

In this paper we study the NP-hard scheduling problem of minimizing total completion time in a two-machine flow shop. Five known lower bounds are discussed and two new ones are presented. A new dominance criterion is also proposed. Several versions of a branch and bound method are derived by applying, both individually and combined, these lower bounds. A heuristic procedure is also presented that uses a constructive O(n 2) time method, which computes a good starting solution, together with a neighborhood search based on pairwise interchanges. Computational results show that the exact method can handle problems of up to 30 jobs in size within a reasonable amount of time and that the heuristic procedure has an average error of less than 0.5% from the optimal value and less than 2.7% from the lower bound. Keywords: Flow shop scheduling; Branch and bound; Neighborhood search

I. Introduction

This work examines the two-machine total completion time flow shop problem. The characteristics of the problem are as follows. Each job consists of two operations where the first operation must be processed on machine 1 and the second operation on machine 2; also, the second operation cannot begin before the first operation completes. All jobs become available for processing at time 0. Preemption on either machine is not allowed. The objective is to minimize the total completion time, i.e. the sum of the job completion times, on the second machine. Following the standard scheduling classifica-

* Corresponding author.

tion scheme of Graham et al. [9], we denote this problem as F2 IIECj. It is known [5] that at least one optimal solution to this problem is a permutation schedule without any idle time on the first machine, where a schedule defines a job order for each machine and a permutation schedule is a schedule in which every machine has the same job order. Both this problem and its preemptive relaxation are strongly NP-hard [6,8]. In one of the earliest papers on this topic, Ignall and Schrage [11] proposed a branch and bound algorithm based on two different lower bounds referred to as LB~s J and LBIs 2 in this paper. Kohler and Steiglitz [13] presented several heuristics for this problem. Ahmadi and Bagchi [1] proposed a lower bound (referred to as LBAB in this paper) and showed that it dominated LB~s 2. Van de Velde [14] presented a branch and bound based

0377-2217/96/$15.00 © 1996 Elsevier Science B.V. All rights reserved SSDI 0377-2217(95)00351-7

228

F. Della Croce et al. / European Journal of OperationalResearch 90 (1996) 227-237

on Lagrangian relaxation. He showed that his lower bound LB v dominated both LBm~ and L B m . Computational testing of the branch and bound on problems of up to 20 jobs in size were also presented in that paper. Hoogeveen and Van de Velde [10] applied slack variables to the Lagrangian relaxation approach proposed in [14]. We shall refer to their bound as LBHv. Finally Cadambi and Sathe [3] proposed a dominance criterion for adjacent jobs. In this work we computationally test the five above mentioned bounds and two new ones, by implementing them in different versions of a branch and bound method that applies also two known dominance criteria and a new one. The branching scheme of this method is such that a node at level k of the search tree corresponds to an initial sequence tr in which k jobs have been put in the first k positions. We show that the best version of the branch and bound procedure solves instances with up to 30 jobs to optimality within reasonable time. In order to be able to solve larger problems we present a heuristic method. The heuristic method is a combination of a constructive O(n 2) time procedure, which computes a good starting solution, with a descent neighborhood search based on pairwise interchanges. We also test the computational performance of the heuristic method. The paper proceeds as follows. In Section 2 all bounds are presented and illustrated on a 5-job example. Section 3 explains the dominance criteria. In Section 4 the heuristic algorithm is described. Section 5 contains detailed computational results and Section 6 concludes the paper with final remarks.

2. L o w e r b o u n d c o m p u t a t i o n

2.1. Notation and problem formulation Let Pk,j and Ck,j be the processing time and the completion time of job j on machine k where j ranges from 1 to n and k ~ {1, 2} respectively. The problem can be formulated as follows: min ~ C2,j ]=1

subject to C1,: >~P1,i Vj,

(1)

c2,j >1 C ,j +P2,j

(2)

C1,~ -PL~ >1C1,J v C1j - P l j / > C~,~ Vi,j i ~j,

(3) C2,i -P2,~ >/C2,j v C2,j -Pz,j >/C2,~ Vi,j i ~j,

(4) where (1) does not allow the processing of any job on machine 1 before time 0, (2) requires for each job that the second operation starts after the completion of the first operation and (3) and (4) indicate that machines 1 and 2 can process no more than just one job at a time. In addition, consider the following redundant constraints:

C2,j >/P2,y +

min Pl k Vj,

l
'

(5)

C2,i - P 2 , i ~ CI,j + P2,j v C2,j - P 2 , j >/ Cl,i 'J-P2,i

Vi,j i * j .

(6)

Also, as we can restrict the search for an optimal solution to the set of permutation schedules, consider the following constraint:

The solution is a permutation schedule. (7) Given a sequence S, let cS, j the completion time of job j on machine k according to S. Also, let

Pk,j(S) be the processing time and Ck,j(S) the completion time of the jth job on machine k according to S. The sequences we refer to in this paper are denoted as follows: • SPT~ - shortest processing time on the first machine, i,e. non-increasing order of the processing times on the first machine. • SPT 2 - shortest processing time on the second machine, i.e. non-increasing order of the processing times on the second machine. • JS - the Johnson's sequence [12] which solves the two-machine maximum completion time (F2 II Cmax) problem to optimality. • S R P T - shortest remaining processing time on the second machine assuming machine 1 with infinite capacity [1]. The SRPT sequence solves the single-machine total completion time preemptive problem with different release times (11 rj, pmtn [T.Cj) to optimality.

F. Della Croce et al. / European Journal of Operational Research 90 (1996) 227-237

• V~- non-decreasing order of CPl,j -1- (1 - c)P2,j (see Section 2.5). In the next subsections we will present seven lower bounds using the example of Table 1 to illustrate them. The optimal solution value for this example is 74.

2.2. The first lower bound of Ignall and Schrage (LBls,)

Therefore LBls 2 = 55.

2.4. The lower bound of Ahmadi and Bagchi

LB,s = ~ [ ( n - j + l ) p , j ( S P T 1 ) + P 2 , j

].

j=l

The computational complexity of computing LBls ~ is O(n log n) at the root node and O(n) for all the other nodes. For the example in Table 1 we have: p1,1(SPTI) = 1,

RI.2(SPT,) = 3,

p,.3(SPT,) = 4,

p,.4(SPT,) = 4,

pl,5(SPTI) = 8. Therefore

2.3. The second lower bound of lgnall and Schrage (LBIs 2) LB~s 2 [11] is obtained by relaxing constraints (1) and (3) and introducing constraints (5). The optimal solution of the relaxed problem is given by sequencing the jobs according to SPT2: LB,s2 = ~ [ ( n - j j=l

Vj.

(1')

The problem is now equivalent to a single machine problem with different release times with the objective of minimizing the total completion time (l[rj ]Y'.Cj). In the modified problem, Pl.j is then the release time r~ of job j and P2j its processing time. This problem is still strongly NP-hard, but its preemptive relaxation (llrj, pmtn lYnCh) is solvable in O(n log n) time by applying the SRPT (Shortest Remaining Processing Time) rule [1]. LBAB is given by the solution of the preemptive relaxation. LBAB can be shown to dominate LBls 2 [1]. Notice, however, that the complexity of computing LBAB remains O(n log n) for each node of the search tree. For the example in Table 1 we have: Cz, l = l , C l , 4 = 4,

LBis ' = 68.

C1,2 = 3 , CI,5 = 8.

Ci, 3 = 4 ,

Consequently, we have: C2,,(SRPT ) = 5,

C2,2(SRPT) = 8,

C2,3(SRPT ) = 9,

C2,4(SRPT ) = 16,

C2,5(SRPT ) = 24. Therefore LBAB = 62.

+ 1)pz,j(SPT2) + min Pl hi" l<~k<~n

' J

The complexity of computing LBis 2 is O(n log n) at the root node and O(n) for all the other nodes. For the example in Table 1 we have:

Table 1 Example Job

P 1,j

P 2.j

p2,,(SPT2) = 1,

P2,2(SPT2) = 2,

P 2 , 3 ( S P T 2 ) = 5,

P2,4(SPT2) = 7,

1 2 3 4 5

1 3 4 4 8

5 2 7 8 1

P2 s(SPT2) = 8, ""

min P1j = 1.

1 <~j<~n

(LBAB)

LBAB [1] is obtained by relaxing constraint (3). Consequently inequality (1) can be substituted by the equality

Cl.j=plj LBIs ~ [11] is obtained by relaxing constraint (4). The optimal solution of the relaxed problem is given by sequencing the jobs according to SPTI:

229

F. Della Croce et al. / European Journal of Operational Research 90 (1996) 227-237

230

2.5. The lower bound of Van de Velde (LB v) LB v [14] is obtained by applying the Lagrangian relaxation to constraint (2) and introducing constraints (5) and (7). A non-negative vector of multipliers (A 1. . . . . A,) is introduced to dualize constraint (2). The resulting Lagrangian problem is n

L ( A ) = m i n E [Aj(CI,j +P2,j) + (1 - Aj)C2j] j=]

subject to (1), (3), (4), (5) and (7), where 0~
for some constant c, 0 ~
The solution is obtained by scheduling the jobs in non-decreasing order of cpLj + (1 - c)p2, j. Given the optimal solution L(c) of the Lagrangian problem, a linear time lower bound for the restricted Lagrangian dual problem m a x { L ( c ) :0 < c ~< 1} is computed by applying a binary search over 21 different values of c = x/20, with x = 0, 1 . . . . . 20. For the example in Table 1 the best value of c is 0.6 and V0.6 = 1 - 2 - 3 - 5 - 4. This gives C1,1(V06)=1, C1,4(V0.6)

=

16

C,,2(V06)=4,

C1,3(V0.6)=8,

CLs(Vo.6) = 20

for the first machine and 62,1(V0.6) = 6 C2,4(V0.6) = 16

C2,2(V0.6) = 8 ,

C2,3(V0.6) = 15,

C2,5(V0.6) = 24

for the second machine. The corresponding value of LB v is 70.8. Notice that when c = 0, LB v = LBm2 and when c = 1, LB v = LBIs 1. The lower bound can be further improved by iteratively perturbing each Lagrangian multiplier At in a manner that does not affect the optimal sequence of the primal problem. We refer readers to [14] for a more detailed description to adjust the multipliers. As pointed out in [14] the final lower bound depends on the order in which the multipliers have been adjusted. This improvement procedure takes O(n 2) time. For the proposed example, when perturbat-

ing the Lagrangian multipliers Aj according to the 1"70.6 sequence, we obtain the following updated Afs: A1=

0.6,

A4 = 0 . 6 5 7 ,

A2 = 0.6,

A3 =

0.6,

As = 0 . 6 .

Consequently, we have L B v = 7 1 . 0 2 8 . The branch and bound implementation of this bound has a pre-processing phase at the root node. In this phase, the computation of the 21 sequences corresponding to each value of c and the perturbation of the Lagrangian multipliers per each sequence is performed. The lower bound for all other nodes can now be computed in O(n) time.

2.6. The lower bound of Hoogeveen and Van de Velde (LBHv) LBHv [10] is also obtained by applying the Lagrangian relaxation to constraint (2) and introducing constraints (5) and (7). In this case constraint (2) is formulated as an equality by introducing a nonnegative vector y = ( Y x . . . . . yn) E Y of slack variables where Y denotes the set of all slack variables corresponding to feasible schedules. We then have:

C 2 , j = C i j + p 2 j + y j Vj,

(2')

where yj can be interpreted as the time job j spends waiting in a buffer between the two machines after having completed its processing on the first machine. The approach used here is similar to the one used for LB v, with the solution to the slack variable problem min{cy I y ~ Y} being added to the Lagrangian primal problem solution. The presence of slack variables, however, forbids the improvement to LB v via the iterative perturbation of the Lagrangian multipliers. It is shown in [10] that a lower bound to the slack variable problem can be computed in O(n log n) time by solving a G i l m o r e - G o m o r y Traveling Salesman Problem [7]. The authors, however, solve its bipartite weighted matching relaxation, which can be done in O(n) time. As was for LB v, the computational complexity here is O(n log n) at the root node of the branch and bound and O(n) for all the other nodes.

F. Della Croceet al. / European Journal of OperationalResearch 90 (1996) 227-237 In the case o f the example in Table 1, we have:

Proof.

231

See A p p e n d i x A.1.

n

Y' yi= 1.

Finding F can be m o d e l e d as an asymmetric traveling salesman p r o b l e m ( A T S P ) with distances

j=l T h e multiplier c that maximizes n

Wi,j=

L ( c ) + c " Y'~ yj j=l

fori, j~{1,...,n}

is c = 0.6. T h e r e f o r e LBi-rv = 70.8 + 0.6 = 71.4.

2. Z Introducing a new lower bound based on the first machine (LBDNT) Let us reformulate the F2 IIECi p r o b l e m in the following m a n n e r : Find a sequence S that minimizes

~ C2,/(S)

j=l

subject to

C,,,(S) =Pl,l(S),

(8)

C2,,(S ) = C,,,( S) + P 2 , 1 ( S ) ,

(9)

c,,j+,(s) = c,,As) +p,,j+,(s) j = 1..... n - 1

(10)

C2,/+,(S ) = m a x [ C z j ( S ) + P 2 , j + I ( S ) ,

clj+l(s) j = 1.... ,n-

max(0, P 2 . i - P , . / ) + max(0, P , , i - P , j )

1.

if we add a d u m m y job n + 1 such that

Wi,n +

I =

for i = 1 . . . . . n,

0

wn+l.i = max(t2 - tl --Pl,i,

0)

for i = 1 , . . . , n,

w h e r e t k (k = 1, 2) denotes the earliest time that machine k b e c o m e s available for processing the u n s c h e d u l e d jobs, hence tt = t 2 = 0 at the root n o d e of search tree. We do not search for F, but we consider the bipartite weighted matching relaxation of the c o r r e s p o n d i n g A T S P which is polynomially solvable in O ( n 3) time. Let LB r be the solution of the bipartite weighted matching relaxation. T h e n LBDNT~ = LBIs I + LB r is a lower b o u n d to F2relJlEC y and therefore also to the F2 problem, but requires O ( n 3) time to be computed. In the case o f the example of Table 1, Table 2 gives the cross reference matrix of the wi,j coefficients for the weighted matching relaxation. By solving the c o r r e s p o n d i n g assignment problem, we obtain LB r = 5 and hence LBDNT, = 73.

I[ECj

(11)

By substituting constraint (11) with the less restrictive

C2./+1(S ) = m a x [ C , , / ( S ) + p z j ( S )

+ p2,/+,( S ),

Cl,j + l( S ) '[- P2,j + l( S ) ] = 1 . . . . . n - 1,

(12)

we obtain p r o b l e m F2r~ l IIF-Cj, which is a relaxation of the original problem.

1. A lower bound to F2re I IIECj /s given by LBml + F where F is the solution value of the problem o f finding a sequence S that minimizes n-1 Proposition

~] [max(0, P 2 a ( S ) j=l

i~j

- Pl.j+

1(S))

+ max(O, P I , j ( S ) - Pl,j +

1(S))]

2.8. Introducing a new lower bound based on the second machine (LBDNT2) T h e lower b o u n d LBma of A h m a d i and Bagchi can be improved in the following way. C h u [4] shows that for any given sequence S we have that Cl,y(SPT1) ~< C , , j ( S )

VJ

(13)

Table 2 Cross-reference matrix of the wi./ coefficients Job 1 2 3 4 5

6

1

oo

2

1

1

0

0

2 3 4 5 6

3 9 10 7 0

o~ 5 6 5 0

0 oo 4 4 0

0 3 ~ 4 0

0 0 0 oo 0

0 0 0 0 oo

F. Della Croce et al. / European Journal of Operational Research 90 (1996) 227-237

232

and C2j(SRPT ) ~< C2,j(S )

(14)

Vj.

Thus LB~= 0 + 0 + 1 + 3 + 4 = 8 and

Given that

c2,j(s) >1c,,j(s)

vj,

(15)

LBDNT2 = 62 + 8 = 70.

from (13), (14) and (15) we get 3. Dominance criteria

C2,j( S) j=l

Dominance criteria can significantly improve the efficiency of a branch and bound procedure by constraining the search space. Van de Velde [14] states:

1> ~ {max[C,,j(SPT1) + p z j ( S ) , j=l

C2,j(SRPT)] } If Pl,i <~Pl,j and Pz.~=P2,j, then job i precedes job j unconditionally.

= ~ C2,j(SRPT) j=l + ~ {max[0, p 2 j ( S ) j=l

- ( C z j ( S R P T ) - C I , ~ ( S P T 1 ) ) ] }.

(16)

To minimize (16), we search for a sequence S that minimizes max[0, P 2 j ( S )

In this paper we extend Van de Velde's criterion by stating a looser condition for forbidding certain ordering of jobs. Consider, in a branch and bound scheme, a branch cr of the search-tree, corresponding to a partial schedule of jobs, such that Ca,~ and C2,~ are the completion times of the last job ~ cr already sequenced on the first and second machine respectively. We have the following

j=l

- (C2,j(SRPT) - CI,j(SPT,))].

(17)

A lower bound LB a on (17) can be computed by sorting in non-decreasing order both the vector of (p2,j(S))'s and the vector of ( C 2 j ( S R P T ) CI,j(SPTI))'s. This can be proven through an interchange argument. Hence LBDNT2-----LBAB + LB a is a lower bound for F2 IIECj and obviously dominates LBAB, which in turn dominates LB~s:. Actually, from (16) we can derive that LBoNa% dominates LB~s' = ~]7-1[CIj(SPT1) +P2j] too. Notice that the complexity of solving LBDNT: is O(n log n). In the example of Table 1, the vector of (p2j)'s sorted in non-decreasing order is given by

Proposition 2. Given a starting subsequence ~r and a pair of unscheduled jobs i, j, if Pl,i <~Pl,j

(18)

and P2,i >~P2,j

(19)

and m a x ( C l , ~ + Pl,i + P2,i, C2,~ + P2,i)

~
(20)

then there exists at least one optimal solution not headed by ~rj. Notice that Van de Velde's statement holds as inequality (20) is always satisfied if Pz, i =P2a.

[1,2,5,7,8] and the vector [Czj(SRPT)-CI,j(SPT1)] sorted in non-decreasing order is given by [1, 4, 4, 4, 4].

Proof. See Appendix A.2.

We also use the following dominance criterion due to Cadambi and Sathe [3], where the variable

F. Della Croce et al. / European Journal of Operational Research 90 (1996) 227-237

/~ represents the total number of jobs already scheduled.

Proposition 3. If P2,i < P2,j

and P2,i--P2,j -t- max(0, Pl,i-Pl,j) + (n - / z + 1) [min(Pl,i,P2,j) -- min( P 2 , i , P l d ) ] <~O,

then job i precedes job j when they are adjacent in a sequence. Finally, by applying the dynamic programming dominance criterion [14], we have that: every branch aji such that

C2,i( trji ) >~C2,j( ~rij) and

C2,j( o'ji ) + C2,i( trji ) >1C2,i( trij ) + C2,j( trij ) can be pruned. In the case both conditions happen to be equalities, it is immaterial which branch to prune.

4. A heuristic procedure Here we propose a heuristic method which is divided into two major steps. In the first step, an O(n 2) time constructive procedure is performed in order to obtain quickly a good solution. The jobs are first sorted in non-decreasing order of the first machine processing times. Then a greedy approach is used in which a given job i is considered preferable to another job j if

C2,i( trij ) + C2j( trij ) <<,C2,i( trji) + C20( trji ) . The candidate job, the job that is to be scheduled next, is obtained with a forward approach where the current candidate job is iteratively compared with all jobs not yet sequenced. Thus n - 1 comparisons are required to choose the first job, n - 2 for the second job and so on for a total of ½n(n - 1) comparisons. The second step is a descent neighborhood search based on pairwise interchanges that finds an improvement to the current solution within

233

O(n 2) comparisons if one exists. Every time an improvement is found, the procedure restarts the search. In order to speed up the method, a flag is used in such a way that the procedure restarts the search at the point where the last improvement was obtained. This simple gadget significantly improved the speed of the heuristic method. The neighborhood of a solution is given by using the following operators: • API (Adjacent Pairwise Interchange). With n jobs this step is performed at most n - 1 times. • NAPI (Non Adjacent Pairwise Interchange). With n jobs this step is performed at most ½(n - 1)(n - 2) times. • EBSR (Extraction and Backward Shifted Reinsertion): given the sequence a - b - c - d - e - f g-h, consider extracting job g from its position and reinserting it backward just before job c. The resulting sequence is: a - b - g - e - d - e - f - h . With n jobs this step is performed at most ½(n - 1)(n - 2) times (EBSR is applied only to non adjacent jobs as for adjacent jobs it is coincident to API). • EFSR (Extraction and Forward Shifted Re-insertion). Analogously, consider extracting job c from its position and reinserting it forward just after job g. The resulting sequence is: a - b - d e - f - g - e - h . In this case too, with n jobs this step is performed at most ½(n - 1)(n - 2) times. While API and NAPI are commonly used as neighborhood operators, EFSR and EBSR are less frequently applied in scheduling problems. We point out that in our case their use, by widening the neighborhood, significantly improves the quality of the solution.

5. Computational study We have implemented several versions of a branch and bound method by using one or more of the lower bounds shown in Section 2. This method uses a best first search as branching strategy and applies the three dominance criteria mentioned before. An initial upper bound is also computed by running the heuristic procedure. With IS we refer to the version of the branch and bound which applies jointly LBIs t and LBm2

F. Della Croce et al. /European Journal of Operational Research 90 (1996) 227-237

234

which are the bounds used by Ignall and Schrage [11]. AB applies jointly LBIs t and LBAa as lower bounds, i.e. the bounds used by Ahmadi and Bagchi in [1]. V applies LB v in order to comply with [14] and analogously HV applies LBrrv in order to comply with [10]. DNT,~ applies jointly LBoN-r~ and LBDNT: while DNT~ applies jointly LBDNT~ and LB v. The assignment problem derived for computing LB~ (see Section 2.8) is solved with the Auction algorithm of Bertsekas [2]. In order to test the branch and bound procedures, 5 different problems sizes (n = 10, 15, 20, 25, 30) were chosen. For each problem size 20 different problems were generated. The processing times of the individual jobs at machine 1 and machine 2 were drawn at random from a uniform distribution U(1, 10). In order to limit the time taken by the procedures, a threshold was placed on the number of nodes generated. The procedures were terminated when the number of nodes generated exceeded 40,000. In order to determine the accuracy of the heuristic method, 13 different problem sets of sizes (n = 10, 15, 20 . . . . . 100) were generated. These were solved using both the heuristic method and the DNT~ version of the branch and bound procedure. As before, for each problem size 20 different problems were generated and the processing times of the individual jobs at machine 1 and machine 2 were drawn at random from a uniform distribution U(1, 10). Table 3 compares the performance of the different versions of the branch and bound procedures. For each version the first column (Nodes) reports the average number of nodes generated for the 20 problems. The second column (Sec)

reports the average time taken on a Sun Sparc 20. The third column (OF, optimum found) reports the number of instances out of 20 solved to optimality. Columns 1 and 2 are obviously not filled if the OF entry is smaller than 20. The performance of the different lower bounding methods was enhanced by incorporating the dominance criteria stated earlier in the paper. This made it possible to solve larger problems without increasing the investment in computational effort relative to the implementation of the lower bounds that were used originally. LB v is clearly the most effective lower bound while LBDN-r~ helps in reducing the number of visited nodes when combined with LB v. However the O ( n 3) complexity of LBD~rr~ reduces significantly the speed of the branch and bounds based on this bound. The weakness of DNT~ seems also to be strictly linked to a poor lower bounding method for the second machine. As a result (though not exploited here) when the sum of processing time on the first machine is significantly greater than the one on the second machine, DNT~ outperforms V. The fact that V outperforms HV (i.e. LB v outperforms LBHv) means that usually the perturbation of the multipliers gives a greater improvement than the slack variable approach. Therefore we did not use LBrrv in combination with some of the new bounds due to its consistently poorer performance versus LB v. We did not combine LBls ~ or LBIs: or LBAB with the other bounds given that all of them are theoretically dominated by some of the others. Table 4 reports the performance of the heuristic method in terms of accuracy. Accuracy was calculated as ( H e u r - Opt)/Opt, where Heur is

Table 3 Comparison of the different versions of the branch and bound method n = 10

IS AB DNTa HV V DNT~

n = 15

n = 20

n = 25

n = 30

Nodes

Sec

OF

Nodes

Sec

OF

Nodes

Sec

OF

Nodes

Sec

OF

Nodes

Sec

132 128 82 87 61 45

0.0 0.0 0.0 0.0 0.0 0.0

20 20 20 20 20 20

664 647 517 367 233 173

0.1 0.2 0.3 0.1 0.0 0.1

20 20 20 20 20 20

5525 5495 3303 3179 1514 1331

8.4 10.3 5.6 2.0 0.5 1.1

20 20 20 20 20 20

18571 18406 10456 7266 3962 3439

40.3 49.6 26.4 5.8 1.3 3.6

20 20 20 20 20 20

11528

39.2

OF 2 2 7 19 19 20

F. Della Croce et al. / European Journal of Operational Research 90 (1996) 227-237

235

6. Conclusions

Table 4 Performance evaluation of the heuristic method No. of H e u r . jobs

Heur-

t i m e (s)

LB

L ~

Heur%

Opt

Opt

Opt - LB %

-

O- p t

10

0.00

1.84

0.06

1.73

15

0.01

2.06

0.16

1.85

20

0.03

2.17

0.36

1.77

25

0.05

2.27

0.41

1.81

30

0.09

2.62

0.49

2.04 -

35

0.17

2.36

-

40

0.28

2.18

-

-

50

0.65

2.16

-

-

60

1.15

2.17

-

-

70

2.02

1.94

-

-

80

3.41

1.87

-

-

90

5.13

1.94

-

-

100

7.00

1.92

-

-

%

the solution value of the local search procedure and Opt is the optimal solution value. To enable the determination of the accuracy of the heuristic method for larger problems (from 35 up to 100 jobs), also the ratio ( H e u r - LB)/LB was computed. The first column in Table 4 is the problem size. The second column is the CPU time in seconds required by the heuristic procedure. We point out that, on the average, the computational effort required by the heuristic procedure increases in proportion to the cube of the problem size. The third column indicates the average percentage deviation of the heuristic method versus the lower bound computed in the DNTt3 version of the branch and bound method ( H e u r LB)/LB. The fourth column shows the average percentage deviation of the heuristic solution value versus the optimal solution value ( H e u r Opt)/Opt which was computed for problems up to 30 jobs. Finally, the last column shows the average percentage deviation of the DNTt3 lower bound versus the optimal solution value (OptLB)/Opt: also this entry is filled for problems up to 30 jobs. From Table 4 we notice that the average percentage deviation from the optimal solution value is smaller than 0.5% while the average percentage deviation from the LB is smaller than 2.7%: this confirms the high-quality performance of the heuristic procedure.

In this paper we have explored exact and heuristic methods for the two-machine total completion time flow shop problem. Several versions of a branch and bound procedure that use one or more lower bounds on a total of seven lower bounds (two new ones are introduced among them) were implemented. To enhance the strength of this procedure three dominance criteria were also applied. The best version of the exact algorithm solves instances with up to 30 jobs. As far as the heuristic procedures is concerned, it seems very efficient and effective for medium size problems (up to 100 jobs), where within few seconds it is able to reach a solution which is on average less than 2.7% far from the LB (and less than 0.5 far from the optimum for problems with up to 30 jobs). Finally we wish to point out that an interesting issue is the extension of the new proposed lower bounds to the two machine weighted case (F2 IlY'.wjfj) and to the general m-machine flow shop problem (F IIEfs).

Appendix

A.1. Proof for Proposition 1 From (9) and (12) we know that in the F2re l problem we search for a sequence that minimizes z = Cl,l(S) +p2,,(s) n-I

+ Z [ P z j + I ( s ) + max(C1,./(S) +Pz,j(S), j=l

n

= E j=l n-1

+ Z [max(0, C i j (S) + p 2 j ( S ) j=l

=

[c,,,(s)

+p2,,(s)]

j=l n--1

+ Y'. [max(O, P2.s(S) - p , , j + , ( S ) ) ] . j=l

F. Della Croce et aL / European Journal of Operational Research 90 (1996) 227-237

236

as

But,

n

n--1

n

= Ey=ICI,j(SPT 1) + Y~'j=I

~_~jflCl,j(S)

~inj + 1[max(0, p I,j(S) - p 1,i(S))], we get

But, if

C ~ = C?,i

and

C2~,j< C~,i,

n-1 z=LBIsI+

~

[max(0, p 2 , y ( S ) - p l j + l ( S ) ) ]

then

j =1

C~l,m ~- C~, m V m ~ (b

n-i + ~

~

[max(0, p l , y ( S ) - P l , i ( S ) ) ]

and consequently

jffili=j+l n--1 >t L B , s I +

C~2,m<~.C~,m V m ~ & .

[]

E [max(0, p 2 j ( S ) - p l , j + l ( S ) ) j=l Acknowledgements

+max(O, pl,j(S)-pl,j+l(S))]

.

[] T h e authors wish to thank the a n o n y m o u s referees whose suggestions led to a significant i m p r o v e m e n t of an earlier version of this paper.

A.2. Proof for Proposition 2 S u p p o s e by contradiction that oq heads an optimal solution which can be expressed without loss of generality as

2/= trjzi~b, w h e r e ~" and & are subsequences of jobs. W e will prove that /3 = trizj& dominates T, by verifying that

E c¢,k + c¢,, + E k~,r

lez

c¢,, + cL. +

E c ,k + c L + E kEcr

l~

E me4,

+ c[,, + E m~b

Clearly, the completion times of jobs in tr are the same for /3 and T- F r o m (18) and (20) we also have that

C~, i < C~,j

and

C~,, < C~j.

Therefore

C~2,t <~C~, t Vl ~ ~'. This m e a n s that since c ,j = we also have that

C~2j <~C~, i

due to ( 1 9 ) .

References

[1] Ahmadi, R.H., and Bagchi, U. (1990), "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, 331-336. [2] Bertsekas, D.P. (1988), "The auction algorithm: A distributed relaxation method for the assignment problem", Annals of Operations Research 14, 105-123. [3] Cadambi, BW., and Sathe, Y.S. (1993), "Two-machine flowshop scheduling to minimize mean flow time", Opsearch 30/1, 35-41. [4] Chu, C. (1992), "A branch-and-bound algorithm to minimize total tardiness with different release times", Naval Research Logistics 39, 265-283. [5] Conway, R.W., Maxwell, W.L., and Miller, L.W. (1967), Theory of Scheduling, Addison-Wesley, Reading, MA. [6] Du, J., and Leung, J.Y.T. (1993), "Minimizing mean flow time in two-machine open shops and flow shops", Journal of Algorithms 14/1, 24-44. [7] Gilmore, P.C., and Gomory, R.E. (1964), "Sequencing a one state variable machine: a solvable case of the traveling salesman problem", Operations Research 12, 655-679. [8] Garey, M.R., and Johnson, D.S., (1979), Computers and Intractability, Freeman, San Francisco, CA. [9] Graham, R.L., Lawler, E.L., Lenstra, J.K. and Rinnooy Kan, A.H.G. (1979) "Optimization and approximation in deterministic sequencing and scheduling: A survey", Annals of Discrete Mathematics 5, 287-326. [10] Hoogeveen, J.A., and Van de Velde, S.L. (1993) "Stronger Lagrangian bounds by use of slack variables: Application to machine scheduling problem", in: G. Rinaldi and L. Wolsey (eds.), Proceedingsof the Third IPCO Conference, Erice, Italy, 195-208.

F. Della Croce et al. /European Journal of Operational Research 90 (1996) 227-237 [11] Ignall, E., and Schrage, L. (1965) "Application of the branch and bound technique to some flow shop scheduling problems", Operations Research 13, 400-412. [12] Johnson S.M. (1954), "Optimum two stage and three stage production schedules with setup times included", Naval Research Logistics Quarterly 1, 61-68. [13] Kohler, W.H., and Steiglitz, K. (1975), "Exact, approxi-

237

mate and guaranteed accuracy algorithms for the flowshop problem n - 2 - F - F " , Journal of the Association for Computing Machinery 22 106-114. [14] Van De Velde, S.L. (1990), "Minimizing the sum of job completion times in the two-machine flow-shop by Lagrangean relaxation", Annals of Operations Research 26, 257-268.