IEEE TRANSACTIONS ON ROBOTICS AND AUTOMATION, VOL. 12, NO. 6, DECEMBEK I996 x35

Single Machine Scheduling with Chain Structured Precedence Constraints

and Separation Time Windows Chengbin Chu and Jean-Marie Proth, Member., IEEE

Abstract-- We consider a single machine scheduling problem which we studied to improve the efficiency of an automated medical laboratory. In this problem, there are not only chain- structured precedence constraints, but also minimal and maximal times separating successive jobs in the same chain (separation time windows). The criterion to be minimized is the makespan. Potential applications are not restricted to medical analysis. This problem often arises in systems where chemical processes are in- volved. Therefore the problem studied in this paper is important in practice. We prove that the prohlem is nonpolynomial (NP)- complete. A s a consequence, we propose three heuristics for large size problems and a branch and bound based algorithm for small size problems. Computational results are reported.

I. INTRODUCTION N THIS' PAPER, we consider a single machine scheduling I problem which we studied to improve the efficiency in a

medical lalboratory. The problem can be stated as follows. A set of jobs available at time 0 should be scheduled on a single machine that can process at most one job at a time. There are chain-structured precedence constraints between jobs, and the separation time between two successive jobs in a chain is lower and upper bounded.

The origin of this problem is a medical laboratory. In a medical la.boratory, a number of analyses of various types have to be performed every day to check the presence of AIDS, C-hepatite, and other diseases. Typically, an analysis consists of two or three biological reactions, according to the type of the analysis (i.e., the disease one wants, to check). Before each biological reaction, a robot is used to introduce chemical or biological elements into the test tube. At the end of a test, the robot has to read the result of the reactions. The times required by the robot to perform these operations are known and fixed. The duration of a biological reaction, however, i.s lower and upper bounded: it should belong to the time interval defined by these bounds in order to guarantee the correctness of the results. Fig. 1 shows two types of analyses where cross-hatched boxes are robot operations and plain boxes are biological reactions. Note that the scale is not

Manuscript received April 8, 1994; revised August IO, 199.5. This paper was recommended for publication by Associate Editor P. B. Luh and Editor A. Desrochers upon evaluation of reviewers' comments.

C. Chu is with the Projet SAGEP, INRIA-Lorraine, CESCOM Technople Metz 2000, :57070 Metz, France.

J.-M. Proth is with the Projet SAGEP, INRIA-Lorraine. CESCOM Techno- ple Metz 2000, 57070 Metz, France and the Institute for Systems Research, University of Maryland, College Park, MD 20742 USA.

Publisher Item Identitier S 1042-296X(96)05736-9.

19" 20" I S " 17"

3O'flS" 3S'f15" pq 12" IS" 14', I X"

Fig. I . Examples of analyses

verified in this figure: the periods corresponding to biological operations are more than 100 times greater than the duration of a robot operation.

We consider a system with a single robot. The goal is to perform a given set of analyses within a minimal period of time. In other words, we want to minimize the makespan. In this medical analysis problem, jobs to be scheduled are robot operations, analyses correspond to chains, and lower and upper bounds on the durations of biological reactions constitute separation time windows.

Note that potential applications of this study are not limited to medical analysis. The problem studied here often arises in systems where chemical processes are involved and the jobs to be scheduled are transportation operations. Consider a chemical plant in which each chemical process is a sequence of chemical reactions whose durations are upper and lower bounded to guarantee the quality of the product. Chemical reactions are performed in different locations. A transportation system is used to carry the product from one location to the next. These kinds of moves are called loaded moves. The time needed by a loaded move (called transportation time) comprises the unloading time at the departure place (i.e., the time needed by the robot to grasp the product at the departure place), the travel time from the departure location to the destination, and the loading time at the destination (i.e., the time required to deliver the product at the destination place). All these times are known and sequence independent. Consequently, transportation times are sequence independent. Other kinds of moves are called void moves; they consist of traveling from one location, where the robot just finishes loading a product, to another location, where the robot has to unload a product. We can see that only a subset of all the possible void moves has to be performed to complete the required set of tests, and this subset is sequence dependent. Our model corresponds to the case where time needed to perform void moves is negligible compared to transportation

1042-296X/96$05.00 0 1996 IEEE

836 JEEE TRANSACTIONS ON ROBOTICS AND AUTOMATION, VOL 12, NO 6, DECEMBER 1996

times. Therefore, when a loaded move finishes, another one can start immediately. This assumption is not restrictive; it is applicable to systems handling fragile and/or heavy products. In this case, for safety reasons, the speed should be slow during the transportation, and the loading and unloading times are also important, while the time needed by void moves is very short compared to the previous ones, and thus can be neglected or included in the loading orland unloading moves. In these systems, a chemical process is a chain, and lower and upper bounds on the durations of chemical reactions form separation time windows.

In the literature, single machine scheduling problems have been extensively studied under various assumptions and crite- ria. Gupta and Kyparisis [ 101 and Lawler et al. [ 141 surveyed hundreds of papers. After these surveys, a large number of new papers were published. In most papers, there is no precedence constraint between jobs. In the cases where there are prece- dence constraints, the separation time between two jobs is not bounded. These kinds of models can be found in mechanical manufacturing systems, but not in chehical processes. To our knowledge, no work has been published on the same problem as the one presented in this paper. In fact, the maximal separation times make the problem very difficult: without these constraints, any sequence would be feasible. When maximal separation times are involved, additional effort should be made even to find a feasible solution. These constraints also make the Lagrangian relaxation approach inapplicable to this problem. The difficulty comes from the fact that with maximal separation times, no algorithm is available to construct a feasible solution from the optimal solution of the relaxed problem. In fact, none of the problems considered till now in Lagrangian relaxation literature has maximal separation time constraints. The algorithms used to construct feasible solutions from the optimal solution of the corresponding relaxed problems cannot be applied to our problem since they cannot guarantee the feasibility of the obtained solutions.

Some authors do consider scheduling problems in envi- ronments where chemical processes are involved. To our knowledge, these problems are hoist scheduling problems in electroplating systems. In these systems, products have to visit a given number of tanks in a given order. The transportation of a product from one tank to the next is carried out by hoists. In each tank, a product has to stay for a time which is upper and lower bounded to guarantee the desired properties of the product. The problems studied so far concern cyclic production environments: the system periodically comes back to the same state. In these'environments, the same mix of products are produced during each cycle. All the studies published till now consider a monoproduct system in which a unique type of products is concerned. Lei and Wang [ 151, [ 161, Phillips and Unger [22], and Shapiro and Nuttle [24] examine the problem with a single hoist. We proposed a more efficient approach based on graph theory [SI which reduces significantly the computation time. The problem with two hoists is studied by Lei and Wang [ 171 using a minimum common cycle algorithm and the results obtained for single hoist scheduling problems.

Our problem can be considered as a noncyclic multiproduct (instead of monoproduct since a chain can be seen as a

product) hoist scheduling problem in which the capacity of each tank is infinite. From this remark, one can see that the results published by hoist scheduling problems cannot be applied to our problem. Compared to the current hoist scheduling literature, the main difficulty comes from the fact that various types of chains (which correspond to different types of products) should be considered.

Our contribution lies in the proof of nonpolynomial (NP)- completeness and the development of algorithms to solve this real-life problem. We propose two kinds of algorithms: heuristics to solve large size problems arising in the medical laboratory mentioned previously, and a branch and bound algorithm to obtain optimal solutions for small size problems that may arise in the future and/or in other environments. This branch and bound algorithm can also be used to evaluate the performance of the heuristics, when small size problems are concerned.

In Section.11, we provide a formulation of the problem which will be used later when developing lower bounds. In Section 111, we show that the problem is NP-complete, which means that the existence of a polynomially bounded algorithm is unlikely. For large size problems, only heuristics can be used. We propose in Section IV three heuristics based on priority rules. For small size problems, we develop in Section V a branch and bound algorithm. Computational results are 'reported in Section VI.

11. PROBLEM FORMULATION

Let N be the number of jobs to be scheduled. Let n be the number of chains and m; the number of jobs in chain i. The total number of jobs is then N = Cyzl m;. We denote by ( i , j ) the j t h job in chain i . Processing this job requires p; , j (>O) units of time, called processing time. The processing of a job cannot be interrupted, that is, there is no preemption of jobs. Besides the precedence constraints described by the chains, the completion of job ( i , j ) and:the beginning of job ( i , j + l ) should be separated by a time belonging to [ F i , j , J&], called separation time window, where l z , j ( 20) and L;,j(>li,j) are, respectively, the minimal and the maximal separation time between jobs ( i i j ) and ( i , j + 1). We are looking for a schedule which minimizes the makespan. If Ci,J ( s ) denotes the completion time of job ( i , j ) in a schedule s (when there is no ambiguity, we simply write Ci,j), then the problem can be formulated as follows:

subject to

C,i,3+1 - Ci,,, 2 p i , j + l ; , j , V j < m i , V i (2) ( 3 ) (4)

C . . - C . . L , J L,J+1 - -&,j - 3 Vj mi, Vi

c . , > . .

Ci,j - C;i,ji 2 p; , i

L , ] -Pl,.l, w <%,'di or Cij,,ii - Ci,j 2 pi/,jt

V ( i , j ) # ( i ' , j ' ) . (5)

Constraints (2) and (3) are introduced to ensure that the separation time between two successive jobs in the same chain is lower and upper bounded. Constraints (4) say that no job

CHU AND PROTH: SINGLE MACHINE SCHEDULING 837

can be processed before time 0. Constraints ( 5 ) are capacity constraints expressing the fact that the machine can perform at most one job at a time. The fact that no preemption is allowed is implicitly taken into account in constraints (2)-(5).

111. NP-COMPLETENESS

In this section, we show that the problem formulated in Section I1 is NP-complete by showing that the problem is reducible ‘to a knapsack problem which is well known to be NP-compkte.

Theorem I : The single machine scheduling problem with chain-structured precedence constraints and separation time windows between successive jobs in the same chain to mini- mize makespan is NP-complete.

Prooj’: Given integers (1.1, a2, . . . , a t , b , the decision ver- sion of the knapsack problem consists of answering the ques- tion, “Is there a subset S c T = {1,2, ‘ . . , t } such that C;,s ai I= b?” This problem is known to be NP-complete. We prove the NP-completeness of our problem by showing that there is an instance such that it gets an answer “yes” if and only if the knapsack problem does. Let A = E:=, a;, and define a c’orresponding instance of the considered problem in the following way:

n = t + 1 m,,; = 1, pi , l = ai, Vl 5 i < ri

mrr = 2, pn,1 = pn,z = 1, ln,1 Ln,1 b. We want to know if there is a schedule such that the makespan is less than or equal to A + 2.

If EiEs ui = b for some S c T = {l,2,...,t}, i.e., if the knapsack problem gets an answer “yes,” then a schedule with a makespan less than or equal to A + 2 is obtained by scheduling the jobs in the following order: (,n, l), { ( i , l)li E S}, (n, 2) , { ( i , l)( i E T - S}. This means that our problem gets an answer “yes” if the knapsack problem does.

On the other hand, for any feasible processing order 0, T can be decomposed into three subsets SI ( O ) , Sz ( O ) , and T - SI (0) - 5’2 ( O ) , such that jobs belonging to SI (0) ,S2 (0), and T - SI (0) - Sz (0) are, respectively, processed before (n , 1). between ( n , 1) and (n, 2), and after (n, 2). For the order 0 to be feasible, it is necessary that CiEs2(0) U ; 5 0, otherwise the constraint on the maximal separation time between (n, 1) and (n, 2) would be violated. If the knapsack problem gets an answer “no,” then there is no subset S C T = { 1 , 2 , . . . , t } such that C L E s a; = b. Therefore, no order 0 exists such that C ; E ~ , ( o ) a i = b. In other words, for any feasible order 0, we have :CLEs2(o) ai < I , b. The makespan of any schedule 0 is then

C U i + 2 + b + U;

i E SI (0) itT-Si ( O ) - S 2 ( 0 )

> C a , + 2 + C n i + ui i E S I ( 0 ) i E S2 (0) LET- SI (0) - S2 (0)

= Ea( + 2 = A+2. i t T

This means that our problem gets an answer “no” if the knapsack problem does.

We showed that our problem gets an answer “yes” if and only if the knapsack problem does. The NP-completeness is proved. Q.E.D.

Since the problem considered is NP-complete, it is neces- sary to use an implicit enumerative algorithm to obtain an optimal solution, which is unrealistic for large size problems. Therefore, we propose heuristics to cope with the complexity of large size problems.

IV. ALTERNATIVE HEURISTIC ALGORITHMS

In this section, we present three alternative versions of a heuristic algorithm. They are based on priority rules. First of all, we,show how to calculate the completion times for a given sequence of jobs s , or to detect the unfeasibility of this sequence. Note that sequence .Y provides the order in which the N jobs should be processed. Since the separation time between two successive jobs in the same chain is upper bounded, this calculation is not straightforward. Let k be the rank of a job in s , ~ ( s ) be the chain which contains this job, and wk(s) the rank of this job in chain c k ( s ) . We are looking for the completion times C,,(,),,,(,),k = 1 , 2 , . . . , N , sukh that the makespan is minimized. This problem, denoted by P1, can be formulated as follows by replacing disjunctive constraints ( 5 ) by conjunctive ones.

Problem PI:

subject to

c,, (Y),W, (5.) - cc, ( 9 ) , W L (s)-1 > P o ( S ) , W , ( s ) + l e , ( s ) ,WI: ( s ) - 1

c,, (.),Tu, (s)-1 - c c , (s ) ,w, ( 3 ) 2 - P o (J),Wk (a )

Vk such that w k ( s ) > 1 (7)

L, ( S ) , W k (s)-1 -

V k such that wk(s) > 1 (8) Cc,(a),w,(s) ~ P C l ( S ) , W , ( 3 ) (9)

(10)

This is a linear programming problem. However, this prob- lem has a particular structure. In all the constraints except one [i.e., (9)], exactly two coefficients of the variables are different from 0, and one of these coefficients is 1 and the other one is -1. Due to this particular structure, the problem can be represented by a directed graph with N + 1 vertices {O, 1 , 2 , . . . , N } . If we denote by 7r,i,j(s) the rank taken by job ( i , j ) in sequence s then, in this graph, for any k such that w k ( s ) > 1, there is:

cc,(s),wk(s) - Cc,-,(,),,,-,,S) L P C , ( S ) , W , ( S ) ! ‘J1 < I C 5 N .

1) an arc which is P ~ ~ ( ~ ) , ~ ~ ~ ( ~ ) + k k ( s ) , w k ( s ) - l units in

2 ) an arc which is - P ~ ~ ( ~ ) , ~ ~ ~ , ( ~ ) - & k ( a ) , u , k ( s ) - ~ units in length from vertex T ~ , ( ~ ) , ~ ~ , ( ~ ) - ~ ( S ) to vertex k ;

length from vertex k to vertex T ~ ~ ( ~ ) , ~ , ( ~ ) - ~ ( S ) .

For 1 5 k 5 N , there is an arc which is p c k ( s ) , w k ( 3 ) units in length from vertex k - 1 to vertex k . According to [23], this problem has a feasible solution if and only if there is no circuit with positive length in the graph. If so, there is an

8% IEEE TRANSACTIONS ON ROBOTICS AND AUTOMATION, VOL. 12, NO. 6, DECEMBER 1996

optimal solution such that for any k:( l I k I N ) : C,,(,s),u,, (.)

is the length of the longest path from vertex 0 to vertex k:. The computation of these lengths and the detection of possible circuits whose length is positive can be solved by the algorithm due, to Ford [8]. Applied to our problem, this algorithm called TIMING, is as follows. It provides an optimal solution to problem P1.

Procedure TIMING:

2) For k from I to N do 1) J L := 0; C;k(,q),u;A (,%) := O,Vk = o> 1.. ' . , N .

lt lr. h " C L (.s) , U ) ) k (.) : = Illax{ "c , ( 3 ) , W L , (s ) CC,,~ ~ 1 (s ) . U l k ~ 1 ( s )

+ Yc, ( s ) , i u k (.s) 3 X, Y } where

X 0 if % u ~ ( s ) = 1 " ~ k ( s ) , l u k ( . s ) - - I + p , k ( a ) , = , k ( s ) + ' Q ( ~ ) , L U ~ ( S ) - ~

0 if i i i k ( s ) = 'rrl,,L(s)

otherwise i i = c:k(s),wk(,?)+,l - PC,. ( ,9) , i I lA (.s)+l - & . ( . S ) . L u k ( s )

otherwise

for any 0 5 k 5 N done.

then STOP, otherwise if h < N - 1 then 11 := h + 1,

Step 2), otherwise the given sequence is not feasible.

- It-1 3 ) If " : k ( s ) , u I k ( s ) - C C k ( S ) , U I A ( S )

h 11-1 CCk(B),Wk(.s) = C c k ( s ) . w k ( . 5 ) : ~ k = 0,1, ' ' ' 3 N , and go to

At the end of Step 2), C'I", (.s),Toi is the length of the longest path from vertex 0 to vertex k:, among those containing at most h backward arcs (i.e., arcs which join a vertex to another one having a lower index than the first one). The value of h varies from 0 to N - 1 and the value of k: varies from 1 to N for each value of h. Therefore, the computational complexity of the procedure TIMING is O ( N 2 ) . Of course, one can use other shortest/longest path algorithms such as SPS (shortest path simplex, see [7]) , but the complexity of these algorithms is O ( N 3 ) ) . These algorithms are efficient only when the number of arcs in the graph is huge.

We now show an interesting property concerning the results of Procedure TIMING. Let { C1*,j} and { Cl,,} be, respectively, the solution obtained by Procedure TIMING and a feasible solution of P1. The following property holds.

Property I . - C:>j < C;,,,W I:'< m i > Y i E { l , 2 1 . . . , ~ ~ } . This property is derived from the fact that for any ( i , : j ) C,L*3

is the length of the longest path from vertex 0 to the vertex corresponding to job ( i , j ) , that is, vertex ~ . ~ , , j ( s ) . Assume that there is a job (i,.i) such that GL*,,j > C:,,). Without loss of generality, we can assume that for any vertex U preceding 7 r i , j ( s ) in the longest path from 0 to 7 r c , i ( s ) . C ~ 1 6 c s , , u l ~ i ( s , < where 'U is the vertex which immediately precedes ni , , ] ( s ) in this path. From the definition of the longest path, we have CT,,j = C.',,,(,q,,,,, + D , where D is the length of the arc from vertex I I to vertex 7 r ; , . j ( s ) . The relation CZ:) > C:,,,

C~L, (s ) ,TL) l , ( s ) = D. In turn, this relation implies that the

in contradiction with the assumption that {Cl,,j} is a feasible solution to problem PI. Q.E.D.

c:t,(s),w<'(s)l which implies that C.C. I , ( 5 ) ; U l t , ( S ) . 5 C:L,(.q),u><,(.s)3

implies that C:..j - CLL,(s)juv(.s) < ' L * j - ':t ( .s) ,u ;<, (s) I CL*,,., -

, - Ccf(,y),,(,L,(,5) 2 D is not verified, which is

Property 1 is important to compute the lower bound required in the next section.

The Procedure TIMING is used both in the heuristics presented hereafter and in the branch and bound algorithm developed in the next section.

In each of the heuristic algorithms, we schedule the jobs of a new chain at each iteration. At the beginning of the zth iteration, (z ~ 1) chains are already scheduled. We denote by s,-1 this feasible partial schedule, and by I , the set of 'unscheduled chains when the xth iteration starts. sz-l is empty if z = 1. The goal at this iteration is to select a chain .i E I , and to merge the jobs of i in the jobs of the sequence sz-l to obtain s2(. i) .

The first task is to select i , and the second is to merge the jobs of i in stPl.

We decided to select the chain i E I, such that the first job of i can start the earliest. If more than one chain meet this condition, we select one of them using one of the following three policies.

1) Select the chain 1 with the largest X i value, where m, - 1

J=1 j=1

A, represents the smallest length of chain i . 2) Select the chain with the largest sum of job processing

times. 3) Select the chain whose first job has the longest process-

ing time. If several chains lead to the same value, select the chain whose second job has the longest processing time, and so on.

These three policies lead to three alternative versions of a heuristic algorithm. These three policies have the same intuitive interpretation: schedule first the chains which are the most difficult to schedule or, more pre- cisely, which require a large amount 'of time, and thus may penalize the makespan if they are not performed soon enough.

The detailed explanation of the selection procedure is in-

General Scheme: I ) We suppose that Il contains the n chains ordered

according to the policy used. Set z = 1 and so = 0. 2) While z I n, do

cluded in the general scheme described hereafter.

7 := +W.

For s i from I to TI, and ,i E 1, do Construct the schedule sz( i ) by merging the jobs of i

If C i , ~ ( s ~ ) - p ~ , ~ < 7 then7 := Ci , l ( sz ) -p i , l , i* := 2,

done

in s,-1 (this construction is explained later).

s; := s,(i).

Iz+l := I , - { a * } , s2 := s;, z := z + 1.

done. Note that at the end of the loop on i , 7 is the earliest time

at which a chain belonging to I , can start to be processed. According to the general scheme, one chain' is scheduled

at each iteration. At the zth iteration, (n + 1 - z )

CHU AND PROTH: SINGLE MACHINE SCHEDULING 839

chains have to be tested, which means that sz( i ) must be computed for (n + 1 - z) chains i . Therefore, E;=, (11 f 1 - z) = w ( n + 1)/2 partial schedules have to be computed during the whole computation. The complexity related to each schedule will be examined later.

Now, vve consider the second question, that is, the con- struction of s z ( i ) starting from the partial schedule s , - ~ and a chain i . A chain i is scheduled by merging successively jobs ( i , l ~ ’ , ( i , 2 ) , . . . , ( ~ , ~ ~ i ) in s,-1. We denote by oj(1 5 .j 5 mi ) the schedule obtained after merging job ( i , j ) , and ( ~ 0 = sZ.-l. The partial schedule o j + l ( l < j 5 mi) being known, it may be impossible to merge job ( i , j ) in ojl. In this case, we say that the scheduling of job ( i , j ) fails and job (a , j ~~ 1) has to be rescheduled in order to increase its completion time.

A schedule (i.e., a sequence) aj-1 being known, we intro- duce zj which is a lower bound of the rank of ( i , j ) in aj-1.

If job ( i , , j ) is scheduled for the first time, in other words if ( i , j ) is not scheduled after a failure of job ( i , * j + 1), then:

1) if j = 1, xj is the rank following the one of the first

2) if , j > 1, i s the rank following the rank of ( i , j - 1). Note that :zj has no physical meaning. This lower bound

has been introduced to avoid useless computation. The sclhedule aj is derived from aj-1 by first computing

yj , which will be the rank of ( i , j ) in s j . For this purpose, we compute the “earliest” and the “latest” starting times T,,,,

and d,,,, of job ( U , U) for each previously scheduled job and for job ( i , j )

rz ; =

job of the last scheduled chain in s -1 ;

if j = 1, ’. { i i , j . - ~ (aj-I) + l,~,j-1 otherwise.

TtL,.I) = C,I‘,l(oj-l) - P,l,,l>, V ( U , V ) # ( i , j ) .

The rank g, to insert job ( i , j ) is then the first y such that

y 2 x3 and

[rc, (O,- l ) ,U), (u7-1) >PY or -

( T C u ( S T ~ - I ) , U J ~ (C3-1) -pY and d C y ( U l - l ) , W y ( 0 3 - 1 ) > ’ i > j 11 where = ~ ~ ~ ~ x { C ~ ~ ~ ~ ( ~ ~ - ~ ) , ~ ~ ~ ~ ~ ~ ( ~ , ~ ~ ) , ri , j} , which is the earliest time when ( i , j ) can start if it is the yth job in the schedule.

If job [cy(nj_l),uuy(nj-l)] can start earlier than ( i , j ) , then it takes the rank y, otherwise the most urgent takes this rank, the most urgent being the one with the smallest latest starting times. The idea behind this choice is from the well-known Schrage’s algorithm which is used to minimize the maximum tardiness (see [3] ) .

Rank yj found in this way may be such that puj > d i , j . In this case, job ( i , ;j) cannot take the rank yj, because this would violate the maximal separation time constraint between jobs ( s i , j - 1) and ( i , j). Therefore it is necessary to reschedule job ( , i , j - 1) by delaying its completion time by p,,, - d i , j . This is done by setting the earliest staring time ri,j-1 of ( i , j - 1) to the suim of pyJ - d i , ) and the starting time of ( i , j - 1) in “,;-I (i.e., C i ; , ; - i ( ~ , ~ - i ) - T)i , j - l ) .

To summarize, the construction of the partial schedule sZ( i )

Construction of Schedule s , (2):

1) Let j := 1,oo := ~ ~ - 1 , and assign to xk,k = 1 , 2 , . . . ,mi, the value of the rank taken by the first job of the last scheduled chain in sz-l increased by one.

starting from the partial schedule sZ-1 is done as follows.

2) While j 5 rrii do 2.1) If j > 1 then xj := niax(xj,yj-1 + 1). 2.2) Find a rank y j for job ( i , j ) as explained above. 2.3) If pyy, > d i , j , then’reschedule job ( i , j - 1) at the next step

”j-1 :=yj-1, Ti,j-l := py3 - di , j

+ Ci,j-l(0,7-1) - pa,3-I, j := j - 1.

Otherwise, construct a schedule oj by inserting ( 2 , j ) at rank y j and calculate the completion times using Procedure TIMING. If 0.i is not feasible then set xj := gj + 1 (reschedule job ( i , j ) at the next step), otherwise ”j := Y j , j := j + 1.

done. 3 ) s z ( i ) := ern. Step 2.1) guarantees that if job ( i , j ) is not scheduled for

the first time, it takes a rank greater than its previous rank. During the construction of s z ( i ) , in the worst case, at most

N ranks (there are at most N jobs and each job occupies a unique rank) have to be considered for each j . For each possible rank of j , Procedure TIMING is called once, the complexity of this computation is O ( N 2 ) . Therefore, the complexity to construct partial schedule s z ( i ) is The overall complexity of a heuristic is then O(n2N”1ii--+2), where mmax = maxl<i<, mi. Note that this is the com- plexity in the worst case.-In practice, the complexity is much less, at most three or four ranks instead of N ranks need to be considered for each j , due to the minimal and maximal separation times. If the separation time windows are tight, there are very few feasible ranks for each j . For instance, when scheduling job ( 2 , j ) at rank :y does not lead to a feasible solution because of the maximal separation time, no rank later than g needs to be considered. On the other hand, if the window is loose, few reschedulings have to be performed.

The heuristics are illustrated in the Appendix. It is very hard to perform a worst case analysis. However,

we can show that the asymptotic worst case bound is at least two. In other words, there are instances such that h / o tends to two, where h and o are, respectively, the criterion value (the makespan) given by the heuristics and the optimal one. Consider the following example:

rril = 3, PIJ = P, ~ 1 , 2 = PIJ = 1, 11.1 = 0 L1,l =11,2 = L1,2 = ( r i - 1)P.

pi,^ = P, rrl.~ = 1, V 1 < i 5 n.

Any of the alternative heuristic algorithms gives the follow- ing solution: (1, I), (2, I), , (3, I), , (n,1), (1 ,2) , (1 ,3)? which yields a makespan h, = ( 2 n - l)P + 2. An optimal solution is (1,1), (1 ,2) , (2 ,1) , (3,1), (n , l ) , (1 ,3)

840 IEEE TRANSACTIONS ON ROBOTICS AND AUTOMATION, VOL 12, NO. 6, DECEMBER 1996

which yields a makespan of o = nP + 2. Therefore h/o tends to be two when n and P tend to infinity.

The performance of these altemative heuristic algorithms for randomly generated instances is evaluated in Section VI.

v. BRANCH AND BOUND ALGORITHM

When the number of jobs to be scheduled is small, implicit enumerative algorithms apply. We present such an algorithm in this section. For this purpose, we first show how to calculate lower bounds and to identify unfeasible solutions. Based on these results, we develop a branch and bound algorithm. Computational experiences are reported in Section VI.

Let s be a partial schedule in which, if a job is scheduled, then all its predecessors in the same chain are scheduled, or equivalently, its immediate predecessor, if any, is scheduled. Let S denote the set of jobs scheduled in s. For any chain 2 , let z , be the number of scheduled jobs belonging to this chain. The problem of scheduling remaining jobs in order to minimize the makespan can be formulated as follows.

Problem P2.

Minimize max Cz,mz (1 1) G , j , V ( W ) 2 1 2 % < mz

Subject to (2), (3), and

CCl (S) ,WI ( s ) 2 P C l ( S ) , W l ( s )

CC,(S),W,(S) - CCk-,(S),Wk-I(S) 2PC,(S) ,Wk(S)

(12)

' v ' l < k I IS1 (13)

C2,J - ~c1.,(s),W,,,,s) > P 2 , 3 , V(z,.?) $ s (14)

q z , J ) $ s W , J O $ s and (Z ,J ) # (W).

(15)

CZJ - G~, f >P,J or c,y - CZJ 2 P2',3'

Constraints (2) and (3) can be rewritten as

C C , , S ) , W , ( S ) - c c ~ ( s ) w k ( s ) - l

2 P C , ( S ) , W k ( S ) + L ( s ) , w k ( s ) - 1

b'k 5 IS1 and w k ( s ) > l (16)

c c L ( s ) , W L ( s ) - l - CC,,S,>Wd~,

2 -Pc,(s),WI(s) - L ( s ) , t u ( s ) - l

'dk 5 IS1 and w k ( s ) > l (17)

CtJ - C2,J-l L P2J + L,3-1

'v'j>l and ' v ' j > l and ( i , j ) f! S (18)

c Z , J - l - '2,J 2 -PZ,,j - LZ,3-1

V j > l and ( z , j ) $ S. (19) Constraints (14) and (18) lead to

G , 3 2 max{Cz,z, + ~ ~ , ~ , , ~ ~ , , l ( , ) , W , , , ( s ) ~ +PZJ

+ ( l a d + P2,3'), YJZ, < 3 5 m2

3 - 1

3 '=z2+l

'v'z such that z , L 1 (20)

3 - 1

'2)J 2 'C\S\(S),Wlsl(S) + 2 ) 2 , 3 + c('%,3' f PZ,3') 3'=1

V l 5 J 5 m,, Vz such that x, = 0 (21) m,

3'=3+1

Cz,m% 2 c Z , ~ + ( ~ , j ) - l + ~ z , j / ) , ~ ( 2 ~ 3 ) E J - s Vz such that x, < m,. (22)

Therefore, the optimal criterion value of the following

Problem P3: problem is a lower bound of Problem P2.

subject to (12), (13), (15)-(17), (20), and (21). One can notice that constraints (12), (13), (16), and (17)

are the same as (7)-(lo), except that N is replaced by ISI. If these constraints lead to a feasible solution then, according to Property 1, when we replace C+, and Cclsl(~),Wls,(s) in (20) and (21) by C?*,2. and C & ( s ) , W ! s , respectively, which are the completion times obtained using Procedure TIMING on the jobs of S , the objective function of the resulting problem gives a lower bound to Problem P3, and consequently to Problem P2. This problem, denoted by P4, can be formulated as follows.

Problem P4:

subject to (15) and

i - 1

Problem P4 is exactly the single machine scheduling prob- lem to minimize makespan with release dates and delivery times, where the release dates T , , ~ and delivery times qz,g are, respectively

.7-1

CHU AND F’ROTH: SINGLE MACHINE SCHEDULING 84 I

This problem has been extensively studied in the literature ([11-[31, [61, [91, [lll-[131, 1191, [201). Unfortunately, the problem is still NIP-hard. But if we further relax the nonpre- emption constraints, the problem can be polynomially solved by the following algorithm [l]. When we have to select a job among the available uncompleted ones, the one with the largest delivery time is chosen. Furthermore, an arriving job preempts the job being processed if the delivery time of the new arrival is strictly smaller than the one of the job in process.

Therefore the following result holds. Theorein 2: If there is a solution which verifies constraints

(12), (13), (16), and (17), the criterion value of Problem P4 without nonpreemption constraints is a lower bound of Problem P2.

In addition, we have the following theorem. Theorem 3: If there is no feasible solution to constraints

(12), (13), (16), and (17), any schedule c such that ( c k ( a ) , w k ( a ) ) = (c~(s),‘u~(s)) , \yll 5 I;.< (SI is not feasible.

Proof: Assume that there is such a feasible schedule 0.

In this case, the completion times of the jobs S in c satisfy constraints (12), (13), (16), and (17). This is in contradiction with the assumption that there is no feasible solution to constraints (12), (13), (16), and (17). Q E D .

Theorem 3 can be modified and made more effective by adding a constraint more than constraints (1 2), (13), (1 6), and (17). We know from (14) and (19) that for a partial schedule s in which S is the set of scheduled jobs

C c l s l ( s ) , w l s l ( . s ) 5 Ci,j + Li,j V ( i , j ) E S such that ( i , j + 1) $ S. (30)

This rneans that in the directed graph defined in Section 111 there is an arc which is -Li,j in length from vertex /SI to vertex 7r i j j ( s ) . If this graph contains circuits which are positive in length, there is no feasible complete sequence starting with the partial sequence s, thus the node represented by the partial sequence s can be eliminated.

We now develop a branch and bound algorithm using Theorems 3 and 3. In this algorithm, each node is defined by a partial sequence s . At the root node, s is empty. Each descendant node is obtained by adding, behind the partial sequence: s , a new job ( , i , j ) chosen among the unscheduled jobs, such that either j = 1 or job ( i , , j - 1) is scheduled in s. Procedure TIMING is then used to compute the completion times of the jobs in s completed by job ( z , j ) . If this new partial sequence is unfeasible, all the descendant nodes of s are eliminated according to Theorem 3. Otherwise, a new node is created with a lower bound computed using Theorem,2 if the lower bound is strictly less than the upper bound, and we continue by considering other descendant nodes with other unscheduled jobs.

The heuristics presented in Section I11 are used to provide an initial upper bound. The upper bound is updated each time a better complete schedule is found. The selection of the node to branch next is performed with the depth first policy, because

with this policy, the application of Theorem 3 can be easily implemented and requires a reasonable storage core.

VI. COMPUTATIONAL RESULTS

In order to evaluate the performance of the algorithms, we randomly generated test problems using uniform probability distribution. For each example, n = 10. The mi values were randomly sampled from { 1, 2,3}. The values were randomly generated in [lo, 401. The mean separation times, denoted by Mi,j , were randomly generated in [loo, 4001. The minimal and maximal separation times were defined as Li,j = (1 + to l )Mi , . , and l , , j = (1 - t o l ) M i , j , where to1 is a parameter which indicates the tolerance on separation times. The larger tol, the less tight the separation time window. The values of to1 were chosen in the set {0.1, 0.2,. . . ,0.9} to evaluate the influence of the tightness of separation time window on the solution to the problem. For each value of t o l , 50 examples were generated, which implies that a total of 450 examples were considered. The alternative algorithms were then tested on these examples.

The algorithms are implemented in C codes on a Sun SPARC 10 workstation. We know that the optimality of the solution obtained is guaranteed only if the branch and bound algorithm stops when the list of nodes waiting for branching is empty. In our experiments, the branch and bound algorithm is artificially stopped after 10000 branchings even if the list of nodes still contains some elements. We assume in this case that the “optimal” criterion value is the minimum of the lower bounds of the nodes in the list, which is less than or equal to the actual optimal value. In the remainder of this paper, we refer to actual optimal solutions as solutions which guarantee optimality, and as “optimal” (with double quote) criterion value the minimum of the lower bounds in the list. The computational results of the algorithms on test examples are summarized in Table I.

In Table I, we can see that: 1) the lower bounds computed at the root nodes are close to the optimal makespan and 2) when the separation time windows are medium tight (i.e., when to1 = 0.4), the computation burden increases in heuristics as well as in the branch-and-bound algorithm.

Remark 2) is not surprising. When the separation time win- dows are tight, the number of feasible solutions is limited. The probability for the heuristics to make inappropriate decisions is low. The branch and bound algorithm can also find quite early that a partial solution cannot lead to a feasible complete solution. When the separation time window is very large, the number of feasible solutions is large. Furthermore, a large number of solutions gives nearly the same criterion value. Therefore, it is relatively easy for the heuristics to find a near optimal solution. For the same reason, the branch and bound algorithm can easily find an optimal solution. Therefore, for extreme values of tol, the algorithms are more effective than for medium values. When to1 = 0.9, for instance, the problems are so easy that the heuristics always give optimal solutions and the optimality is proved at the root node of the search tree: the lower bound at this node is equal to the upper bound. Therefore, no further branching is needed. This explains the

842 IEEE TRANSACTIONS ON ROBOTICS AND AUTOMATION, VOL 12, NO 6, DECEMBER 1996

TABLE I COMPUTATIONAL RESULTS

to( OF HO DSH MDH DSL MDL TH TBAB NEX NBR

0.1 41 23 I.X6 1.92 0.43 0.50 0.64 198.00 124.24 653.37

0.2 37 17 4.26 4.41 0.43 0.49 0.64 115.3X 104.59 451.14

0.3 38 7 6.26 6.44 0.61 0.66 0.64 206.50 187.82 884.37

0.4 39 7 X.95 9.1 I 0.37 0.38 0.96 374.62 330.97 1738.59

0.5 43 9 X.63 9.05 0.09 0.09 1.60 213.86 205.56 978.72

0.6 47 17 5.45 6.01 0.04 0.05 1.28 129.34 143.18 605.36

0.7 49 33 1.93 2.27 0.00 0.00 1.92 42.12 65.80 231.12

0.8 50 46 0.56 0.61 0.00 0.00 2.88 8.12 7.92 9.04

0.9 50 SO 0.00 0.00 0.00 0.00 2.24 3.20 0.00 0.00 - OF: HU: DSII.

MDH: DSL: MDL. ‘ 1 1 I: ?’BAD:

NEX.

NBR:

fact that all the values of DSH, MDH, DSL, MDL, NEX, and NBR are zero in Table I. What is surprising, however, is the fact that the looser the separation time windows, the longer the computation time of heuristics.

The heuristics are applied to real-life problems of the medical laboratory for which we worked. The size of the problems to be solved is very large. The number of chains is between 100 and 400 and each chain contains three or four jobs. Since this medical laboratory manufactures automated medical analysis systems, and the number of analyses to be done every day in the world increases drastically due to the fast expansion of AIDS, C-hepatitis, and other pandemics, the alternative heuristic algorithms provided in this paper are very important. They,have been implemented in the automated systems. The service ratio, i.e., the ratio of the total processing time of the robot to the makespan, has been improved from 55570% to 75-95%, depending on the set of analyses to be performed. The comparison is made with the previous system which used scheduling rules. The mean computation time is 18.08 s. This computation time may appear to be surprisingly low considering the complexity in the worst case given in Section IV. Apart from the reasons we gave in Section IV, this is because many chains are identical (many chains consist of checking the AIDS virus, but belong to different patients, for instance). There are at most 18 types of chains, i.e., at most 18 types of analyses can be performed simultaneously. This significantly reduces the computation time for two reasons.

1) Instead of constructing as many partial schedules s z ( i ) as unscheduled chains at each iteration, the number of these schedules never exceeds 18.

2) When constructing a partial schedule s, (i), the number of ranks to be considered for scheduling (i, j ) can be reduced, since if a chain k identical to i has been scheduled in previous

TABLE I1 AN EXAMPLE

iterations, it is not necessary to consider ranks earlier than the one taken by ( k , , j ) .

However, it is difficult to evaluate the performance of the heuristics for large size problems in terms of quality of the solutions. Of course, it is always possible to compare the heuristic solution with the lower bound. The lower bound could be quite far away from the optimum (for 18 out of the 23 real-life examples we have, the lower bounds are simply the total processing time of jobs). This comparison shows that the mean deviation from the lower bound is 29.24%, and the deviation of the sum of makespans from the sum of the lower bounds is 30.63%. We could imagine computing the lower bounds using Lagrangian relaxation technique (see [4] and [ 181). In fact, for our examples, the lower bounds are poor due to the relaxation of capacity constraints when using Lagrangian relaxation. Furthermore, computation time would be long and storage core large, since the computation time and the storage core increase with the time horizon, which should be larger than the makespan and thus the total processing time. For the real-life problem we studied, total processing time could be 40 000 s. It is also impossible to change time unit, because the processing time of each job is between 19 and 53 s. Indeed, we can use techniques proposed by Owens and Luh [21] to handle this difficulty, but this will make the lower bounds even poorer.

VII. CONCLUSION

In this paper, we studied a real-life sequencing problem with chain structured constraints and windows on separation times between successive jobs in a same chain. Heuristic and branch and bound algorithms have been developed to deal with large and small size problems.

Since the mean value of the deviation between the lower bounds of the optimal criterion value and the criterion values provided by the heuristics is less than 1070, we can claim that, on the average and for large size problems, the solution provided by the heuristics is acceptable for solving real-life problems.

The application domains of this approach are medical lab- oratories and chemical plants. Further studies will try to extend the previous approach to the case when assembly operations are involved, in which case the graph representing the precedence constraints becomes an in-tree in which each node could have more than one immediate predecessor. Note that chain structured precedence constraints constitute a special case of in-trees. Another possible extension is to take into account nonnegligible void moves in transportation systems.

CHU AND PROTH: SINGLE MACHINE SCHEDULING

.

843

1.3 2.3

jgJ-j * o S io IS 20 25 30 3s 40 45 so ss time

Fig. 2. Schedule 5 1 at the end of iteration 1.

Fig. 3. Schedule (TI at iteration 2 when scheduling chain 2.

Fig. 4. Schedule U 2 at iteration 2 when scheduling chain 2.

n 1.3 * 0 s IO 15 20 25 30 3s 40 45 so 55 time

Fig. 5. Schedule IT^ at iteration 2 with (2, 2) rescheduled.

APPENDIX

The heuristics are illustrated by the following example: n = 4, the processing times, and minimal and maximal separation times are given in Table 11.

Without loss of generality, we only illustrate the first policy. The jobs are already numbered in the order defined by this policy.

At the first iteration, any chain can start at time 0. According to the policy, the partial schedule with chain 1 is chosen. Thereforls, at the end of the first iteration (or at the beginning of the second iteration), the partial schedule SI is shown in Fig. 2.

At the second iteration, there are three unscheduled chains: 2, 3, and 4. Thus, we have to compute three schedules s2 by merging successively chains 2, 3, and 4 with chain 1 in order to identify the chain whose first job starts the earliest. In the first trial, we consider chain 2. At first 2 1 = 2, 7 ’ 2 , ~ = 0, and d2,1 = -100. The rank y1 obtained is 2. A feasible solution exists when inserting job (2, 1) at rank 2. Schedule 01 is shown in Fig. 3.

At the next step, job (2, 2) is considered. 2 2 is set to 3. It is found that y1 = 4 and that there is a feasible solution by inserting job (2, 2 ) at the fourth rank (see Fig. 4).

When scheduling job (2, 3), L C ~ is set to 5. We can compute 7’2,3 = 23, d2,3 = 25. We found that y3 = 6, but pb: = 26 > 25 = $ 2 ~ . Therefore, job (2, 2) should be rescheduled. When rescheduling job (2, 2), its earliest starting time is set to C 2 , 2 ( 0 2 ) - p2,2 + pb: - d2,3 = 16, and 2 2 is set to 4. A feasible solution is found with y2 = 4 (see Fig. 5).

Schedule s2, when scheduling chain 2 after chain 1, is shown in Fig. 6. In s2, there is no idle time before job (2, I) , thus it is not possible for chain 3 or chain 4 to start earlier in

I . l l 2.1 11. I 3.2 I 1 3.3 I * 0 S 10 15 20 2s 30 3s 40 45 50 5s time

Fig. 7. Schedule .s:3(3) at iteration 3 when chain 3 is tested.

1.11 2.1 14.1 b.211 4.2 1k.d I I.? 12.31 * 0 5 IO 15 20 25 30 35 40 45 SO 55 time

Fig. 8. Schedule .‘:3(4) at iteration 3 when chain 4 is tested.

3.1 11.11 2.1 13.2 ! l . d 3 . 3 1 1 2 ~ 4 I 1.2 12.314.1 I * 0 5 I O IS 20 25 30 35 40 4.5 SO 55 time

Fig. IO. Complete schedule obtained with the third heuristic.

3, l I 2.1 11.113.2 p.4l.21 3.3 ] 2 . 3 ( 4 . 1 I 1.3 14.2 I * 0 s I O 15 20 2s 30 35 40 4s so 55 time

Fig. 11. An optimal schedule.

s2 than the starting time of (2, 1) in s 2 . Therefore, s2, obtained when scheduling chain 2, is taken as a partial schedule for the next iteration.

At the third iteration, the two unscheduled chains are 3 and 4. Using the same procedure as explained before, partial schedule s j obtained by merging chain 3 and s2 is shown in Fig. 7.

It can be seen that job (4, 1) starts earlier in s3 than job (3, 1). Therefore, s~(4) is selected at the fourth iteration, i.e., S Q = s3(4) (see Fig. 8).

Finally, the complete schedule obtained using the first heuristic is shown in Fig. 9. The corresponding makespan is 55. The same schedule is found using heuristic 2, since the job numbering is the same with the two policies. In the same way as explained before, we can obtain a complete schedule with the third heuristic. It gives a makespan of SO (see Fig. 10).

Fig. 11 gives one of the optimal solutions with a makespan of 44.

REFERENCES K. R. Baker and Z. Su, “Sequencing with due-dates and early start times to minimize maximum tardiness,” Nav. Res. Logisr. Quart., vol. 21, pp. 171-176, 1974. P. Bratley, M. Florian, and P. Robillard, “On scheduling with earliest start and due dates with application to computing bounds for the (71/1n/G‘/F max) problem,” Nav. Res. Logist. Quart., vol. 20, pp. 57-67, 1973. J. Carlier, “The one machine sequencing problem,” EuI.. J . Op. Res., vol. 11 , pp. 4 2 4 7 , 1982. H. X. Chen, C. Chu, and J. M. Proth, “Job shop scheduling using Lagrangian relaxation,” INRIA, France, Res. Rep. 2505; IEEE Trans. Robot. Automat., 1995. -, “Cyclic scheduling of a hoist with time window constraints,” IEEE Trans. Rabat. Automat., to be published. M. I. Dessouky and C. R. Margenthaler, “The one-machine sequencing problem with early starts and due dates,” AIIE Trans., vol. 4, pp. 214-222, 1972.

844 IEEE TRANSACTIONS ON ROBOTICS AND AUTOMATION, VOL. 12, NO. 6, DECEMBER 1996

[7] D. Goldfarb, J. Hao, and S.-R. Kai, “Efficient shortest path simplex algorithms,” Op. Res., vol. 38, pp. 624-628, 1990.

[8] M. Gondran and M. Minoux, Graphes et Algorithmes. Paris: Editions Eyrolles, 1985.

[9] J. Graboski, E. Nowicki, and S. Zdrzalka, “A block approach for single- machine scheduling with release dates and due dates,” Eur. J . Op. Res., vol. 26, pp. 278-285, 1986.

[lo] S. K. Gupta and J. Kyparisis, “Single machine scheduling research,” OMEGA Znt. J. Mgmt. Sei., vol. 15, pp. 207-227, 1987.

1111 N. G. Hall and W. T. Rhee, “Average and worst-case analysis of heuristics for the maximum tardiness problem,” Eur. J. Op. Res., vol. 26, pp. 272-277, 1986.

[12] B. J. Lageweg, J. K. Lenstra, and A. H. G. R. Kan, “Minimizing maximum lateness on one machine: Computational experience and some applications,” Statist. Neer., vol. 30, pp. 2 5 4 1 , 1976.

[13] R. E. Larson, M. I. Dessouky, and R. E. Devor, “A forward-backward procedure for the single machine problem to minimize maximum lateness,” ZIE Trans., vol. 17, pp. 252-260, 1985.

[14] E. L. Lawler, J. K. Lenstra, A. H. G. R. Kan, and S. D. B. Shmoy, “Sequencing and scheduling: Algorithms and complexity,” Ctr. Math. Comput. Sci., Amsterdam, Rep. BS-R8909, 1989.

[15] L. Lei and T. J. Wang, “On the optimal cyclic scheduling of single hoist electroplating processes,” Rutgers Univ., NJ, Working Paper 89-0006, 1989.

[ 161 ~, “A proof The cyclic hoist scheduling problem is NP-complete,” Rutgers Univ., NJ, Working Paper 89-0016, 1989.

[ 171 ~, “On the optimal cyclic scheduling of single hoist electroplating processes,” Mgmt. Sci., vol. 37, pp. 1629-1639, 1991.

[18] P. B. Luh and D. J. Hoitomt, “Scheduling of manufacturing systems using the Lagrangian relaxation technique,” IEEE Trans. Automat. Contr., vol. 38, pp. 1066-1079, 1993.

[19] G. McMahon and M. Florian, “On scheduling with ready times and due dates to minimize maximum lateness,” Op. Res., vol. 23, pp. 475482, 1975.

[20] E. Nowicki and S. Zdrzalka, “A note on minimizing maximum lateness in a one-machine sequencing problem with release dates,” Eur. J. Op. Res., vol. 23, pp. 266-267, 1986.

1211 T. A. Owens and P. B. Luh, “Improving the time resolution of schedules generated via Lagrangian relaxation algorithms,” in Proc. IEEE Int. Con5 Syst., Man, Cybern., Chicago, IL, Oct. 1992, pp. 1390-1394.

[22] L. W. Phillips and P. S. Unger, “Mathematical programming solution of a hoist scheduling program,” AZZE Trans., vol. 13, pp. 304-310, 1976.

[23] B. Roy, Alg2bre Moderne et Thtorie des Graphes. Paris: Dunod, 1970. [24] G. W. Shapiro and H. W. Nuttle, “Hoist scheduling for a PCB electro-

plating facility,” ZIE Trans., vol. 20, pp. 157-167, 1988.

Chengbin Chu was bom in 1965 in the People’s Republic of China. He received the B.Sc. degree from Hefei Polytechnique University (China) in eletrical engineering in 1985 and the Ph.D. degree from Metz University (France) in computer science in 1990.

He is currently a Senior Research Officer at INRIA (National Research Institute in Computer Science and Automation), France. He is interested in research areas related to operations research and modeling, and analysis and optimization of discrete

event systems. He has published one book and 14 papers in joumals, including the IEEE TRANSACTIONS ON ROBOTICS AND AUTOMATION, the European Journal of Operational Research, and Naval Research Logistics.

Jean-Marie Proth (M’89) received the Ph.D. de- gree in computer sciences from the University of Nancy (France) and the Doctorat d’Etat in manage- ment science from the University of Pans-Dauphine (France).

He was a Professor in several French universities from 1969 to 1979. Between 1979 and 1982, he served as a Professor at the European Institute for Advanced Studies in Management in Brussels (Belgium), and then joined INRIA (Institut National de Recherche en Informatiaue et en Automatiaue)

in France. Since 1986, he has been a Research Director at INRIA and Heai of the SAGEP Team located in Metz (France). He is also an Associate Member of the Institute for Systems Research of the University of Maryland (USA). His research interests include the preliminary design of manufacturing systems, the design and use of hierarchical production management systems, and the modeling and evaluation of flexible manufacturing systems. He is also a Consultant in the fields of manufacturing system design and management. He is the author and co-author of several books, an Associate Editor of the Journal of Applied Stochastic Models and Data Analysis, a member of the editorial board of the Journal of Intelligent Manufacturing, and an Associate Editor of the IEEE TRANSACTIONS ON ROBOTICS AND AUTOMATION.