On scheduling with ready-times, due-dates and vacations

On Scheduling with Ready-Times, Due-Dates and Vacations

V. Jorge Leon and S . David Wu Harold S . Mohler Lab 200, Department of Industrial Engineering, Lehigh

University, Bethelehem, Pennsylvania 18015

A single machine sequencing problem is considered in which there are ready-time and due-date constraints on jobs and vacation constraints on the machine. Each vacation has fixed starting and finish time and no preemption is allowed for the jobs. The objective is to minimize maximum lateness. An intriguing feature of this formulation is that it allows sequencing in disconnected time windows. A relaxation of the problem is obtained by modeling the vacations as a set of jobs with flexible ready-times and artificial due-dates and a branch and bound algorithm is developed for the problem. In the algorithm, the search is not only guided by the bounds but also by a careful manipulation of the artificial due-dates. Consequently, while searching in the relaxed solution space, solutions of the original problem are implicitly enumerated. Computational results indicate that the algorithm can satis- factorily solve problems with multiple vacations.

1. INTRODUCTION

Sequencing problems typically assume a noninterrupted planning period such that available jobs can be processed anywhere along the planning horizon. This assumption, however, is rarely true in reality. Disruptive events such as machine maintenance, shift changes, and meal breaks are often planned in specific time windows which render the operations schedule suboptimal. This is an issue of great practical importance that has been largely ignored in the past. In this article we address the issue by modeling the disruptive events as machine “vacations.” Specifically, we examine the problem of sequencing a set of jobs on a single machine in order to minimize maximum lateness, subject to ready times, due dates, and a set of vacations. The vacations are defined as a set of predetermined periods in the future when the machine will be interrupted. Each vacation starts and ends at known time points and no preemption is allowed for the jobs. An intriguing feature of this formulation is that it allows sequencing in disconnected time windows.

A broader set of applications will result if this single-machine model is included in the solution methods for the job-shop scheduling problems. Adams, Balas, and Zawack [l] and Carlier and Pinson [7] have suggested such procedures for job-shop problems without vacations.

Naval Research Logistics, Vol. 39, pp. 53-65 (1992) Copyright 0 1992 by John Wiley & Sons, Inc. CCC 0894-069X/92/010053-13$04.~

54 Naval Research Logistics, Vol. 39 (1992)

Baker and Nuttle [3] and Gelders and Kleindorfer [lo, 111 have studied a similar problem in which variable resources availability is considered. Baker and Nuttle [3] showed that many sequencing models for the single machine apply, with minor modifications, to the variable resource problem. For the problems with ready times and due dates, they showed that by allowing preempt-resume of jobs, the maximum lateness can be minimized using the EDD rule.

In this article an alternative formulation is used to solve this scheduling problem with vacations. The formulation is closely related to the one-machine sequencing problems which minimize maximum lateness with the consideration of ready times and due dates. This one-machine problem has been extensively studied and branch-and-bound algorithms exist that solve the problem optimally [6, 131. Work by Jackson [12], Schrage [15], Florian, Trepant, and McMahon [8], Baker and Su [4] are of significance in the development of efficient bounds for the solution of this problem. The one-machine problem is known to be NP- hard [9]. The problem dealt with in this article is at least as complex since the problem without vacations is a proper subset.

2. PROBLEM STATEMENT

The single-machine sequencing problem with vacation constraints to minimize maximum lateness may be stated as follows. Each job in a set N (N = (1, . . . , n}) is to be processed without interruption on a single machine. A job may not be available at the beginning, and each job i E N has a ready time ai , a processing time d;, and a due date b;. There is a set of vacations V associated with the machine. Each vacation i C V has a fixed starting time T; and duration 6;. No job can be processed during the period of a vacation. At any instant the machine can process only one job.

Bratley, Florian, and Robillard [5 ] showed that the single-machine problem with ready times and due dates to minimize maximum lateness is equivalent to the problem with ready times a; and tails qi to minimize makespan [i.e., maxi(tj + di + q;), where ti is the starting time of job i in the sequence]. The equivalence is achieved with a simple transformation: qi = L - b;, where L is a large number (e.g., the makespan for the corresponding job-shop problem). The ready time a; and the tail qi can be easily interpreted in the context of a job shop: a; is the earliest time when job i finishes processing all of its preceding operations, and qi is the time job i needs to finish all succeeding operations. The rest of this article refers to the problem with ready times a, and tails qi.

2.1. Problem Formulation The single-machine problem (Pl) under consideration is formulated as follows:

Pl : min maxjEN(tj + d; + 4,) s.t.

(i) ti - t, 2 d, v t, - ti 2 d,, (ii) t, + d, 5 z1 v t, 2 T~ + dl, (iii) t, L a;, i E N, (iv) t, L 0, i E N .

i, j E N , i # j , i E N , 1 E V ,

Leon and Wu: Scheduling With Ready Times 55

Any feasible solution for P, is called a schedule. Constraints (i) allow the processing of only one job at a time on the machine; constraints (ii) exclude the processing of jobs during vacation periods. (iii) and (iv) are ready-time and nonnegativity constraints, respectively. If constraints (ii) are dropped from the formulation, we are left with the one-machine scheduling problem with ready times and tails [6].

3. SOLUTION METHOD

Problem PI divides the planning horizon into IVI + 1 disconnected time windows. To solve the problem in its original form involves assigning jobs into windows, sequencing jobs in each window, and swapping jobs among windows until the overall sequence is optimal. These tasks require the development of interconnected solution algorithms each demanding a significant computational effort. We propose a solution method to solve a transformed problem which can be briefly described as follows: Suppose one treats the vacations as special jobs which must start immediately when they become available (i.e., t, = a,, Vi E V ) , then an equivalent problem, P i , can be formulated as follows:

Pi : min max(t, + d, + q,), E N u V

s.t.

(i) t , - t , ~ d , v t , - t , ’ d , , i , j E N U V , i # j , (ii) t , = a,, i E V

(iii) t , 2 a,, i E N U V , (iv) t, 2 0, i E N U V ,

where, Vi E V ,

a, = T I ,

and

q, = 0.

Note that constraint (ii) imposes an additional condition for the “artificial” jobs (i.e., the vacations).

Denote Pi without constraint (ii) as the transformed relaxed problem (TRP). Clearly an optimal solution to TRP is a lower bound for P i . If the solution is feasible for P i , it is also optimal for Pi (therefore P I ) . As discussed earlier, efficient branch-and-bound procedures are available to solve TRP. The method proposed in this paper is an implicit enumeration procedure which enables a branch-and-bound algorithm to examine those solutions for TRP that are feasible for P : . This is accomplished by defining the lower and upper bounds based on P i , and assigning an “artificial tail” for each “job” in the set V , such that the algorithm is guided to examine the feasible schedules for Pi in the solution space of TRP.


3.1. The Artificial Tails

Artificial tails can be defined for jobs in V such that those solutions for TRP that are feasible for Pi may be enumerated implicitly. Let M be a sufficiently large constant, the artificial tails, 41, can be defined as follows.

vi E v, q [ = M - (ai + di), q[ 2 0. (1)

Denote TRP with the above artificial tails as TRP(M). The following prop- ositions establish the relation between Pi and TRP(M).

PROPOSITION 1: If L* is the optimal makespan for P i , then L* is also optimal for TRP(L*).

PROOF: The optimal solution to Pi will correspond to a feasible solution for TRP(L*) which will have a makespan of L*. Moreover, any solution to TRP(L*) cannot have the jobs in V finishing before ai + di + q[ = L*. Hence the optimal solution to TRP(L*) has a makespan of exactly L*. 0

Clearly L* is not available while solving TRP(M). The lower bound (LB) and the upper bound (UB) of L*, however, are not difficult to compute. When M is set equal to the lower bound (i.e., M = LB < L*) , a vacation in V may be allowed to start after its ready time and the optimal solution for TRP may not be feasible for P i . The following proposition examines the condition when M is set equal to the upper bound of L*.

PROPOSITION 2: The optimal solution of TRP(UB) corresponds to a feasible solution of P ; .

PROOF: The optimal solution to the problem P ; corresponds to a feasible solution for TRP(M) with a makespan value of max(M, L*). Since M = UB, the optimal solution for TRP(M) will have a makespan value of UB. This solution is feasible for P ; because UB = M = ai + di + qf = ti + di + qf , or ti = ai, for all vacations i in V. 0

Clearly the optimal solution of TRP(UB) may not be optimal for P ; unless UB = L*.

3.2. The One-Machine Problem without Vacations As discussed earlier , McMahon-Florian’s branch-and-bound algorithm [ 131

solves the relaxed problem TRP(M) optimally. Their algorithm is based on the Schrage schedule, a critical job c and a critical block B,.

The Schrage algorithm [14] can be described briefly as follows: At the time the machine becomes available for processing, say time t, schedule among the ready jobs i (i.e., ai I t) the job j with the largest tail, qi. Typically a Schrage schedule consists of “blocks” of jobs. In each block the first job starts at its ready time (i.e., ti = ai) and there is no idle time between the remaining jobs


in the block. Denote Bi as the set of jobs that precede i in its block including i. A critical job c is the job which realizes the makespan, i.e., tc + dc + qc = L. The set B, is said to be a critical block. Clearly any suboptimal sequence may be improved only by scheduling the critical job earlier. If t, = a,, then the sequence is optimal. This property can be stated formally as follows:

PROPERTY 1: Given a suboptimal Schrage schedule, its critical block B,, and a candidate set I = {ili E B,\{c}, qi < q,}, the makespan may be reduced only by scheduling jobs in I after c.

This property was proved and used by both McMahon and Florian [13] and Carlier [6]. In both of these papers a complete Schrage sequence is associated with each node in the branch-and-bound tree and the above property is used for branching. In [13] the successors of a node are generated by scheduling each job in I after c. In [6], only the latest job in I, say job m, is considered for branching; i.e., m E I and t,,, = max,,,{t,}. Two successors are generated based on jobs c and rn: one in which job m starts at or before time t,,, (i.e., before c), and the other in which job rn starts after c. The first successor is generated by first resetting the tail of m as follows, then reapplying Schrage algorithm.

where J is the set of jobs between m and c , including c .

as follows. Similarly, the second successor is generated by resetting the ready-time of rn

a, = max a,, min a, + 2 d, { El iE J

3.3. Solving Problem Pi We propose a branch-and-bound procedure which solves problem Pi by ex-

ploring the relaxed solution space defined by TRP(UB). In the search tree, a Schrage sequence feasible for TRP(UB) is associated with each node. This sequence is only feasible for Pi when all the vacation jobs are at their right places, i.e., Vi E V, ti = a;. The branch-and-bound procedure starts with a Schrage schedule feasible for P ; , then the algorithm proceeds by seeking an improvement of the Schrage schedule using Property 1. During the search, the algorithm examines the solutions for TRP(UB), which may or may not be feasible for P ; . Since each vacation job is associated with an artificial tail defined by the upper bound of the makespan, any solution infeasible for Pi (i.e., f , > a; for any i E V) will have a makespan value greater than the upper bound. Eventually, the successors of these solutions will either become feasible or be pruned from the tree. This is done through a careful manipulation of the artificial tails and the branching scheme. The procedure will terminate with a solution optimal for Pi.


The bounding procedure involves computing a lower and an upper bounds for each node. The lower bound is computed based on a preempt-resume relaxation, and the upper bound is obtained by the best feasible schedule of Pi known so far. The bound computation is further detailed in Section 3.4.

Our basic brancing scheme is similar to that of McMahon and Florian [13], and is outlined as follows: For each node in the search tree,

1. Use the associated Schrage schedule, identify the critical job c, the critical block B,, and the candidate set 1.

2. Generate 111 successors as follows: for each job k E I , create a successor node that corresponds to a new problem, in which the ready time of job k , ak, is reset to a,. Recompute a Schrage schedule for the new problem, in which case k will be scheduled after c (since q k < qc, Vk E I ) .

For the problem without vacations, the above branching scheme investigates all the possible improvements of the Schrage schedule using Property 1. How- ever, if the same branching scheme is used here, the procedure will terminate when a solution optimal for TRP(UB) is found. This will be the case when a vacation job is the critical job and all the vacation jobs are at their right places. As noted earlier, this solution is feasible but not necessarily optimal for Pi. In order to enumerate all the possible sequences that may improve the makespan of Pi, special treatments are given to the deterination of the critical job c. Three cases are considered in the following procedure:

Procedure FIND-C Given a Schrage schedule, determine the critical job as follows: Case 1. If c is a job in N , then return c; Case 2. If c is a vacation job and t, > a,, then return c; Case 3. If c is a vacation job and all the vacation jobs are on their right places, then

return a new critical job determined after setting all the artificial tails to 0.

Cases 1 and 2 are straightforward applications of Property 1 and all possible schedules that may reduce the makespan are enumerated by scheduling each job i in the candidate set I after c. Moreover, in Case 2, the vacation job is scheduled closer to its right place when a job in the candidate set is placed after the vacation job. In fact, this is how the procedure forces vacation jobs to start on their ready times. Case 3 eliminates the problem caused by the artificial tails by disregarding them when determining the critical job. Furthermore, Case 3 enables the algorithm to proceed, seeking improvement of the sequences among the nonvacation jobs.

Another important point concerning the branching tree is that the value of M directly affects the cardinality of the candidate set I, thus the size of the tree. This is true because when the critical job is a vacation, the candidate set Z can be expressed as I = {ili E B,\{c}, qi < M - (a, + d,)}. Since a, and d, are both constant, 111 will be reduced as M decreases. If we use an arbitrarily large number as M such that the artificial tail defined by M is longer than the tails of all the other jobs on the critical block B,, the set I would have to include all the jobs in B,\{c}. Clearly this results in a very large search tree.


3.4. The Branch-and-Bound Procedure

Lower and upper bounds are computed for each node in the search tree. Upper Bound. In the branch-and-bound procedure, the upper bound is first

initiated by the makespan of a schedule which is feasible for problem Pi. The bound is then updated by the best feasible solution known so far. The initial feasible schedule is generated by a modified Schrage's algorithm as follows.

Procedure FIND-FEASIBLE 1. At the time the machine becomes available for processing, select among the avail-

2. For the job i selected, do the following.

0, Vk E V ) , schedule job i .

the ready time of i to the end of vacation u (Le., set a, + T~ + &); go to 1.

able jobs in set N the job i with the largest tail q,

(a) If i does not interfere with any vacations (i.e., [f,, I, + d,] n [ T ~ , rk t d,] =

(b) Otherwise, if i interferes with a vacation v (i.e., I, + d, E [T~,, T~ + d,,]), reset

Lower Bound. The lower bound computed for each node is the makespan of a preemptive schedule with vacations. The preemptive schedule is a relaxation of problem P ; by disregarding constraint (i). Baker [2, p. 821 has generalized the optimality of the EDD rule for the case when jobs have different ready times and preempt-resume applies. The same generalizations can be done for problems with vacations, using the procedure outlined as follows:

Procedure P R EEMPTIVESCHED U L E 1. For each vacation u in V , compute its artificial tail by setting M to the current upper

bound, i.e., qL = UB - (a, + d J . 2. At time zero, or the time when a job has just completed processing, schedule among

the available jobs in N U V the job i with the largest tail, q,. If there is no job available, leave the machine idle until the first available job.

3. When a new job j just become available, compare the tail of job j with the job i under processing. If the tail of j is greater then the tail of i, preempt job i by j. Otherwise. add job j to the list of available jobs.

It is easy to see that this schedule is optimal when preempt-resume applies. The optimality can be established by making the observation that (1) if vacations are treated as jobs, the problem here is equivalent to the preempt-resume case suggested by Baker [2, p. 821, in which case the EDD rule is optimal, (2) the vacations will start right on their ready times and will never be preempted since they always have the longest tails among the available jobs. A similar preempt- resume bound for TRP was suggested by Baker and Su [4]. Carlier [6] showed that the preempt-resume bound is a strong lower bound for TRP and that the complexity of the preemptive algorithm is O(n log n). Clearly the complexity remains the same for problems with vacations.

Algorithm '$3 : The implicit enumeration procedure.

Step 0. Initialization. (i) Apply procedure FIND-FEASIBLE to get a feasible schedule for P ;

and compute its makespan Lo. Set UB +-Lo and M < UB. Apply procedure P R E E M P T N E S C H E D U L E to compute its lower bound, LB.

(ii) Associate the job set N with the root node.

60 Naval Research Logktics, Vol. 39 (1992)

(iii) If Lo = LB, stop; the initial schedule is optimal. Otherwise, put the root node on a list called OPEN.

Step 1. Remove from OPEN a node r at which LB, is minimum. (i) Compute an artificial tail, q,’, for each job j E V, such that 4,’ = M -

(a, + dj). Set q, - q,’, Vj E V . (ii) Generate a Schrage sequence for set N, U V, where N, is the set of jobs

associated with node r . Set q, + 0, for the vacations i E V, then compute its makespan L,. Note that N, is in general different from N, since the ready times may be modified in Step 3.

(iii) If the sequence is feasible for P i , update the upper bound: UB + min{UB, L,} and M + UB.

Step 2. Given the Schrage sequence (i) Apply procedure F1ND-C to identify the critical job c. Based on c, identify

(ii) If 11) = 0 go to Step 4.

(i) setat +a, + dc,qk +q, ,N, +{k} U N,\{j}. ApplyprocedurePREEMPTZVE

(ii) If LB, < UB, associate N, with a node index and put it into OPEN. (iii) Repeat Step 3 until Z is exhausted.

the candidate set I such that I = {ili E B,\{c}, q, < qc}.

Step 3. For each job j in the set I,

SCHEDULE on the set N, U V to compute the lower bound LB,.

Step 4. Check for optimality. (i) If OPEN is empty, stop; UB is the optimal makespan. (ii) If UB I min,,,,,{LB,}, stop; UB is the optimal makespan. (iii) Otherwise, go to Step 1.

As described in the algorithm (Step 0), the sequence found by procedure FZNDJEASZBLE defines the initial upper bound as well as the initial value of M. As discussed earlier in Section 3.3, the value of M will affect directly the cardinality of set I . As a result, the quality of the initial feasible solution is critical to the search efficiency. Procedure FZND-FEASIBLE appears to be very effective in computational testing where optimal solutions are often found (see Section 5 ) .

4. A NUMERICAL EXAMPLE

To illustrate the operation of Algorithm B1, consider the example problem in Table 1. For simplicity, only a single vacation u is considered. u starts from time 339 and lasts for 26 time units.

Initially, the algorithm applies procedure FZNDYEASZBLE to generate a feasible schedule, where Lo = M = UB = 896. Procedure PREEMPTZVE- SCHEDULE then computes the lower bound: LBO = 883. The initial feasible schedule and its associated preemptive schedule are shown in Figure 1. The job set N is now associated with the root node (i.e., node a) of the branch-and- bound tree and OPEN = {a}. The tree is shown in Figure 2.

The first execution of Step 1 yields q: = 531, OPEN = { }, and a Schrage sequence (3, 1, 2, 6, 0, 4, u, 5 ) . The sequence is associated with node a in the

Table 1. Job set for the example problem.

Job 1 0 1 2 3 4 5 6 U

Ready time a, 240 100 175 60 278 419 223 339 Duration d, 63 24 34 74 67 51 43 26 Tail q, 470 220 159 136 35 413 102 0


I I-

c = 5. I - (4) = 896, LB, - 883

C = 5. I - nil L, - 883. LB, - 883 opt rnal

Figure 1. Schedules for the example

tree. Since the sequence is not feasible (see Figure l), UB will not be updated. In Step 2, procedure FIND-C is used and the critical job c = u is identified, I = (4, 0, 5}. Step 3 is then repeated for each element of I. The first execution of Step 3 (for job 4) generates node b in the tree with u4 + 365 which yields

(3, 1, 2, 6. 0, 4, V, 5) C = V, I = {4, 0, 6)

LBf = 898 > UB = 896

(3, 1 I 2, 0, V, 4, 5, 6)

LBh= 883, L,,= 896, UB = 896

(3, 1, 2, 0, V, 5, 6, 4)

Figure 2. Branch-and-bound tree for the example.


LBb = 883. Since LBb < UB, node b is added into OPEN (i.e., OPEN = {b}). The next execution of Step 3 (for job 0) generates node c in the tree and LB, = 898. Since LB, > UB, node c is not added to OPEN. For job 5, node d is generated with LBd = 883; therefore, OPEN = {d, b}. Since none of the stop- ping condition in Step 4 is met, go to Step 1.

Step 1 removes node d for processing since LBd = min,,opEN{LBr}. The Schrage sequence for Nd U {u} is (3, 1, 2, 0, 4, u, 6, 5). Step 2 yields I = (4, 0}, and Step 3 yields LB, = 883, LBf = 898; therefore, OPEN = {e, b}.

In the following iteration node e is chosen for processing and a feasible schedule (3, 1, 2, 0, u, 6, 4, 5) with makespan L, = 939 results. Since L, > UB, the upper bound remains the same. In Step 2, job c = 5 and Z = (4, 6). Step 3 yields LB, = LBh = 883; therefore, OPEN = {h, g, b}.

Node h is chosen for processing next and a feasible schedule (3, 1 ,2 ,0 , u, 4, 5, 6) with Lh = 896 results. In this case, both u and job 5 are critical, i.e., t, + d, + q, = ts + d5 + qs = 896. However, since a, = t,, procedure FIND-C returns job 5 as the critical job and I = (4). Step 3 yields LBI = 883 and OPEN =

(1, g, b}. Node 1 is chosen for processing and a feasible schedule (3, 1, 2, 0, u, 5, 6, 4)

with LI = 883. Since Lj < UB, UB is updated to 883. In Step 2, job c = 5 and I = pl. In Step 4 the stop condition (ii) is satisfied. The algorithm terminates with an optimal makespan 883.

5. COMPUTATIONAL EXPERIMENTS

The algorithm was coded in C on a Sun 4/280 computer. Two sets of experiments were conducted: a first set of experiments on 95 problems was used to verify the optimality of the algorithm, and a second experiment set consisting of 1400 problems was used to evaluate the computational efficiency of the algorithm.

The first set of problems was obtained by solving (to optimality) a set of 50- job problems without vacations, then assigning noncritical jobs in the schedule as vacations. As a result, 95 scheduling problems with vacations are generated with known optimal makespans.

The set of problems without vacations are generated to resemble a job shop. The processing times di are generated based on normal distribution, N(50, lo2), and the interarrival times of jobs are generated exponentially with parameter 40. Since a tail qi is the time a job remains in the system subsequent to the machine in consideration, the following method is used:

r

qi = dj , where r - U(1, 50) and dj - N(50, lo2). j = l

Each problem generated is solved using Carlier’s algorithm [6]. Vacations of various patterns are then generated based on parameters a and p. a varies the mean interarrival times of vacations and p varies their durations. Specifically, jobs are assigned as vacations as follows.


Table 2. Results for 95 problems. Avg. no. Nodes explored Not solved in

a p Runs of vacations Min. Avg. Max. 600 nodes 10 1 19 4.1 1 205 555 0 10 3 19 3.5 1 132 285 0 10 5 19 2.9 1 95 268 0 15 1 19 2.6 1 232 467 0 5 1 19 6.7 1 229 566 1

1 . Generate the arrival times of vacations T, with exponential inter-arrival with parameter

2. For each job i in the schedule which satisfies the following condition: 50a.

replace jobs i to (i + p - 1) by a vacation of starting time I,

A set of 19 problems without vacations was generated and solved. We then assigned the vacations by setting five (a$) pairs: (5,1), (lO,l), (15,1), (10,3), and (10,5). The results are shown in Table 2. As shown in the table, 94 out of the 95 problems were solved optimally in less than 600 nodes. The limit on the maximum number of nodes was set at 2000 nodes. Only one problem reached this limit and the solution found was 3596 while the optimal is 3580.

The second problem set consisted of 1400 50-Job problems. The problems are randomly generated by setting the maximum ready time (amax), tail (qmax), and processing time (d,,,), and generating the values of a;, q;, and d, with uniform distribution between 1 and amax, qmm, d,,, , respectively. The vacation interarrival times and durations are generated exponentially with parameters 1, and ,I2.

Fifty replicates were generated for each combination of parameters, i.e., amax, qmax, d,,,, I , and 3L2. A total of 1400 problems were tested. To study the per- formance of the algorithm under different parameter settings, we collected data concerning the number of problems not solved in 1500 nodes, the running time in microseconds, and the number of nodes explored (i.e., a node is considered “explored” when its lower bound is determined). In addition, we recorded the number of times in which the solution obtained by the FIND-FEASIBLE procedure was optimal. The results are given in Table 3.

Among the 1400 problems tested, 89 problems were not solved in 1500 nodes. The remaining problems were solved in 107 nodes on average (1 node minimum and 1217 nodes maximum).

As shown in the table, the algorithm does not perform well for values of amax < 2500. For these problems, all the jobs are ready very early in the schedule which results in a large single block of jobs rather than several blocks of jobs. In other words, at each node the candidate set I becomes quite large. Consequently, for instance, if amax < 2000 this method does not work practically.

Moreover, procedure FIND-FEASIBLE found the optimal solution in 461 out of 1400 problems. A result which suggests that the procedure may serve as an effective heuristic for the problem.


Table 3. Results for 1400 problems. (dmU = 100.) Not solved in

1500 nodes Avg. no. out of 50 Avg. running Avg. no. Find-Feasible

amnx qmai 1, of vacations problems time in psec of nodes solution optimal 5000 5000 5 m 400 2.0 5000 5000 5oooO 100 2.6 5000 5000 25000 400 2.9 5000 5000 25000 100 4.5 4OOO 4000 5 m 400 2.0 4000 4OOO 5oooO 100 2.6 4OOO 4OOO 25000 400 3.3 4000 4OOO 25000 100 4.1 3000 3000 5oooO 400 1.9 3000 3000 5oooO 100 2.3 3000 3000 25000 400 3.1 3000 3000 25000 100 3.9 2500 2500 5oooO 400 2.0 2500 2500 5oooO 100 2.4 2500 2500 25000 400 2.8 2500 2500 25000 100 3.5 4000 5000 5 m 400 2.0 4OOO 5000 5oooO 100 2.7 4OOO 5000 25000 400 3.1 4000 5000 25000 100 4.4 3000 5000 5 m 400 2.0 3000 5000 5oooO 100 2.4 3000 5000 25000 400 3.1 3000 5000 25000 100 3.9 2500 5000 5oooO 400 2.1 2500 5000 5oooO 100 2.3 2500 5000 25000 400 3.1 2500 5000 25000 100 4.1

0 0 0 0 0 0 0 0 7 4 5 3 5 5

13 10 0 0 1 0 5 1 3 3 8 5 3 8

278989 57998

309321 171660 787635 178660

1121622 248323

1376302 832938

17 18080 1215200 1704376 1633638 1126081 1668115 702305 197659

1349266 443982

1139214 626506

1887868 1200306 1638426 1521791 1328316 1858259

34 8

36 20 91 24

129 32

149 97

160 144 173 186 114 185 87 26

146 53

121 79

184 144 165 178 125 188

24 27 29 23 14 19 11 11 11 6

22 6

19 10 30 4

12 27 9

21 19 9

16 6

22 10 27 17

6. CONCLUDING REMARKS

This article presents a single-machine scheduling procedure with ready time, tail, and vacation constraints to minimize makespan. As demonstrated by the test problems, the procedure provides a satisfactory method for solving problems with up to 50 jobs and multiple vacations. Further attempts to improve the efficiency of the algorithm might involve experimenting with different branching strategies. Additional improvement to the branching method may be worthwhile for problems with relatively long blocks.

ACKNOWLEDGMENT

The research is part of a project supported by National Science Foundation under Grant No DDM-9010033. The authors would like to thank the two anon- ymous referees for their comments and suggestions on an earlier version of this article.

REFERENCES

[1] Adams, J., Balas, E., and Zawack, D., “The Shifting Bottleneck Procedure for Job Shop Scheduling,” Management Science, 34(3), 391-401 (1988).


[2] Baker, K.R., Introduction to Sequencing and Scheduling, Wiley, New York, 1974. [3] Baker, K.R., and Nuttle, H.L.W., “Sequencing Independent Jobs with a Single

Resource,” Naval Research Logistics Quarterly, 27, 499-510 (1980). [4] Baker, K.R., and Su, Z.S., “Sequencing with Due-Dates and Early Start Times to

Minimize Maximum Tardiness,” Naval Research Logistics Quarterly, 21, 171-176 (1974).

[5] Bratley, P., Florian, M., and Robillard, P., “On Sequencing with Earliest Starts and Due Dates with Application to Computing Bounds for the (nimlGIFmax) Prob- lem,” Naval Research Logistics Quarterly, 20, 57-67 (1973).

[6] Carlier, J., “The One-Machine Sequencing Problem,” European Journal of Oper- ational Research, 11, 42-47 (1982).

[7] Carlier, J., and Pinson, E., “An Algorithm for Solving the Job-Shop Problem,” Management Science, 35(2) 164-176 (1989).

181 Florian, M., Trepant, R., and McMahon, G . , “An Implicit Enumeration Algorithm . _ for the Machine Sequencing Problem,” Management Science Applications, 17,782- 792 (1971).

\ I

[9] Garey, M.R., and Johnson, D.S., Computers and Intractabili/y, Freeman, San Fran- cisco, CA, 1979.

[lo] Gelders, L., and Kleindorfer, P., “Coordinating Aggregate and Detailed Scheduling in the One Machine Job Shop: Part I,” Operations Research, 22, 46-60 (1974).

[ 111 Gelders, L., and Kleindorfer, P., “Coordinating Aggregate and Detailed Scheduling in the One Machine Job Shop: Part 11,” Operations Research, 23, 312-324 (1975).

[ 121 Jackson, J.R., “Scheduling a Productin Line to Minimize Maximum Tardiness,” Research Report No. 43, Management Science Research Project, University of California, Los Angeles, 1955.

[13] McMahon, G . , and Florian, M., “On Scheduling with Ready Times and Due Dates to Minimize Maximum Lateness,” Operations Research, 23, 475-482 (1975).

[ 141 Schrage, L., “Obtaining Optimal Solutions to Resource Constrained Network Scheduling Problems,” unpublished manuscript.

[ 151 Schrage, L., “Solving Resource-Constrained Network Problems by Implicit Enu- meration-Nonpreemptive Case,” Operutions Research, 18(2), 263-278 (1970).

Manuscript received August 2, 1990 Accepted July 16, 1991

Documents

On scheduling with ready-times, due-dates and vacations