two branch and bound algorithms for the permutation flow shop problem

E L S E V I E R European Journal of Operational Research 90 (1996) 238-251

EUROPEAN JOURNAL

OF OPERATIONAL RESEARCH

Two branch and bound algorithms for the permutation flow shop problem

J a c q u e s C a r l i e r a'*, I s m a i l R e b a i "b.l a Laboratoire HEUDIASYC CNRS URA 817, Universit~ de Technologie de Compi~gne, B.P. 649, 60206 Compi~gne Cedex, France

b Ecole Centrale Paris, Universit~ de Technologie de Compi~gne, Laboratoire Productique et Logistique, Grande Voie des Vignes, 92295 Chdtenay-Malabry Cedex, France

Received September 1994; revised March 1995

Abstract

The objective of this paper is to present two exact methods for the permutation flow shop problem. The first method is based on immediate selections and optimal adjustments of heads and tails. The second method consists in recursively enumerating jobs potentially processed first (inputs) and jobs which would be processed last (outputs) on machines. It is found that this second method gives better results than the first. However, the first method becomes more efficient when initial heads and tails are added.

Keywords: Flow shop scheduling; Exact methods; Heads and tails; Immediate selection; Branch and bound method; Input and output

1. Introduction

In the permutation flow shop problem (PFS), a special case of the flow shop problem, N jobs have to be processed on M machines with the objective of minimizing the makespan. The flow shop differs from the job shop since the machine sequences are indepen- dent of the jobs whereas the permutation flow shop is characterized by identical job sequences on all the machines.

Being a special case of the job shop problem, PFS is more constrained. Both the general flow shop problem and the job shop problem have been shown to be NP-hard in the strong sense [ 14]. Both problems have been the subject of numerous research efforts [ 1,17].

* Corresponding author. E-mail: [email protected] t E-mail: [email protected]

Although most investigations were directed towards heuristics [10,12,21,25], several authors have proposed exact methods based on branch and bound pro- cedures [ 4,12,13,15,19 ]. In this paper we propose two branch and bound methods for the PFS problem. The first one is based on the tools which were introduced by Carlier and Pinson [5-8,18] for the job shop problem and which have been subsequently developed by Brucker et al. [2,3]. Essentially, these authors used immediate selections of disjunctions. Since two jobs cannot be scheduled at the same time on a machine, disjunctions are not specific to job shops but are also present in flow shops. A first set of results was reported in a previous publication [9]. In the second method, PFS is modeled differently: we disregard disjunctions and consider sets of jobs instead. At each node of the search-tree, we fix one job as input or output of machines, i.e. we fix a job to be processed before or after

0377-2217/96/$15.00 (~) 1996 Elsevier Science B.V. All fights reserved S S D 1 0 3 7 7 - 2 2 1 7 ( 9 5 ) 0 0 3 5 2 - 5

J. Curlier, I. Rebai’/European Journul of Operationul Research 90 (1996) 238-251 239

all others. Both methods use a variation of the depth-

first search strategy [ 111. Although we consider here a basic PFS with some variations, we plan to investi- gate the performance of both methods on generalized

PFS as studied in the literature [ 16,20,22,23]. The organization of the paper is as follows. In Sec-

tion 2, we give a definition of PFS together with the

assumptions made and the notation used. In Section 3,

a detailed description of the first method and its algorithm are given. We present results of this method obtained on benchmarks issued from the literature [5]

as well as on a new set of randomly generated problems [ 21,241. In Section 4, the second method is presented together with its computational results. An ad- ditional set of randomly generated problems is used

to explout the fact that this method can handle opti-

mally larger problem instances. Concluding remarks and future extensions of both methods are presented

in Section 5.

2. Notation

2.1. The PFS problem

In a PFS, N jobs have to be processed on M machines. The processing of a job on a machine is called an operation. The following assumptions are made:

each machine can process at most one job at a time; the operation of a job i on a machine m will be denoted as (i, m) or (i) if no ambiguity arises;

the processing of a job i on a machine m takes an uninterrupted period of time pi,m (no preemption allowed) ; a job has exactly M operations; the processing order of the jobs through the machines is fixed, it is the same for all jobs and is equal

to 1,2,. . . , M; the order by which the jobs are processed on any machine (operating sequence) is identical and is

not known; an operating sequence has to be determined in order to minimize the makespan C.

,.2. Schedule and solution

On Fig. 1, two optimal flow shop operating se- Carlier and Pinson [ 6-81 have proposed branch and

quences are shown. The first one is 2-3-4-1, while bound methods for solving job shops. They used im-

Fig. 1. The two optimal operating sequences.

the second is 2-4-3-l. The makespan of the corresponding schedules is 33.

We define LB as a lower bound and UB as an upper bound on the optimal schedule. By definition, a solution is a schedule with a makespan smaller than or equal to UB.

2.3. input and output of machines

In both methods, the set J of jobs not yet sequenced is associated with each node of the search-tree. Only one job of J will be fixed for branching and processed before all others (input) or after all others (output).

In the sequel, IN(J) is defined as being a set of jobs that could be input of J, i.e. jobs that could be scheduled before all other jobs of J on all the machines. Likewise, OUT(J) is defined as a set of jobs that could be outpur of J, i.e. jobs that could be scheduled after all other jobs of J on all the machines.

It should be noted that these same terms are associated with machines: we deal with input and output of machines, since in a PFS, operating sequences are not dependent of machines.

3. Branch and hound method based on immediate selections

240

mediate selections and optimal adjustments of heads and tails. In this section, this approach is applied to PFS and some computational results are given. In our branch and bound method, the PFS is modeled by a disjunctive graph, while heads and tails are defined on operations.

3.1. PFS model

J. Carlier, L Rebdi / European Journal of Operational Research 90 (1996) 238-251

Table 1 Initial values of heads and tails

3.1.1. Dis junct ive graph

PFS is modeled by a disjunctive graph g = (G, D) , where G = (X, U) is a conjunctive graph and D a set of disjunctions. Two operations i and j , executed by the same machine, are said to be in disjunction since they cannot be processed at the same time. The corresponding disjunctive constraint is represented by a pair [ i , j ] . A disjunction [ i , j ] is selected if, at a node of a search-tree, i has to be processed before j , or vice versa. From here on, the term "selected" will be used in accordance with this definition.

Fig. 2 shows the disjunctive graph associated with the flow shop of Fig. 1. In order to build a schedule, the disjunctive constraints should be selected, thereby fixing an operating sequence for all the machines. A selection is called complete if all the disjunctions have been selected. The result is a conjunctive graph which allows to calculate the makespan.

Whenever a makespan corresponding to the conjunctive graph is less than or equal to UB, a solution to the PFS is attained. This schedule is called feasible.

Fig. 2. A disjunctive graph.

Job Machine 1 Machine 2 Machine 3

r q r q r q

3.1.2. Heads ans tails

Each job i on machine m is charecterized by a head ri,m, a processing time Pi.ra and a tail qi,m.

Initially, heads and tails take the following values: ri, m = l ( O , ( i , m ) ) and qi,m = l ( ( i , m ) , * ) - P i , m , where l ( a , b) is the longest path from a to b on the graph G, 0 and • being dummy source and sink of G respectively. For the graph of Fig. 2, the initial values of r and q are given in Table 1. When ri. m (or qi,m) is adjusted, the processing order of job i through the machines is used to consequently modify heads (or tails) of job i on other machines. Generally, if ri, m

is modified, ri, m, for m I >-- m may also be modified. Symmetrically, if qi,m is modified, qi,ra' for m I ~ m may also be modified. The symbols " ~ " and " ~ " denote predecessor and successor relations in the conjunctive graph G.

3.2. Adjustments

An efficient branch and bound method may benefit from the definition of one-machine problems, restrict- ing the flow shop to the operations executed by this machine and relaxing disjunctive constraints related to other machines. In such problems, a set 1 of operations has to be sequenced on a single machine in order to minimize the makespan.

3.2.1. Local operations Since we consider one-machine problems, each op-

eration i is defined by a head ri, a processing time Pi and a tail qi. This means that i cannot be processed earlier than ri or later than C - qi, and that it takes pi time units for i to be processed.

(a) Immediate selection on disjunctions. For each disjunction [ i , j ] , we evaluate El = ri @ Pi d- p j -~ qj

! 0 10 6 2 14 0 2 0 15 3 8 I0 0 3 0 12 5 5 12 0 4 0 9 9 3 15 0

J. Carlier, 1. RebaT / European Journal of Operational Research 90 (1996) 238-251 241

0 2

3 4 5

I0 15 22 23 24 27 30

Fig. 3. PJPS.

8 11 17 20 27 33 35

F i g . 4 . D J P S .

(i processed before j ) and E2 = rj + pj + Pi + qi ( j processed before i). If both El and E2 are higher than UB, there exists no solution. If either E! or E2 is higher than UB, we should select the disjunction in the opposite direction. For instance, if El > UB and E2 ~< UB, j is definitely fixed before i for all cases. This means that ri could be set to max(ri , rj q - p j ) and qj to max (q j, qi + Pi ).

Whenever an adjustment is made for a given machine according to the immediate selection on disjunctions, the same adjustment is done for all the machines. This is quite possible since the PFS has identical operating sequences for all the jobs on all the machines.

(b) Jackson's preemptive schedule. In order to ad- just heads and tails and to compute lower bounds, we solve a preemptive version of a simple machine makespan problem with job heads and tails. A Jack- son's preemptive schedule (JPS) is the list schedule associated with the most work remaining priority dis- patching rule. To build a primal JPS (PJPS), jobs are considered in increasing order of their heads. Among the jobs available at time t, the one with the largest tail is scheduled, even if the machine is not idle. This means that preemption is allowed.

To illustrate this procedure, let us consider the five- job one-machine problem defined by heads, processing times and tails as given in Table 2. The PJPS schedule is given in Fig. 3. Its makespan is max(Ci +q i ) = 42.

For the dual case (DJPS), at any time t, jobs available according to their tails are considered. Among them, the one with the largest head is scheduled, even if the machine is not idle. The corresponding schedule is given in Fig. 4. Its makespan is max(Ci + ri) = 42.

In order to define the adjustment using JPS, let p+ denote the residual processing time of operation i at

Table 2 One-machine example for JPS

i r p q

i 4 3 8 2 0 5 5 3 2 9 10 4 10 6 I1 5 15 7 20

time t in JPS. As a result P7 -- Pi - P+. By definition, a subset A of operations is called an

ascendant set of operation c if c does not belong to A and minj~Au{c} rj h- EjEAU{c} PJ + minjEA qJ > UB. In this case, c has to be processed after all jobs of A. Thus, rc could be adjusted.

An O(n) algorithm for optimally adjusting rc (in the primal case) runs as follows [7] :

1. build JPS up to t = rc; 2. take the operations of K + = { j E 1 ] p f >

0 and qj > qc} in increasing order of qj; 3. let s be the first operation such that rc + Pc +

~-~der~" P+ + qs > UB (if any exists), with K c =

{ j E K + I qj >>- qs}: 4. rc = m a x ( r c , a c ) , where ac = maxjeK~. Cj and Cj

is the completion time of operation j in the JPS.

For instance, if UB = 42 and c = 4, we would have Kc + = {5}, K~' -- {5}, s = 5 and rc would be set to 22.

Adjusting all the heads (primal case) can be done in O(n2). These adjustments can also be computed with a time complexity of O(n logn ) using more so- phisticated algorithms [ 2,3,8 ]. Tails could be adjusted symmetrically (dual case).

( c ) Another simple immediate selection. Another local adjustment can be done by applying the follow-

242 J. Carlier. I. Reba'i / European Journal o f Operational Research 90 (1996) 238-251

ing result: let IS(c, Kc) = rc + Pc + )-~jer~. P f + qs (the same notations are valid as in the previous para- graph). Ifp~- > 0 and IS (c ,K c) + P s > liB, then s is processed before c in any solution [8].

- All the evaluations of a column j are higher than UB: j cannot be an output and it is deleted from the possible output set OUT(J ) .

- If only one potential input (resp. output) remains, it is fixed definitely.

(d) Adjustments based on inputs and outputs. As an example, consider a set J consisting of three operations il, i2 and i3. In terms of J potential inputs, three cases are possible: il, i2 or i3. The objective is to eliminate all cases leading to an incoherency. If, for instance, on fixing il as input, Scheme a below yields a value higher than UB, il would never be an input of J. It follows that only i2 and i3 could be inputs. If branching in the search-tree is done with i2 as an input, then, in the new node, J would consist of two jobs: il and i3.

In general, J is equal to I, the set of all N jobs in the beginning of a PFS branch and bound procedure. At each node, sets I N ( J ) and OUT(J ) are determined for branching purpose. Initially, J is the set of all jobs in disjunction. Then, Scheme a is computed for each job of these two sets. Jobs that give an evaluation higher than UB are eliminated.

Scheme a . For each job i and machine m, the quan- tities ri,m + ~'~j Pj, m + minj_{i} qj, m are computed and the maximum over all the machines is taken. If it is higher than UB, we conclude that i is not an input for the set J and does not belong to I N ( J ) . The same reasoning is used for outputs [4].

3.3. Lower bounds: Johnson's and Jackson's schedules

Several lower bounds can be found in the literature. Generally, a compromise is obtained between the sharpness of a lower bound and its computational re- quirements. Lower bounds are mostly derived from partial schedules. It is found that the bounds derived from Jackson's schedule and Johnson's schedule are both effective and computationally efficient.

3.3.1. Jackson's preemptive schedule A first lower bound can be obtained by building

a JPS on machine m. The lower bound LBm on the makespan can be computed as:

max h( K) , rc_t

where

h(K) = min rim + E P j , m + minqim. jEK " jEK "

jEK

JPS can be computed in O (n log n) steps [ 5 ]. A lower bound LB I for the PFS is the maximum LBm taken over all the machines.

3.2.2. Global operations Potential inputs and outputs at a node k being de-

termined, it is possible to eliminate more jobs before branching actually occurs. If a new input at a node k is chosen, the problem is modified accordingly and checked for an incoherency. This procedure can be illustrated by associating potential inputs to the rows and potential outputs to the columns of a matrix. Each intersection of row i and column j with i ~ j repre- sents a case where i is the input of J and j its output. Matrix entries are filled for each case by computing LB l and LB 2 (cf. Section 3.3). The following cases may occur: - All the evaluations of a row i are higher than UB: i

cannot be an input and it is deleted from the possible input set I N ( J ) .

3.3.2. Johnson's schedule Another lower bound, LB 2, for the PFS can be ob-

tained by building Johnson's schedule for two consec- utive machines m and m + 1. The scheme is as follows:

Let

G(m, J) = min ri, m + Johnson(J, m, m + 1 ) ir.J

+ min qi.m+l, iEJ

where Johnson (J, m, m + 1 ) is the duration of processing jobs of set J on machines m and m + 1 according to Johnson's schedule. The lower bound is then computed as:

LB 2-- max G ( m , J ) . l<.m<.M--I

J. Carlier, L Reba'i / European Journal of Operational Research 90 (1996) 238-251

IN(J)

J \ {IN(J) O OUT(J)}

OUT(J)

Fig. 5. Repartition of jobs of J at a given node for all machines.

3.4. Branching scheme

Among the two sets IN(J) and OUT(J) , the one with the smaller cardinality is chosen for branching. Let this set be denoted as SET(J) . Since each new branching permits to fix an element of one of these two sets as input or output, the number of possible branchings is the lowest. Furthermore, evaluations for inputs and outputs are considered at the same time. This means that a number l of inputs could be fixed in l successive nodes.

In fact, this approach permits to restrict PFS to the remaining set J. As shown in Fig. 5, this is done by adjusting, whenever possible, release dates and tails of jobs of J. When job i is chosen to be the input of J, at node k + I, J[k + 1 ] = J[k] \ {i}. The following adjustment can then be made: for every job j of J and for every machine m, rj, m is adjusted to the maximum among r/,m and ri,m +Pi,m. I f / i s a new fixed output, for every job j of J and every machine m, qj, m is adjusted to the maximum among qj.m and qi,m + Pi,m. At node k + 1, only the remaining jobs of J are considered. A solution is said to be attained when the makespan is less than or equal to UB and when J contains only one operation.

3.5. Branch and bound algorithm

Using the tools defined in previous sections, the branch and bound algorithm can now be stated as folows:

Step 1. Initialization: A. Fix an upper bound UB; B. k = l ; B. For all jobs i and machines m, compute

heads ri,m and tails qi, m; D. J = 1, the set of all jobs;

243

Step 2. Apply immediate selections as defined in Section 3.2.1 (a);

Step 3. Apply PJPS for heads and tails adjustments according to Section 3.2.1(b) and (c);

Step 4. Apply DJPS for heads and tails adjustments according to Section 3.2.1 (b) and (c);

Step 5. Modify heads and tails according to the given processing order of jobs;

Step 6. Repeat Steps 2-5 until values of ri, m and qi.m do not change anymore;

Step 7. Compute LB according to Section 3.3; Step8. I f l J I = 1,

A. A feasible schedule is obtained, its makespan is LB;

B, UB = m i n ( U B , L B - 1); Step 9. If LB ~< LIB, then compute sets IN(J )

and OUT(J) according to Section 3.2.1(d) and 3.2.2. Let SET(J) be the one with the lowest cardinality;

Step 10. While [ (SET(J ) corresponding to node k is an empty set or LB ~> UB) and k 4= 0], do k = k - 1;

Step 11. If k 4= 0, A. Choose a new input (output) j , delete it

from SET(J) and branch, i.e. introduce node k + l;

B. k = k + l ; c. J = J \ { j } ; D. For all jobs i and machines m, compute

heads ri,m and tails qi,m; E. Go to Step 2;

Step 12. End.

Table 3 shows the modifications of heads and tails for a 15-job 10-machine problem at the 294th node of the search-tree (k = 294). The vectors of heads and tails are reported for 15 jobs processed by the 5th machine (m = 5). The purpose of this example is to illustrate the evolution of heads and tails after the application of the above listed tools.

The values are given in the first three columns of Table 3: for each job mentioned in the first column, the second column gives the corresponding processing time p. The column with heading BIS gives the values of r and q obtained before the application of Step 2 (i.e. Before Immediate Selections). At this level, the graph still has disjunctions. The first operation at node k is to make immediate selections. The modified val-

244 J. Carlier, L Reba'i / European Journal of Operational Research 90 (1996) 238-251

Table 3 Modification of r and q values in the 294th node of the search-tree

BIS BPJ BDJ ADJ

Job p r q r q r q r q

I 42 899 161 899 161 899 161 899 161 2 79 167 992 167 1033 167 1033 167 1062 3 26 642 507 642 507 642 507 642 507 4 91 808 279 808 279 808 279 808 279 5 22 246 970 246 1011 246 1011 246 1040 6 74 520 598 520 639 520 639 520 668 7 5 941 154 941 154 941 154 941 154 8 21 369 792 369 833 369 833 369 862 9 94 714 370 714 370 714 370 714 370

10 83 668 416 668 416 668 416 668 416 I1 77 681 370 681 370 681 370 681 395 12 12 357 836 357 877 357 877 357 906 13 56 442 736 442 777 442 777 442 806 14 47 595 533 595 533 595 533 595 533 15 89 268 881 268 922 268 922 268 951

I 42 899 161 899 161 1013 161 1013 161 2 79 167 1062 167 1062 167 1062 167 1062 3 26 642 507 642 507 642 507 642 556 4 91 808 279 808 279 922 279 922 279 5 22 246 1040 246 1040 246 1040 246 1040 6 74 520 668 520 668 520 668 520 668 7 5 941 154 941 154 1055 154 1055 154 8 21 369 862 369 862 369 862 369 862 9 94 714 370 714 370 828 370 828 370

10 83 668 416 668 416 668 416 668 465 I1 77 681 395 681 395 681 395 681 464 12 12 357 906 357 906 357 906 357 906 13 56 442 806 442 806 442 806 442 806 14 47 595 533 595 533 595 533 595 582 15 89 268 951 268 951 268 951 268 951

ues of heads and tails obtained in Step 2 are given

in column BPJ (Before Primal Jackson). After that,

PJPS is built followed by DJPS. This allows the ad-

justment of some of the heads and tails as shown in

the columns BDJ (Before Dual Jackson) in Step 3

and ADJ (After Dual Jackson) in Step 4, respectively.

According to the job processing order, heads and tails

are modified in Step 5. As new disjunctions may be

selected immediately since the values have changed,

the same procedure (Step 6) is applied once again.

The corresponding values are reported in the bottom

part of Table 3.

At the end of this node, J is composed of the op-

erations {10, 11} still in disjunction. This can be ob-

served from the values of r and q. At this node, oper-

ations {2, 5, 15, 12, 8, 13, 6, 14, 3} have already been

fixed as inputs and {9, 4, 1, 7} as outputs.

3.6. Numerical results obtained by the f irs t method

3.6.1. General case The proposed method has been programmed in C.

A computational experiment has been carded out on

two sets of problems. First, benchmarks issued from the literature [4] (referred to as ( C ) ) were optimally

solved. In addition, larger size problems were ran-

domly generated with jobs processing times ranging

from 1 to 99 according to a uniform distribution as

Table 4 The results of the

J. Carlier, I. Reba'i / European Journal of Operational Research 90 (1996) 238-251

first method in the general case

245

N M BSF tl t2 nl n2

(C) 11 5 7038 1 0.390 9 9 (C) 12 5 7312 2 0.380 13 13 (C) 7 7 6590 2 0.400 18 21 (C) 13 4 7166 2 0.440 9 9 (C) 14 4 8003 3 0.960 11 11 (C) 8 9 8505 5 1.230 12 41 (P) 10 10 1193 9 2.160 8 43 (C) 10 6 7720 9 2.320 17 108 (T) 10 15 1373 282 84.790 683 1412 (T) 15 10 1256 310 81.250 922 922

N M FSF BSF t2 nl n2

(T) 10 10 1061 958 13.14 10 223 (T) 10 20 1969 1756 140.62 10 1407 (T) 10 30 2519 2342 150.88 10 752 (T) 10 40 3271 3127 156.08 10 323 (T) 10 50 3605 3487 154.01 10 428 (T) 10 60 4220 4092 166.07 10 73 (T) 10 70 4566 4425 158.83 10 337 (T) 10 80 5648 5267 158.32 10 118 (T) 10 90 6377 6015 161.31 10 61 (T) 10 100 6539 6465 173.95 10 105 (T) 15 15 1757 1698 165.99 15 1304 (T) 20 10 1851 1718 181.75 19 1540 (T) 20 20 2429 2283 182.47 20 438 (T) 3 100 5465 5279 0.39 3 3 (T) 4 I00 6014 6014 1.30 4 8 (T) 5 100 5573 5551 4.26 5 23

in [21] and [24] (referred to as (P) and (T) respec-

tively).

The computational results for both optimal and

time-limited resolution are collected in Table 4. We

applied this method to the same set of problems as in

Table 6. As we could not obtain results within a rea-

sonable time for some problems, we fixed a limit of

about 200 s in certain cases (second part of Table 4).

In the first and the second column, the size of the

problem is indicated by N (number o f jobs) and M

(number of machines). The best makespan found at

the end is written in the third column under the head-

ing BSF (Best Solution Found). When a time limit is

introduced for large problems, this makespan is not

optimal. Since the same problem was solved opti-

mally on a 4 8 6 D X 33 MHz PC and a four-processor

SUN 10 workstation, both CPU times are given (in

seconds) as tl and t2, respectively. The number of

nodes developed to find the first solution is nl while

the number of nodes for proving its optimality is n2.

The search-tree was started with an upper bound

equal to the optimal solution. For some problems a

higher UB was used and corresponding results are pre-

sented in the next section. In this case, the computa-

tional time is about 200% larger.

As can be seen later, our second method outper-

forms our first one in treating large problems opti-

mally. With this method, we could not obtain the optimal solution for all the problems within 200 s of CPU

time. For problems with more than 30 jobs, we did

not get even one solution within the fixed time.

246 J. Carlier, L Rebai" / European Journal of Operational Research 90 (1996) 238-251

Table 5 Non-generated heads and tails results vs. generated heads and tails results

Without generated heads and tails With generated heads and tails

N M BUB FSF nl BSF n2 n t FSG nlg BSG n2g ng tg

8 9 18000 9538 7 8505 101 4 12 9426 7 8637 108 5 13 I0 6 10000 8303 9 7720 215 13 23 8361 10 7788 208 16 24 I0 15 1600 1579 9 1373 2514 24 537 1572 8 1471 799 13 188 15 I0 1500 1396 13 1256 3571 20 1016 1459 13 1387 6031 24 1610

3.6.2. A special case: Initial heads and tails The advantage of this method is that it can be ap-

plied even if jobs have initial heads and tails. In prac- tice, this corresponds to the situation where jobs have release dates (initial heads in the example) and due dates (initial tails). For four of the previously solved problems, heads and tails were generated with values ranging from 1 to 99. Table 5 shows results obtained with and without generated heads and tails. In the first two columns the size of the problem is indicated. BUB is the Beginning Upper Bound, FSF is the First Solu- tion Found without heads and tails generated, nl is the corresponding number of branchings necessary to get the first solution, BSF is the Best Solution Found in the absence of generated heads and tails, n2 is the corresponding number of branchings required for proving its optimality, n is the number of solutions encountered and t is the corresponding CPU time in seconds on a 486 DX 33 MHz PC. In the bottom part of Table 5, FSG indicates the First Solution found with heads and tails Generated, nlg is the corresponding number of branchings necessary to get the first solution, BSG is the Best Solution found with heads and tails Gener- ated, n2g is the corresponding number of branchings for proving its optimality, ng is the number of solutions encountered and tg is the corresponding CPU time in seconds on a 486DX 33 MHz PC.

3.7. Conclusion for the first method

The results obtained in the present work outperform those published by [ 13] and more recently by [10] and [ 12]. Results from the two last references were obtained on 13-job 10-machine problems in the general case, i.e. without bottleneck machines. Here, 10- job 15-machine and 15-job 10-machine problems have been solved requiring a small number of nodes to be

generated in the search-tree and within less than 350 s on a 486 PC and 90 s on a Sun 10. Clearly, this method gives better results even when initial heads and tails are given.

4. Second method: Inputs and outputs o f machines

Similarly to the branch and bound procedure de- scribed above, the second method describes three sets at each node of the search-tree: IN for fixed inputs, J for jobs in disjunction and OUT for fixed outputs. Inpits consist of jobs already ordered, and which are to be processed first on the machines (see Fig. 6). As seen before, in a PFS, this order is the same for all machines. OUT is the set containing jobs already ordered and which are to be processed in the end. In addition, J is the set of jobs not yet ordered. These jobs are called in disjunction based on the assumption that two jobs cannot be processed at the same time on a given machine.

The second method, however, disregards disjunctions. Instead of considering operation heads and tails, machine heads and tails are introduced.

112131.1.1.1 , IN

J

OUT

Fig. 6. Repartition of jobs at a given node for all machines.

J. Carlier, L Reba~ / European Journal of Operational Research 90 (1996) 238-251 247

4.1. Definitions

At each node k, we define M "set_heads", M "set_tails", M "set_processing_times" and a lower bound LB.

A set .head vector is the vector of dates prior to which the associated machine is not available. The word "set" is introduced here because these heads are common to all jobs of J.

A set_tail vector is the dual case of a set_head vector. It is related to tails of jobs of set J.

A set_processing_time vector is the sum of processing times of set J jobs on each machine.

for each machine m 4: 1. The new_set_tail vector would have the same value

as old_set_tail. Furthermore, job i is added to IN[ k] to get IN[k + I ], and i is removed from J[k] to obtain J [ k + 1].

If i were a new fixed output, corresponding equalities would be:

new_set_tall(M) = old_set_tail(M) + Pi,M

and

new_set_tail(m)

= max(old_set_tail(m), new_set_tail(m + 1 ) )

4.2. Initialization

For each machine m, m = 1 to M, the three vectors associated with the root of the search-tree are shown as follows:

m - I

root_set_head(m) = min Z Pi,maehine, i

machine=l

M

root_set_tail(m) = min Z Pi,machine, i

mach in~m+ 1

N

root_set_processing_time(m) = Z Pi,m. i=1

4.3. Adjusting vectors

Let old_set_head, old_set_tail and old_set_processing _time denote the three vectors associated with the current node k of the search-tree and let i be the new input. Consequently, a new node k + 1 will be introduced in the search-tree. Let new.set_head, new_set_tail and new_set_processing_time denote the three vectors associated with this new node. Then, the following equalities apply for heads:

new_set_head( 1 ) = old_set..head( 1 ) + Pi, i

and

new_set_head (m)

= max(old_set_head(m), new_set_head(m - 1 ) )

-}- Pi,m

q- Pi,m

for each machine m ~ M. The new_set_head vector would have the same value

as old_set_head. Job i would be added to OUT[k] to get OUT[ k + 1 ], and i is removed from J[ k] to obtain J [ k + 1].

In both cases, i.e. fixing i as a new input or as a new output, the following equality applies for each machine m:

new_set_processing_time(m)

= old_set_processing_time (m) - Pi,m.

The advantage of this method is undoubtedly its linear computational complexity: - computing set_heads and set_tails is peformed in

2 . O(M) time; - computing sets IN, J, OUT is done in O( 1 ) time; - computing LB is done in O(M) time. Therefore, this method has a linear complexity.

4.4. Lower bound

The lower bound computed in the search-tree, for a chosen job i, is given by the following formula:

LB(i) = max (new_set_head(m) m=l,. . . ,M

+ new_set_processing_time(m)

+ new_set_tail(m) ) .

If LB(i) > LIB, the next job of J is taken instead of i, and if LB(i) ~ LIB, the procedure branches into a new node.

248

Table 6 The results of the

J. Carlier, I. Rebai" / European Journal of Operational Research 90 (1996) 238-251

second method in the general case

N M B SF n L n2 t FSF N SF

7 7 6 590 187 248 0.002 7 646 20 11 5 7 038 536 576 0.040 8 245 42 12 5 7 312 1 085 1 106 0.050 9 369 56 13 4 7 166 696 1030 0.100 8217 33 14 4 8 003 1090 1 113 0.009 9 545 60 8 9 8 505 466 547 0.040 9 925 26

10 6 7720 912 i 264 0.140 9283 41 I0 10 958 1 131 1259 0.200 1358 33 10 15 1373 3 246 6 871 1.200 1540 30 I0 20 1709 3 457 4769 1.250 1981 32 I 0 30 2 248 12 205 22 726 7.900 2 607 49 I 0 40 3 044 160 991 20 i 290 83.020 3 220 24 I 0 50 3 449 62193 85 249 46.640 3 676 34 I 0 60 3 962 41366 65 892 44.480 4 450 50 I 0 70 4 367 54 787 67 566 54.050 4 996 56 10 80 5120 37 611 52 601 46.750 5 664 25 I0 90 5 888 71293 107 994 109.680 6445 59 I0 oo 6 274 99 087 131980 141.810 6748 45 15 10 1256 28 276 30066 5.510 1749 114 15 15 1 594 921956 1328023 337.980 i 882 83 20 10 1545 4375711 4375762 997.060 1978 212 20 20 2 111 48687464 50087931 23179.770 2520 177 30 3 1745 8 743 9 076 1.440 1966 80 30 5 1628 35 061 35148 6.930 2267 333 30 7 1648 139127 139322 35.400 2180 350 30 I0 2 116 1 500008 1500353 456.850 2634 277 40 2 2120 7 699 8 389 1.370 2173 24 40 3 2 264 21767 22 390 4.210 2 594 132 40 4 2214 19214 19862 4.700 2663 181 40 5 2 115 45 527 45 746 9.970 2 505 268 40 10 261 ! 42380655 42380967 21 156.990 3249 546 50 2 2 642 3 550 4 754 1.080 2 698 8 50 3 2 541 39119 40 048 10.090 2 826 89 50 4 2728 56213 57 861 16.280 3169 230 50 7 2 888 12 942 773 12 952 669 4 719.740 3 671 593 50 10 3150 40383 271 40388152 22005.180 3 803 545

3 I oo 5 279 3 8 0.010 5 279 1 4 I oo 6 014 I 1 29 0.020 6190 4 5 I00 5 551 82 87 0.080 5610 5

4.5. Branching scheme

In the b r anch ing scheme, a new input is fixed fol -

lowed by a new output . This m e a n s that, i f at a part ic-

ular n o d e o f the search- t ree , a new input was fixed and

hence r e m o v e d f r o m J and added to IN, a new out-

put w o u l d be f ixed at the d e s c e n d i n g node. A boolean

varaibale l a sLb ranch ing a l lows to do this as i l lustrayed

in the a lgo r i t hm given below.

4.6. Branch and bound algorithm

The second branch and b o u n d a lgor i thm now runs

as fo l lows:

Step 1. Ini t ia l izat ion:

A. k - - l ;

B. Fix an upper b o u n d UB;

C. last_branching = 0 (i .e. o u t p u t ) ;

J. Carlier, L Reba'i / European Journal of Operational Research 90 (1996) 238-251 249

D. Compute vectors set_head, set_tail and set_processing_time according to Sec- tion 4.2;

E. J = I , I N = 0 , O U T = 0 , IN(J ) = l a n d OUT(J) = I;

E L B = 0 ; Step 2. If lJ [ = 1,

A. A feasible schedule is obtained, its makespan is LB;

B. UB = min(UB,LB - 1); Step 3. For all jobs j of J;

A. Compute new vectors according to Sec- tion 4.3 and to last_branching;

B. Compute new value of LB according to Section 4.4;

C. If LB > UB, j cannot be an input, IN(J) = IN(J ) \ {j} (output, OUT(J) -- OUT(J) \ {j});

Step 4. While [ (IN(J) (OUT(J) ) corresponding to node k is an empty set or LB i> UB) and k > 0],dok=k- I;

Step 5. If k 4= 0, A. If last_branching = I, i.e. input (0, i.e. out-

put), fix an output i (input) from OUT(J) (IN(J));

B. k=k+I; C. Compute new_set_head, new_set_tail and

new_set_processing_time vectors according to Section 4.3 and last_branching;

D. J = J \ {i}, IN(J ) = J, OUT(J) = J, OUT = OUTU {i} (IN = I N U { i } ) , last_branching = 1 - last_branching;

E. Go to Step 2; Step 6. End.

4. 7. Numerical results for the second method

4; 7.1. General case This method has been programmed in C and the

results obtained are given in Table 6. The column headings are N (number of jobs), M (number of machines), BSF (Best Solution Found), nl (number of nodes necessary to get the optimal solution), n2 (number of nodes for proving its optimality), t (CPU time in seconds on a four-processor SUN 10 workstation), FSF (First Solution Found) and NSF (Number of Solutions Found in all the search-wee). Note that the search-tree begins with an upper bound of 10000,

which is higher than the optimal makespan solution for all the problems.

4.7.2. Initial upper bound is the optimal solution The same problems are solved, with an initial up-

per bound equal to the optimal makespan. This is a measure of the efficiency of our method since it rep- resents the distance between this bound and the solution. The results are given in Table 7 where the first

Table 7 The results of the second method with initial upper bound equal to the solution

N M FLB n I n 2 t

7 7 5699 19 77 0.00 11 5 6917 25 56 0.02 12 5 7 103 39 50 0.00 13 4 6917 13 334 0.02 14 4 8003 54 74 0.01 8 9 7951 87 157 0.02

10 6 7 085 75 504 0.04 10 10 813 21 189 0.04 10 15 1 058 562 4042 0.88 10 20 1 463 312 1 570 0.50 10 30 1 850 3 107 13281 4.99 10 40 2332 104219 144519 58.16 10 50 2 778 6 205 28 728 18.45 10 60 3 147 16214 40351 29.57 10 70 3619 17786 30257 27.18 10 80 4169 18818 33535 31.57 10 90 5 024 22 132 58 123 63.90 10 100 4983 47627 83687 97.61 15 10 1 136 811 2598 0.63 15 15 1286 13301 392354 107.95 20 10 1 427 219610 219657 56.61 20 20 1 974 958 505 2 183 935 1085.84 30 3 1 745 54 377 0.08 30 5 1 628 209 296 0.09 30 7 1 569 515 700 0.19 30 10 2079 562940 563264 189.82 40 2 2 120 40 709 0.14 40 3 2064 40 577 0.16 40 4 2214 40 627 0.19 40 5 2 115 40 216 0.05 40 10 2602 212486 212747 136.83 50 2 2642 50 I 177 0.26 50 3 2541 51 975 0.25 50 4 2 725 50 1 633 0.76 50 7 2 855 162 860 172 729 81.85 50 10 3059 10693 15535 9.06

3 100 4867 3 6 0.01 4 100 5 300 5 24 0.03 5 100 4628 68 72 0.05

250 J. Carlier, L RebaT / European Journal of Operational Research 90 (1996) 238-251

Table 8 The results of the second method with a bottleneck machine

N M BM BUB BLB BSF n t

15 15 7 2 589 1 992 2 059 430 0.210 20 20 10 3 003 2 310 2 403 8 691 4.990 25 25 12 4 275 3 289 3 470 3 433 3.190 40 10 5 5 293 4 072 4 072 461 0.530 45 20 15 6 328 4 868 4 883 925 1.650 50 10 5 5 989 4 607 4 649 859 1.120 55 15 12 8422 6479 6494 1 306 2.510 55 20 15 7 888 6 068 6 104 528 649 978.940

lower bound has also been reported. The columns are N (number of jobs), M (number of machines), FLB ( First Lower Bound), n I (number of nodes necessary to get the optimal solution), n2 (number of nodes for proving its optimality) and t (CPU time in seconds on a four-processor SUN 10 workstation).

4. 7.3. Bottleneck machines with dichotomic search We now describe a variation of the second method,

based on a dichotomic search. The second method procedure is called more than once, each time with a new upper bound which depends entirely on the previous iteration. The procedure has two parts: initialization and dichotomic search. In the initialization, an upper bound is computed which exceeds the first bound by 10, 20 or 30 percent. If a lower bound is found which exceeds the first upper bound, the first upper bound is increased. Otherwise, the second method is applied, splitting each time the interval [LB, UB] in two until the solution is obtained [ 18 ]. Table 8 shows the results of the dichotomic search on problems with bottleneck machines. By definition, a bottleneck machine is a machine on which jobs have processing times higher than on others. Hence, it is "the machine with the largest priority index" [ 1 ]. The coefficient has been set equal to 2 as has been done in [ 10] and [ 12], i.e. the maximum processing time for this machine is twice that of the others. The column headings in Table 8 are N ( number of jobs), M ( number of machines), BM (the number of the Bottleneck Machine), BUB (Beginning Upper Bound), BLB (Beginning Lower Bound), BSF (Best Solution Found), n (number of branchings for proving the optimality) and t (CPU time in seconds on a four-processor SUN 10 workstation).

In the case of bottleneck machines, Han [ 12] has

solved 45-job 15-machine and 50-job 7-machine problems with coefficients equal to 2 and 3. In this study, 55-job 20-machine and 25-job 25-machine problems with a coefficient equal to 2 were solved optimally.

4.8. Conclusion for the second method

As illustrated in Tables 6-8, the second method gives excellent results. This method can solve up to 10-job 100-machine, 50-job 10-machine and 20-job 20-machine instances. This is mainly due to the linear complexity when introducing a new node and to the quality of the local bound. In fact, the lower bound evaluation becomes accurate when several jobs are introduced in the set IN and in the set OUT. Using dichotomic search to improve bounds, larger problems could be solved. 55-job 20-machine and 25- job 25-machine problems were reached. However, this method seems less efficient when large initial heads and tails are introduced. In this case, the first method should be used.

5. Concluding remarks

This paper treats the permutation flow shop problem with N jobs and M machines. The problem is NP-hard in the strong sense. This motivates the devel- opment of branch and bound algorithms. First, results for job shop were transposed to PFS. This approach allowed to derive an exact method that could solve larger instances than other authors have done before. This method can be used in real-life problems, where jobs have set-up and removal times or release and due dates. For the latter, some problems have been ex-

J. Carlier, L Reba'i / European Journal of Operational Research 90 (1996) 238-251 251

actly solved. The second method is a variat ion o f the first. Dis junc t ions are no more conserved. Instead, the problem is restricted to mach ine heads and tails. This new approach gave better results than the first method: larger problems could be solved optimally. Moreover,

some general ized flow shops were also solved. Several issues are worthy of future invest igat ion. For

instance, a poss ib le extension o f the methods could be done for other general ized flow shops [21] . Also, because o f its potent ial and its practical use in appli-

cation to industr ia l problems, other measures o f per-

formance, such as m a x i m u m tardiness, could be considered.

Acknowledgements

The authors gratefully thank Professors E. P inson and C. Proust for their useful comments . This work has been part ial ly supported by the European Eco-

nomic C o m m u n i t y contract C H R X - C T 9 3 - 0 0 8 7 (net- work C H M : models , a lgori thms and systems for deci- sion mode l s ) .

References

I 1 ] Blazewicz, J., Ecker, K.H., SchmidL G., and Weglarz, J., Scheduling in Computer and Manufacturing Systems, 2rid edn., Springer Vedag, Berlin, 1993.

121 Brucker, P., Jurisch, B., and Kramer, A., "The job-shop and immediate selection", Osnabritcker Schriften zur Mathematik Reihe P, Heft 145 (1992); to appear in Annals of Operations Research.

131 Brucker, P., Jurisch, B., and Sievers, B., "A branch and bound algorithm for the job-shop scheduling problem", Discrete Applied Mathematics 49 (1994) 107-127.

141 Carlier, J., "Ordonnancements ~ contraintes disjonctives", RAIRO Recherche Opdrationelle 12 (1978) 333-351.

151 Carlier, J., "One machine problem", European Journal of Operational Research 11 (1982) 42-47.

161 Carlier, J., and Pinson, E., "An algorithm for solving the job- shop problem", Management Science 35 (1989) 164-176.

171 Carlier, J., and Pinson, E., "A practical use of Jackson's preemptive schedule for solving the job-shop problem", Annals of Operations Research 26 ( 1991 ) 269-287.

[ 81 Carlier, J., and Pinson, E., "Adjustment of heads and tails for the job-shop problem", European Journal of Operational Research 78 (1994) 146-162.

[ 91 Carlier, J., and RebaL I., "Applying immediate selections to the permutation flow shop problem", Proc. 4th International Workshop on Project Management and Scheduling, Leuven, Belgium, 1994.

[ 10] Dejax, P., and Han, W., "Une heuristique pour le probltme d'ordonnancement de type n/m/F/Cmax avec presence de machines goulots", RAIRO Recherche Opdrationelle 4 (1990) 315-330.

[11] Demeulemeester, E., and Herroelen, W., "A branch and bound procedure for the multiple resource constrained project scheduling problem", Management Science 38 (1992) 1803- 1818.

[12] Han, W., "AIgorithmes de r~solution exacte et heuristique pour ies probl~mes d'ordonnancement en flowshop", Thtse de doctorat de l'Ecole Centrale Paris, 1992.

[13] Lawler, E.L., Lenstra, J.K., and Rinnooy Kan, A.H.G., "A general bounding scheme for the permutation flow shop problem", Operations Research 26 (1978) 53-67.

[ 14] Lawler, E.L., Lenstra, J.K., Rinnooy Kan< A.H.G., and Shmoys, D.B., "Sequencing and scheduling: Algorithms and complexity", in: S.C. Graves, A.H.G. Rinnooy Kan and EH. Zipkin (eds.), Logistics of Production and Inventory, North- Holland, Amsterdam, 1993.

[15] Lee, C.Y., Cbeng, T.C.E., and Lin, B.M.T., "'Minimizing the makespan in the 3-machine assembly-type flow shop scheduling problem", Management Science 39 (1993) 616- 625.

[ 16] McMahon, G.B., and Lim, C.J., "The two-machine flow shop problem with arbitrary precedence relations", European Journal of Operational Research 64 (1993) 249-257.

[ 17] Monma, C.L., and Rinnooy Kan, A.H.G., "A concise survey of efficiently solvable special cases of the permutation flow shop problem", RAIRO Recherche OpdrationeUe 7 (1983) 105-119.

[ 18 ] Pinson, E., "Le probl~:me de job-shop", Th~se de doctorat de l'Universit~ Paris VI, 1988.

[ 191 Potts, C.N., "An adaptive branching rule for the permutation flow-shop problem", European Journal of Operational Research 5 (1980) 19-25.

[201 Potts, C.N., and Baker, K.R., "Flow shop scheduling with lot streaming", Operations Research Letters 8 (1989) 297-303.

[21] Proust, C., "Influence des idles de S.M. Johnson sur la rtsolution de probl~mes d'ordonnancement de type n/m/F, contraintes diverses/Cmax", E3I, Universit6 Franqois Rabelais, Tours, 1992.

[221 Proust, C., Gupta, J.N.D., and Deschamps, V., "'Flow shop scheduling with set-up, processing and removal times separated", International Journal of Production Research 29 ( 1991 ) 479--493.

[23] S0ral, H., Kondakci, S., and Erkip, N., "Scheduling unit- time tasks in renewable resource constrained flowshops", Zeitschrift far Operations Research 36/6 (1992) 497-5 ! 6.

[24] Taillard, E., "Benchmarks for basic scheduling problems", European Journal of Operational Research 64 (1993) 278- 285.

[25] Widmer, M., and Hertz, A., "A new heuristic method for the flow shop sequencing problem", European Journal of Operational Research 41 (1989) 186-193.

two branch and bound algorithms for the permutation flow shop problem

Documents