The total completion time open shop scheduling problem with a given sequence of jobs on one machine

*Corresponding author. Tel.: #886-4-332-3000; fax: #886-4-374-2327.E-mail address: c#[email protected] (C.-F. Liaw).

Computers & Operations Research 29 (2002) 1251}1266

The total completion time open shop scheduling problem witha given sequence of jobs on one machine

Ching-Fang Liaw*, Chun-Yuan Cheng, Mingchih Chen

Department of Industrial Engineering and Management, Chaoyang University of Technology, 168 Gifeng East Road, Wufeng,Taichung, Taiwan

Received 1 May 2000; received in revised form 1 November 2000

Abstract

This paper addresses the open shop scheduling problem to minimize the total completion time, providedthat one of the machines has to process the jobs in a given sequence. The problem is NP-hard in the strongsense even for the two-machine case. A lower bound is derived based on the optimal solution of a relaxedproblem in which the operations on every machine may overlap except for the machine with a given sequenceof jobs. This relaxed problem is NP-hard in the ordinary sense, however it can be quickly solved viaa decomposition into subset-sum problems. Both heuristic and branch-and-bound algorithm are proposed.Experimental results show that the heuristic is e$cient for solving large-scaled problems, and the branch-and-bound algorithm performs well on small-scaled problems.

Scope and purpose

Shop scheduling problems, widely used in the modeling of industrial production processes, are receiving anincreasing amount of attention from researchers. To model practical production processes more closely,additional processing restrictions can be introduced, e.g., the resource constraints, the no-wait in processrequirement, the precedence constraints, etc. This paper considers the total completion time open shopscheduling problem with a given sequence of jobs on one machine. This model belongs to a new class of shopscheduling problems under machine-dependent precedence constraints. This problem is NP-hard in thestrong sense. A heuristic is proposed to e$ciently solve large-scaled problems and a branch-and-boundalgorithm is presented to optimally solve small-scaled problems. Computational experience is also re-ported. � 2002 Elsevier Science Ltd. All rights reserved.

Keywords: Production scheduling; Open shop; Heuristic; Branch-and-bound

0305-0548/02/$ - see front matter � 2002 Elsevier Science Ltd. All rights reserved.PII: S 0 3 0 5 - 0 5 4 8 ( 0 1 ) 0 0 0 2 8 - 4

1. Introduction

In shop scheduling problems, a set of jobs must be processed on a number of machines in series.A job consists of several operations, each to be performed on a di!erent machine for a givenamount of time. At any time, at most one operation can be processed on each machine, and at mostone operation of each job can be processed. Shop scheduling problems are further classi"edaccording to ordering restrictions for the operations of a job. In a #ow shop, each job has exactlyone operation on each machine, and the order in which each job is processed by the machines is thesame for all jobs. In a job shop, the operations of each job must be processed in a given orderspeci"c to that job. For an open shop, the operations of each job can be processed in any order.Shop scheduling problems, widely used in the modeling of industrial production processes, arereceiving an increasing amount of attention from researchers. Many heuristics and exact solutionmethods have been proposed for solving shop scheduling problems. However, most studies in this"eld are focused on job shop and #ow shop scheduling problems. This paper addresses the problemof scheduling open shops.To model practical production processes more closely, additional processing restrictions can be

introduced, e.g., the resource constraints, the no-wait in process requirement, the precedenceconstraints, etc. In this paper, we consider the open shop scheduling problem with following simpleprecedence constraint: one of the machines processes the jobs according to a given sequence. Theproblem under consideration may arise in modeling a production process in which, due totechnological or managerial decisions, the jobs should be processed on one of the machinesaccording to a predetermined order. For example, the various setup requirements of jobs on thismachine may lead to a decision that the jobs should be processed on this machine in a speci"corder. This model is also applicable when an existing schedule should be adjusted, provided thatthe sequence of jobs on one machine has to be retained. Furthermore, this model may also arise asa subproblem in determining a lower bound for a general open shop problem (see Gueret and Prins[1]).Formally, the open shop scheduling problem studied in this paper can be stated as follows.

We are given a set of n jobs �J�� 1)i)n�, and a set of m machines �M

�� 1)j)m�. Each job

J�consists of m operationsO

��,O

��,2,O

��such that operationO

��of job J

�has to be processed on

machine M�for a given amount of time p

��. The operations of each job can be processed in any

order, but only one at a time, and preemptions are not allowed. We assume, without loss ofgenerality, the jobs are required to be processed on machineM

�in the sequence J

�, J

�,2, J

�. The

objective is to "nd a feasible schedule that minimizes the sum of job completion times. Using thenotation of (Sharfransky and Strusevich) [2], this problem is denoted by O

��GS(1)��C

�, where

GS(1) stands for a given sequence of jobs on one machine. The O��GS(1)��C

�problem is NP-hard

in the strong sense even for the case m"2 since the proof of Achugbue and Chin [3] which showsthat the problem O

��C

�is NP-hard in the strong sense is also applicable to the problem with

a given sequence of jobs on machine M�.

Current researches on open shop scheduling problems have concentrated on minimizing makes-pan (C

��), i.e., the maximal job completion time [4}7]. Some progress has been made on the

solutions of makespan open shop scheduling problems with precedence constraints. If all machinesare required to process the jobs in the same sequence, i.e., the same sequence of jobs is given on allmachines, the two-machine problem is solvable in O(n log n) time, if preemption is forbidden, and in

1252 C.-F. Liaw et al. / Computers & Operations Research 29 (2002) 1251}1266

O(n�) time, if preemption is allowed [8]. However, the three-machine problems in both preemptiveand nonpreemptive case are NP-hard [9]. The O

��GS(1)�C

��problem is studied by Sharfransky

and Strusevich [2]. They showed that in the preemptive case this problem is polynomially solvable.If preemption is not allowed, this problem is NP-hard. For the latter case, they developed ane$cient heuristic for the case of m"2.In this paper, we develop both heuristic and branch-and-bound algorithm for solving

O��GS(1)��C

�, the total completion time open shop scheduling problem with a given sequence of

jobs on one machine. The total completion time criterion is important, since many important costmeasures, such as "nished goods turn-over, depend on total completion time. To the best of ourknowledge neither heuristic nor exact algorithm has previously been proposed for the totalcompletion time open shop scheduling problem. The rest of this paper is organized as follows.Section 2 presents a heuristic for O

��GS(1)��C

�. A lower bound for this problem is derived in

Section 3. In Section 4, we describe a branch-and-bound algorithm for solving O��GS(1)��C

�.

Computational experiments are given in Section 5, followed by the conclusions in Section 6.

2. A heuristic

The heuristic developed in this paper is an iterative dispatching procedure. Each iteration of theprocedure is a one-pass heuristic which generates a complete schedule using some dispatchingindex. At the end of each iteration, the parameter used in the dispatching index is adjusted toimprove upon the current schedule. This iterative dispatching procedure consists of two majorcomponents: a one-pass heuristic to generate a complete schedule at each iteration, and anadjustment strategy to adjust the parameter used at each iteration.

2.1. A one-pass heuristic

The one-pass heuristic constructs a complete schedule using a dispatching index. We de"nea dispatching index DI

��for each unscheduled operation O

��as follows:

DI��

"�1

(��I

��#1)�RJ

�#p

��

if jO1,

1i

if j"1,

where ��is the parameter associated with job J

�, I

��the idleness between O

��and its immediate

predecessor on machine M�if O

��is processed next, and RJ

�the remaining processing time

(excluding p��) of job J

�.

Whenever a machine, say M�, is available, the operation with the highest dispatching index is

chosen to be processed next on machine M�. The process repeats until a complete schedule is

generated. It can be seen easily that with this dispatching index the required sequence of jobs onmachine M

�is guaranteed.

The dispatching index DI��combines the philosophies of the well-known minimum idleness rule

and the shortest remaining processing time rule. It prioritizes each operation O��corresponding to

the total completion time objective.

C.-F. Liaw et al. / Computers & Operations Research 29 (2002) 1251}1266 1253

2.2. An adjustment strategy

Given a complete schedule, we "rst compute the actual completion time AC�and the ratio

AC�/¹P

�of job J

�, where ¹P

�"��

��p��is the sum of processing times of job J

�, for i"1, 2,2, n.

The ratio AC�/¹P

�represents in some sense the extent to which job J

�is &delayed'. We can identify

a set of most delayed jobs Q such that the ratio of each job in Q is greater than the ratio of each jobnot inQ. We then adjust the parameters �

�associated with those jobs in Q such that they are assigned

a higher dispatching index in the following iteration. This will tend to decrease the actual completiontimes of the jobs in Q, and thus hopefully generate a better schedule in the next iteration.The structure of this iterative dispatching procedure is given below.

Step 1: Set the iteration count k"0 and setMax}iter to be the maximum number of iterations.Determine the initial parameter to be used in the dispatching index.Step 2: Generate a complete schedule using the one-pass heuristic with the current dispatching

index.Step 3: Update the parameter used in the dispatching index based on an adjustment strategy.Step 4: Set k"k#1. If (k(Max}iter) goto Step 2, else STOP.

Based on preliminary experiments, we setMax}iter equal to 5000, subset size �Q� equal to [��n],where � is a scalar between 0 and 1, and [x] denotes the largest integer less than or equal to x. Also,the parameter �

�of each job J

�in Q is updated by �

�"��

�where � is a scalar between 0 and 1. In

order to determine the most appropriate parameters (the initial value of ��, � and �) to be used in

the heuristic, a factorial experiment is conducted to investigate the e!ect of each parameter on theperformance of the heuristic. The parameters are set to the following possible values:

Initial value of ��(factor A): 0.1, 0.5, 1.0, 5.0, 10.0, 50.0, 100.0;

Parameter � (factor B): 0.25, 0.50, 0.75;Parameter � (factor C): 0.50, 0.70, 0.90, 0.99, 0.999.

Five replications for each combination of these parameters are run with n"m"20, and theanalysis of variance is summarized in Table 1. As Table 1 shows, with a 95% con"dence coe$cient,both the initial value of �

�and the parameter � have signi"cant e!ects on the performance of the

heuristic, whereas the e!ect of parameter � is insigni"cant. Furthermore, there is no indication ofinteraction between these factors. We then apply the Turkey multiple comparison method tocompare the individual e!ects for di!erent values of �

�and di!erent values of �. The results are

summarized in Table 2. The e!ects of values within each group are not signi"cantly di!erent,whereas the e!ect of each value in group 1 is signi"cantly better than that of each value in group2 which in turn is signi"cantly better than that of each value in group 3. Based on above results, weset the initial value of �

�to be 1.0, the parameter � to be 0.75, and the parameter � to be 0.90.

3. A lower bound

In this section we derive a lower bound for O��GS(1)��C

�. The lower bound J¸B ( job-based

lower bound) is equal to the optimal��C

�value of a relaxed problem O

��GS(1),R��C

�, in which


Table 1Result for analysis of variance (�"0.05)

Source Sum of squares d.f. Mean square F P

C 225949.619 4 56487.405 11.323 0.000B 3.189 2 1.594 0.000 1.000A 33067281.531 6 5511213.589 1104.755 0.000C*B 648.735 8 81.092 0.016 1.000C*A 50524.221 24 2105.176 0.422 0.993B*A 9675.291 12 806.274 0.162 0.999C*B*A 19168.385 48 399.341 0.080 1.000Error 2095223.600 420 4988.628

Total 3389113446.000 525

Table 2Results of the Turkey multiple comparison method (�"0.05)

Group 1 Group 2 Group 3

Initial value of ��

�1.0, 5.0, 10.0, 50.0, 100.0� �0.5� �0.1�Parameter � �0.90, 0.99, 0.999� �0.999, 0.70� �0.70, 0.50�

the operations on every machine may overlap except for machine M�. The problem

O��GS(1),R��C

�is still NP-hard, however it can be solved pseudo-polynomially via a decomposi-

tion into subset-sum problems [10].

Proposition 1. The problem O��GS(1),R��C

�is NP-hard in the ordinary sense even for three jobs.

Proof. See Appendix A. �

In what follows, we "rst describe brie#y the principle of our algorithm for solvingO

��GS(1),R��C

�, and then specify in details a pseudo-polynomial implementation of the proposed

algorithm. We remark that our algorithm for solving O��GS(1),R��C

�can be considered as dual

with respect to the algorithm A developed by Gueret and Prins [1].The algorithm consists of n steps. In step k, k"1, 2,2, n, we compute the completion time of

job J�by considering a subproblem SP

�consists of k jobs J

�, J

�,2, J

�. A set of schedules has been

generated for SP��

during the previous step. For each of these schedules, two schedules for SP�

are constructed in step k: in the "rst one S�, O��starts just after O

��is completed; in the second

one S�, an idle time is allowed between these two operations. In this setting, the optimal schedulecan be obtained among the schedules constructed in the last step.Let �C

�(SP

��) denote the sum of completion times of the jobs considered in subproblem

SP��, and let c

��denote the completion time of operation O

��on machineM

�. In schedule S�, we

schedule before O��a subset of operations of job J

�whose total processing time is maximal but not


greater than the completion time t of O��

. Let B(k, t) denote the total processing time of theoperations of this subset. Then, the completion of operation O

��is c

��"t#p

��, the completion

time of job J�is C�

�"¹P

�#t!B(k, t), and �C

�(SP

�)"�C

�(SP

��)#C�

�. In schedule S�, we

schedule before O��a subset of operations of job J

�whose total processing time is minimal but

greater than the completion time t of O��

. Let A(k, t) denote the total processing time of theoperations of this subset if it exists. Otherwise, A(k, t) is set equal to t. In this case, the completiontime of operation O

��is c

��"A(k, t)#p

��, the completion time of job J

�is C�

�"max(¹P

�, c

��),

and �C�(SP

�)"�C

�(SP

��)#C�

�. The values of B(k, t) and A(k, t) can be computed e$ciently in

O(¹P�) by solving a subset-sum problem using the algorithm proposed by Gueret and Prins [1].

We demonstrate the algorithm for solving O��GS(1),R��C

�via a small example. Consider the

following processing times for a problem instance with n"m"3.

p��

J�

J�

J�

M�

8 5 9M

�3 4 6

M�

2 7 8

In the "rst step, we solve the subproblem SP�consisting of job J

�only. The optimal schedule of

this problem is obvious (Fig. 1(a)): operation O��starts at time 0 and the remaining operations of

job J�follow contiguously in any order after O

��. This gives a schedule S

�with�C

�(SP

�)"13. In

step 2, we solve the subproblem SP�consisting of jobs J

�and J

�. Based on the schedule S

�in step

1, we consider two cases (Figs. 1(b) and (c)).Case 1: O

��starts just after O

��at time c

��. In this case, to minimize the completion time of job

J�, we must schedule O

��before O

��, and O

��after O

��. This results in an optimal schedule

S��with C�

�"17 and �C

�(SP

�)"13#17"30.

Case 2: O��starts strictly after O

��. In this case, we must schedule both O

��and O

��before O

��.

This gives an optimal schedule S��with C�

�"16 and �C

�(SP

�)"13#16"29.

In step 3, we consider the subproblem SP�consisting of jobs J

�, J

�and J

�. We "rst construct

two schedules based on the schedule S��obtained in step 2 (Figs. 1(d) and (e)).

Case 1: O��starts just after O

��. To minimize the completion time of job J

�, we must schedule

O��before O

��and O

��after O

��. This results in an optimal schedule S

��with C�

�"28 and

�C�(SP

�)"30#28"58.

Case 2: O��starts strictly after O

��. In this case, we schedule both O

��and O

��before O

��. This

produces an optimal schedule S��with C�

�"23 and �C

�(SP

�)"30#23"53.

Similarly, based on the schedule S��, we get two other schedules: S

��with�C

�(SP

�)"29#25

"54 and S��with�C

�(SP

�)"29#25"54 (Figs. 1(f) and (g)). In fact, S

��is exactly the same as

S��and can be discarded since we can schedule both O

��and O

��before the completion time of

O��. The optimal �C

�value is equal to min�58, 53, 54�"53.

We now present a pseudo-polynomial algorithm for solving O��GS(1),R��C

�. At step k, the

algorithm generates the schedules for jobs J�, J

�,2,J

�. For the "rst step, there is only one

schedule: O��starts at time 0 and the remaining operations of job J

�follow contiguously in any

order after O��. At the end of step k, the algorithm only keeps schedules with di!erent c

��values.


Fig. 1. Illustration of the computation of algorithm RELAX.


If two schedules have the same value for c��, it keeps the one with smallest total completion times

of jobs J�, J

�,2, J

�. The reason is that the completion times of the other jobs J

��, J

��,2, J

�depend only on c

��. Also, the only information stored for each schedule is a pair (c

��,��

��C

�), since

we only need to compute the optimal ��C

�value of O

��GS(1),R��C

�, but not the exact

composition of an optimal schedule.Let ;B be an upper bound, which can be obtained by the heuristic presented in Section 2, and

¸B0"��

¹P�be a simple lower bound, for O

��GS(1),R��C

�. Also, let t}max"

��p��

#��max�p

��: 2)j)m� denote the largest possible completion time of operation O

��.

The algorithm stores the schedules at the beginning of step k in an array Z of t}max#1 elementsindexed from 0. If a schedule with c

��"t was generated at the previous step, then

Z[t]"��C

�, else Z[t] is set to be a big number (BigM). More precisely, the schedules generated

in step k are "rst stored in an array Z}temp which then overwrites array Z for the next step. Thealgorithm RELAX for solving O

��GS(1),R��C

�is given below.

Solve the subset-sub problem corresponding to each job and store the results.If ;B"¸B0, stop.Initialize array Z to be BigMZ[p

��]"¹P

�For (k"2; k=n; k##)Initialize array Z}temp to be BigMFor (t"0; t=t}max; t##)If ( Z[t]OBigM)// Here we have a schedule with c

��" and ��

��C

�"Z[t]

Determine A(k, t) and B(k, t) for job J�

// First schedule S�c��

"t#p��

¹emp"Z[t]#¹P�#t!B(k, t)

If (¹emp(;B && ¹emp(Z}temp[c��]) Z}temp[c��

]"¹emp// Second schedule S�c��

"A(k, t)#p��

¹emp"Z[t]#max(¹P�, c

��)

If (¹emp(;B && ¹emp(Z}temp[c��]) Z}temp[c��

]"¹empEnd of If (Z[t]OBigM)

End of For (t"0; t=t}max; t##)Z"Z}temp

End of For (k"2; k=n; k##)Optimal ��

��C

�value"minimum value in Z

Algorithm RELAX has a pseudo-polynomial complexity of O(��

¹P�#n�t}max). The

following proposition shows that algorithm RELAX "nds the optimal ��C

�value for

O��GS(1),R��C

�.

Proposition 2. Algorithm RELAX xnds the optimal ��C

�value for O

��GS(1),R��C

�.

Proof. See Appendix B. �


Fig. 2. Illustration of duplicated schedule elimination.

4. A branch-and-bound algorithm

In this section, we describe the implementation of our branch-and-bound algorithm.

4.1. Branching strategy

Each node in the search tree corresponds to a partial schedule. A node in level r representsa partial schedule PS

�with r operations scheduled. Given PS

�, a set of new partial schedules each

consisting of PS�plus exactly one unscheduled operation is generated. Gi%er and Thompson [11]

have proposed an active schedule generation scheme for job shop scheduling problems. Thisscheme can be easily adapted to open shop scheduling problems. Our branching strategy is basedon the modi"ed active schedule generation scheme. Given a partial schedule PS

�, let;S(PS

�) be the

set of unscheduled operations corresponding to PS�. The branching procedure adopted is

described as follows.

Step 1: Calculate the earliest completion time of all operations in ;S(PS�). Let O

�H�H be an

operation for which the minimum earliest completion time t is achieved.Step 2: Let C(O

�H�H)-;S(PS

�) denote the con#ict set of operations associated with O

�H�H . If

jH"1,C(O�H�H) is the set of operations in ;S(PS

�) which belong to job J

�H , and whose earliest

starting time is less than t. Otherwise, C(O�H�H) is the set of operations in ;S(PS

�) which take place

on machine M�H or belong to job J

�H , and whose earliest starting time is less than t.

Step 3: For each operation O��

3C(O�H�H), generate a child node which corresponds to the partial

schedule PS��

in which operation O��is added to PS

�and started at its earliest starting time.

It can be seen easily that this branching procedure generates all possible active schedules for theproblem O

��GS(1)��C

�. In fact, it can be further improved by eliminating the duplicated schedules


generated during the branching process. The duplicated schedule elimination criterion is based onthe following idea. Suppose that there are two operations O

�H�and O

��H such that iHOl and kOjH

in the con#ict set C(O�H�H ), where C(O

�H�H) is the set of operations to be processed on machineM

�H or

belonging to job J�H . We call such a pair of operations unrelated since their earliest completion

times remain unchanged if we reverse the order at which they are scheduled. If such a situation canbe detected during the branching process, then it su$ces to generate only one of the schedules sincethe second one is redundant.Consider the following example of n"m"3 given in Fig. 2. Suppose that we are branching the

root node and that O�H�H"O

��. Then C(O

��)"�O

��,O

��,O

��,O

��,O

��. The following pairs of

operations are unrelated: (O��,O

��), (O

��,O

��), (O

��,O

��), and (O

��,O

��). For each unrelated pair

of operations, only one sequence of the operations needs to be considered. As shown in Fig. 2, thelast four branches can be discarded later during the branching process.

4.2. Bounding strategy

The algorithm RELAX presented in Section 3 can be easily modi"ed to take into account a givenpartial schedule. Furthermore, it is modi"ed to produce the job completion times C

�,C

�,2,C

�corresponding to the lower bound value J¸B. The lower bound J¸B can be further improved byconsidering the following. Given a partial schedule, letD

�be the earliest completion time and;

�be

the set of unscheduled operations of machine M�, j"1, 2,2,m. The unscheduled operations of

a machine may have di!erent ready times. Therefore, determining D�, for each j"1, 2,2,m, is

equivalent to solve a 1�r��C

��problem for which it is known that the earliest ready time (ERT) rule

produces an optimal schedule. Let D�H"max

��D

�:;

�O�. If jHO1, any one of the opera-

tions in the set ;�H may be processed last on machine M

�H and thus completed at time D

�H .

Otherwise, according to the given sequence of jobs on machine M�, operation O

��is the only

candidate to be processed last on machine M�and completed at time D

�H . An improved lower

bound ¸B1 can be de"ned as follows:

¸B1"J¸B#�,

where

�"�

(D�H!C

�)� if jH"1,

min��

�D�H!C

�: D

�H'C

�,O

��H3;

�H� if jHO1

and (x)� denotes max�0, x�.The lower bound ¸B1 considers only the machine with the largest earliest completion time in

improving the job-based lower bound J¸B. If �'0, ¸B1 can be further tightened, in a similar

way, by considering the machine with the second largest earliest completion time. Suppose that thevalue of

�is achieved by job J

�H , i.e.,

�"D

�H!C

�H'0. Let D

�HH"max

��D

�: jOjH,


;�O+�. That is, machine M

�HH has the second largest earliest completion time D

�. De"ne

D�HH!C

�HH"�

D�HH!C

�if jHH"1,

min��

�D�HH!C

�: D

�HH'C

�,O

��HH3;

�HH� if jHHO1.

That is, J�HH is the job selected to be processed last on machineM

�HH and completed at time D

�HH . An

improved lower bound ¸B2 can be thus de"ned as follows:

¸B2"¸B1#�,

where

�"�

0 if iHH"iH,

(D�HH!C

�HH)� if iHHOiH.

The lower bound ¸B2 is used in the branch-and-bound algorithm developed in this paper.We illustrate the computation of ¸B1 and ¸B2 via a simple example. Consider the problem

instance of n"m"4 with the following data.

p��

J�

J�

J�

J�

M�

1 9 4 10M

�6 4 6 9

M�

9 7 2 3M

�3 7 10 3

Suppose that we are given the partial schedule as shown in Fig. 3. The lower bound J¸B generatedby algorithm RELAX is 96 with C

�"20, C

�"28, C

�"22, and C

�"26. In this case, we have

;�"�O

��, ;

�"�O

��,O

��, ;

�"�O

��,O

�� and ;

�"�O

��,O

��. Hence, the earliest ma-

chine completion times are D�"24, D

�"26, D

�"23, and D

�"23. The gives

D�H"max�24, 26, 23, 23�"26 with jH"2. By de"nition, we have

�"min�D

�H!

C�,D

�H!C

��"min�26!20,26!22�"4. Thus, we have ¸B1"J¸B#

�"96#4"100.

Note that �"4 is achieved by job J

�, i.e., iH"3. The machine with the second largest earliest

completion time is M�, that is, D

�HH"D

�"24. Thus, we have D

�HH!C

�HH"

D�!C

�"24!26"!2 and

�"(!2)�"0. In this case, ¸B2"¸B1. We remark that in

other cases the value of �may be strictly positive and hence the resulted lower bound ¸B2 may be

strictly greater than ¸B1.

4.3. Search strategy

Initially, the heuristic presented in Section 2 is used to calculate an upper bound for the problem.The upper bound is updated whenever a complete schedule that improves the upper bound isgenerated during the search process. The following mixed best-"rst and depth-"rst strategy is usedin the search process. The best-"rst search is "rst performed until the number of nodes generated


Fig. 3. A given partial schedule.

Table 3Performance of the branch-and-bound algorithm

n�m ¸B2/OP¹ CP; NODES ;NSO¸

4�4 0.95 0.02 1 628 05�5 0.96 1.76 88 395 06�6 0.97 925.43 29 187 479 07�7 0.98 53114.72 797 556 143 7

reaches 1000; thereafter, the depth-"rst search is applied. We have found that this mixed strategyperforms better than with the best-"rst search and the depth-"rst search used separately. For eachnode generated during the search process, a lower bound for this node is calculated. If the lowerbound plus the cost of the associated partial schedule is greater than or equal to the current upperbound, the node is discarded.

5. Computational experiments

We tested the branch-and-bound algorithm and the heuristic proposed with randomly generatedproblems on a Pentium III-600 personal computer using the programming language C. Thebranch-and-bound algorithm was tested on problems with up to n"m"7, whereas the heuristicwas tested on problems with up to n"m"30. We generated only square problems (n"m) sincesuch problems are harder solvable than the other ones [12]. For each operation, an integerprocessing time is generated from the uniform distribution u[1,10]. For each problem size, 25instances are generated.We present the results of our computational runs associated with the branch-and-bound

algorithm in Table 3. We terminate the execution of the branch-and-bound algorithm after 50 h ofCPU time. For each problem size, the average ratio of the lower bound ¸B2 at the root node overthe optimal value (¸B2/OP¹), the average CPU time in seconds (CP;), the average number of


Table 4Performance of the lower bound ¸B2

n�m ¸B2/¸B0 CP;(¸B2)/CP;(¸B0) NODES(¸B2)/NODES(¸B0)

4�4 1.03 0.912 0.6105�5 1.02 0.987 0.7746�6 1.06 0.305 0.206

Table 5Performance of the heuristic

n�m HE;/OP¹ HE;/¸B2 CP;

4�4 1.025 0.1145�5 1.041 0.2806�6 1.047 0.4617�7 1.043 0.70510�10 1.077 1.68815�15 1.083 5.41720�20 1.089 12.44130�30 1.076 41.279

Average 1.039 1.081

nodes generated (NODES), and the number of unsolved instances (;NSO¸) are reported. Unsolvedinstances are excluded from the calculations of above performance measures. All the instances withn"m)7 are solved to optimality, except for 3 instances of n"m"7. As can be observed fromTable 3, both the average CPU time and the average number of nodes generated increase rapidly asthe problem size increases. Our lower bound ¸B2 performs quite satisfactory. The averagedeviation of the lower bound ¸B2 from the optimal value is about 4%.To test the e!ectiveness of our lower bound ¸B2, we compare in Table 4 the results of the

branch-and-bound algorithm based on lower bound ¸B2 with the results of the branch-and-boundalgorithm based on the simple lower bound ¸B0. It can be seen from Table 4 that the lower bound¸B2 signi"cantly outperforms the simple lower bound ¸B0. The improvement of ¸B2 over ¸B0seems to increase as the problem size increases.In Table 5 we report on the performance of the heuristic presented in Section 2. For small

problems (n"m)7), the solution obtained by the heuristic (HEU) is measured against theoptimal value obtained by our branch-and-bound algorithm. The average optimality gap is about4%. For large problems (n"m'7), the solution found by the heuristic is compared to the lowerbound value ¸B2. The average gap is about 8%. Table 5 also gives the average CPU time of theheuristic for each problem size. As shown in Table 5, the heuristic is able to "nd good solutionswithin a short time.


Table 6Results for di!erent processing time distributions of operations on machine M

�

Distribution n�m HE;/OP¹ ¸B2/OP¹ CP; NODES

p��

3;[1, 10] 4�4 1.025 0.951 0.024 1 6285�5 1.041 0.964 1.763 88 3956�6 1.047 0.973 925.431 29 187 479

p��

3;[6, 15] 4�4 1.022 0.996 0.013 5095�5 1.020 0.997 0.496 11 9616�6 1.038 0.998 653.616 9 304 251

p��

3;[11, 20] 4�4 1.013 1.000 0.005 625�5 1.027 1.000 0.102 2 1476�6 1.015 1.000 26.962 316 900

Finally, Table 6 presents the results of the proposed algorithms for di!erent processing timedistributions of operations on machineM

�. Since the operations on machineM

�are processed in

a given order, the relative length of the operations on machine M�compared to the other

operations will have a signi"cant e!ect on the problem hardness. We compare the results forp��

3;[1, 10], p��

3;[6, 15] and p��

3;[11, 20] for all i, with p��

3;[1, 10] for all i and jO1. AsTable 6 shows, the performances of both the heuristic and branch-and-bound algorithm improveas the processing times p

��'s increase. Hence, the problem becomes easier to solve as the processing

times p��'s increase.

6. Conclusions

In this paper we have examined the problem of scheduling open shops to minimize totalcompletion time with a given sequence of jobs on one machine. We have derived a new lowerbound based on the optimal solution of a relaxed problem in which the operations on everymachine may overlap except for the machine with a given sequence of jobs. Our experimentalresults show that the new lower bound outperforms the classical simple lower bound de"ned as thesum of all processing times. We have also developed a heuristic, based on iterative dispatching, fore$ciently solving large-scaled problems, and a branch-and-bound algorithm for optimally solvingsmall-scaled problems.In view of our experimental results, the problem under consideration is extremely di$cult. Our

results indicate that even sharper upper and lower bounds are needed to cut down the size of thesearch space. Also, more e$cient branching strategy is necessary to further improve the perfor-mance of the branch-and-bound algorithm. The approach considered in this paper may lead to thedevelopment of branch-and-bound algorithms for more general performance criteria than totalcompletion time such as total tardiness. The ideas presented here may also be extended to moregeneral open shop scheduling problems.


Fig. 4. A schedule with �C�"9X.

Appendix A. Proof of Proposition 1

Proposition 1. The problem O��GS(1),R��C

�is NP-hard in the ordinary sense even for three jobs.

Proof. Consider the PARTITION problem that is known to be NP-complete [13]: given a setS"�a

�, a

�,2, a

�� of r integers with ��

��a�"2X, does there exists a partition of S into two

subsets > and Z such that ��a�"�

��a�"X?

Given an instance of PARTITION, we de"ne in polynomial time the following instance ofO

��GS(1),R��C

�with n"3 jobs and m"r#1 machines. The processing times are

p��

"X, i"1, 2, 3,

p��

"a�, i"1, 2, 3, j"1, 2,2, r.

MachineM�has to process the jobs in the sequence J

�, J

�, J

�. We show that in the constructed

problem a schedule Ssuch that �C

�(S

))9X exists if and only if PARTITION has a solution.

Suppose that PARTITION has a solution, and > and Z are the required subsets of S. Let �(>)and �(Z) denote an arbitrary permutation of the machinesM

�,M

�,2,M

��that correspond to

> and Z, respectively. Then, the desired schedule Sexists (Fig. 4). In S

, all jobs are processed

continuously from time 0 to time 3X. Job J�is processed on machines in the sequence

M�, �(>), �(Z). Job J

�is processed on machines in the sequence �(>),M

�, �(Z), and job J

�is

processed on machines in the sequence �(>), �(Z),M�. Clearly, we have �C

�(S

)"9X.

Suppose now that there exists a schedule Ssuch that �C

�(S

)"9X. Since each job lasts 3X,

each job is processed continuously in S. So, there exists a set of machines on which the sum of

processing times of job J�is equal to X. Such a situation is possible only if PARTITION has

a solution.This proves the proposition. �

Appendix B. Proof of Proposition 2

Proposition 2. Algorithm RELAX xnds the optimal ��C

�value for O

��GS(1),R��C

�.


Proof. Let SH be an optimal schedule for O��GS(1),R��C

�, and= be the set of schedules generated

by algorithm RELAX. We show that SH can be transformed into a schedule belonging to =,without increasing total job completion time. To accomplish that, we execute algorithm RELAXand check at each step k if algorithmRELAX "nds the same job completion time as in SH for job J

�.

Let t"C��

. A discrepancy implies that the subset of operations, belonging to job J�, processed

before operation O��in SH has a total duration di!erent from B(k, t) and A(k, t). This can be

adjusted easily since any operation O��, jO1, processed before (after) operation O

��can be moved

to be processed after (before) operation O��without increasing the completion time of job J

�. The

"nal schedule adjusted by this process belongs to=. Hence, algorithm RELAX "nds the optimal��

��C

�value for O

��GS(1),R��C

�. �

References

[1] Gueret C, Prins C. A new lower bound for the open-shop problem. Annals of Operations Research 1999;92:165}83.[2] Sharfransky YM, Strusevich VA. The open shop scheduling problem with a given sequence of jobs on one machine.

Naval Research Logistics 1998;45:705}31.[3] Achugbue JO, Chin FY. Scheduling the open shop to minimize mean #ow time. SIAM Journal on Computing

1982;11:709}20.[4] Brucker P, Hurink J, Jurisch B, Wostmann B. A branch & bound algorithm for the open-shop problem. Discrete

Applied Mathematics 1997;76:43}59.[5] Gonzales T, Sahni S. Open shop scheduling to minimize "nish time. Journal of the ACM 1976;23(4):665}79.[6] Gueret C, Prins C. Classical and new heuristics for the open-shop problem. European Journal of Operational

Research 1998;107(2):306}14.[7] Brasel H, Tautenhahn T, Werner F. Constructive heuristic algorithms for the open shop problem. Computing

1993;51:95}110.[8] Tanaev VS, Sotskov YN, Strusevich VA. Scheduling theory.Multi-stage systems. Dordrecht: Kluwer Academic, 1994.[9] Strusevich VA. Shop scheduling problems under precedence constraints. Annals of Operations Research

1997;69:351}77.[10] Martello S, Toth P. Knapsack problem. New York: Wiley, 1990.[11] Gi%er B, Thompson GL. Algorithms for solving production scheduling problems. Operations Research

1960;8:487}503.[12] Taillard E. Benchmarks for basic scheduling problems. EJOR 1993;64:278}85.[13] Garey MR, Johnson DS. Computers and intractability. A guide to the theory of NP-completeness. San Francisco:

Freeman, 1979.

Ching-Fang Liaw received B.B.A. andM.S. degrees in Industrial Management from National Cheng Kung University,Taiwan, and a Ph.D. degree in Industrial and Operation Engineering from the University of Michigan, MI. He iscurrently a Professor at the Chaoyang University of Technology, Taiwan. His research interests include combinatorialoptimization and heuristic search methods with applications to production scheduling, and vehicle routing andscheduling.Chun-Yuan Cheng received B.S. degree in Industrial Engineering from Chung-Yuan University, Taiwan, andM.S. and

Ph.D. degrees in Industrial Engineering from Auburn University, AL. She is currently an Associate Professor atChaoyang University of Technology, Taiwan. Her research interests include input analysis in simulation, maintenanceand reliability, and production scheduling.Mingchih Chen received a B.S. degree in Industrial Engineering from Chung Yuan Christian University, Taiwan, and

M.S. and Ph.D. degrees in Industrial Engineering from the Texas A&MUniversity, Texas. She is currently an associateprofessor at the Chaoyang University of Technology, Taiwan. Her research interests include reliability, maintainabilityand production scheduling.


Documents

The total completion time open shop scheduling problem with a given sequence of jobs on one machine