On Scheduling with Ready Times and Due Dates to Minimize Maximum Lateness

On Scheduling with Ready Times and Due Dates to Minimize Maximum LatenessAuthor(s): Graham McMahon and Michael FlorianSource: Operations Research, Vol. 23, No. 3 (May - Jun., 1975), pp. 475-482Published by: INFORMSStable URL: http://www.jstor.org/stable/169697 .

Accessed: 09/05/2014 06:59

Your use of the JSTOR archive indicates your acceptance of the Terms & Conditions of Use, available at .http://www.jstor.org/page/info/about/policies/terms.jsp

.JSTOR is a not-for-profit service that helps scholars, researchers, and students discover, use, and build upon a wide range ofcontent in a trusted digital archive. We use information technology and tools to increase productivity and facilitate new formsof scholarship. For more information about JSTOR, please contact [email protected].

.

INFORMS is collaborating with JSTOR to digitize, preserve and extend access to Operations Research.

http://www.jstor.org

This content downloaded from 169.229.32.138 on Fri, 9 May 2014 06:59:30 AMAll use subject to JSTOR Terms and Conditions

http://www.jstor.org/action/showPublisher?publisherCode=informs

http://www.jstor.org/stable/169697?origin=JSTOR-pdf

http://www.jstor.org/page/info/about/policies/terms.jsp


OPERATIONS RESEARCH, Vol. 23, No. 3, May-June 1975

On Scheduling with Ready Times and Due Dates to Minimize Maximum Lateness

GRAHAM MCMAHON

University of New South Wales, Australia

MICHAEL FLORIAN

University of Montreal, Montreal, Quebec

(Received original June 13, 1974; final, December 16, 1974)

An algorithm is developed for sequencing jobs on a single processor in order to minimize maximum lateness, subject to ready times and due dates. The method that we develop could be classified as branch- and-bound. However, it has the unusual feature that a complete solution is associated with each node of the enumeration tree.

IN REFERENCES 1 and 2 implicit enumeration algorithms were pre- sented for the following scheduling problem: n jobs become available for

processing at nonnegative ready times ai and have processing times di and due dates bi. The aim is to find the order of processing these jobs that minimizes the maximum lateness of the jobs. While the problem is inter- esting in itself, its importance is due to its application in computing strong lower bounds for the job shop problem or the (n/m/G/Fmax) problem. The interested reader may refer to reference 2 for a complete discussion of this application.

The purpose of this paper is to present for this problem a much improved implicit enumeration algorithm that is different from the approach of references 1 and 2. The resulting algorithm could be classified as branch- and-bound. However, it has the unusual feature that a complete solution is associated with each node of the enumeration tree. We report also on the outstanding computational results obtained with the algorithm.

1. AN INITIAL SOLUTION AND ITS PROPERTIES

Our approach in solving this problem is to generate a good initial solution by using a heuristic suggested by SCHRAGE[51 and used in reference 2. We test whether this solution is optimal; if the test is unsuccessful, we generate an enumeration tree of improved solutions. We recall first the heuristic that constructs the initial solution. Let S be the set of unscheduled jobs: 1. Set t<-O.

475



476 Graham McMahon and Michael Florian

2. Is there at least one job ieS such that ai _ t? If so, go to 4. 3. Set t(-miniE af.

4. Among all jobs iES such that ai<5 t choose the job j that has the smallest due date bj; break ties on due date by selecting the job with the largest duration dj.

5. Schedule the chosen job next and update t<-t+dj. 6. If S = 0, go to 2. Otherwise the schedule is complete.

As an example consider the problems given in Table I.

TABLE I

ai di bi aidi bi

1 0 10 80 1 1 8 36 2 0 10 70 2 8 4 24 3 9 11 20 3 10 7 35 4 29 11 40 4 14 3 32 5 49 11 60 5 16 5 21

The corresponding initial solutions are

2 3 1 4 5

0 10 21 31 42 49 60

and

1 2 3 5 4

1 9 13 20 25 28

The resulting schedule consists in general of a number of separate blocks. A block is a period of continuous utilization of the machine, such that the last job in the block completes its processing at a time t, when no other job is delayed. The next job in the sequence will then start a new block. It will commence processing at its ready time, which may be at time t.

Lower bounds on the mnm-max lateness of the schedule may be computed while the initial solution is produced. Let Pj be the set of jobs that precede j in its block and the jobj itself. The completion time of j, tj, is the earliest possible completion time of the set of jobs Pj; that is, if another order were chosen for the jobs in Pj, the last job in this new order cannot complete processing before tj. Consider now such different orders. If job kcEPj, rather than j, is scheduled last, then the following possibilities arise: either (i) bk < bj-then in such a schedule, if job k were last, it would be at least as late as the lateness of j or (ii) bk>bj-then job k, if it were scheduled last, could not complete its processing before tj+ l, since the order change



Scheduling to Minimize Maximum Lateness 477

would leave a gap in the scheduled jobs. The lateness of k would then be at least tj+ 1- bk. (See also the analogous argument of Theorem 1. "')

Thus, lower bounds for our problems may be computed as follows:

LB, 1ft -bi if bj=maxiEPi b-, ' ti+l-bk if bjpzbk=maxifEp bi,

and the evident bound LB2 =maxi {ai+di-bi4. Hence, LB=max maxii LBi', LB2}.

For the examples introduced earlier, the lower bounds obtained are as shown in Table II.

We turn our attention now to ways of improving the initial solution. Let the critical job be a job that realizes the value of the max lateness in a given schedule. Any nonoptimal schedule may be improved only if the critical job may be rescheduled earlier. Consider the block of the initial

TABLE II

i LBS' LB-2 i LBil LB.2

2 -60 -60 1 -27 -27 3 -48 0 2 -23 -12 1 -49 -70 3 -15 -18 4 -37 0 5 -10 0 5 0 0 4 -7 -15

LB = O LB=0

solution where the critical job, sayj, is found. If bj=maxifp, bi, then the schedule may not be improved and the initial solution is optimal. If, however, bj3<bk for kEPj, then it may be possible to improve by scheduling k after j. (Recall that, by definition of a block, job j starts processing at a time t>aj.)

Let the generating set of j, Gj, consist of jobs iEPj such that their due dates are greater than that of the critical job j. These are the jobs that, if scheduled later than j, may reduce the maximum lateness.

Before we can apply the notion of the generating set in an enumerative algorithm, we note that the solutions space may be partitioned into disjoint sets of solutions, each defined by the relative order of job k in Gj and the critical job j. If job kEPj but kfGj, then any solution associated with a relative sequence change of k and j may be ignored. However, each k, kEGj, if scheduled later than j, generates an associated subset of solutions that may contain improved solutions, possibly an optimal one.

A convenient way of looking at the solutions for which a job kEGj is scheduled later than j is to create a new problem, in which ak' = a. If we




apply the algorithm that generates the initial solutions to this problem, job k will be scheduled later than job j.

2. THE IMPLICIT ENUMERATION ALGORITHM

We now define a search tree that has the initial solution represented by the root node. At this node we also compute a lower bound on all schedule values and a generating set Gj for the critical job j.

For each job kEGj, we create a successor node that corresponds to a new problem, in which ak'= a. We reapply the algorithm that computes the initial solution for this problem and test it for optimality. If the optimal solution is not discovered among any of the resulting problems, then we proceed to create new successor nodes in a similar manner. As pointed out earlier, a lower bound may be computed for each node in the resulting tree. We would like to point out that the new problems may have identical solutions. As we will show later, this drawback does not lead to computational inefficiencies. The resulting algorithm may be called a 'primal' branch- and-bound method, since a complete solution is associated with each node of the tree. We shall use a strategy of branching from the node with the least lower bound. The computations may terminate at any level, in- cluding the root.

The basic strategy of the algorithm derives from the hypothesis that greater efficiency is to be expected from a method that generates the search tree using structural properties of the problem than from a method that prunes the tree of all possible schedules (permutations). In this way only the important sequence changes are explicitly evaluated. The detailed steps of the algorithm are as follows:

Step 0: Compute the initial solution and the corresponding LB, and find the critical job j and its lateness, S0L. If S0L equals LB, Stop-the initial solution is optimal. Otherwise, call the node corresponding to the initial solution the parent node.

Step 1: Find the generating set Gj and create GGjJ new nodes. For each of these set ak'= aj for kEGj and recompute initial solutions, lower bounds, LBOC , and find the critical jobs and their lateness, SOLlOc.

Step 2: If all the new nodes have been examined, close the parent node and go to Step 5. Otherwise, select the node with the smallest SOLIOc.

Step 3: Set SOL<-min { SOL, SOLl1c0}. If SOL is less than or equal to the least lower bound of all open nodes, Stop-the solution is optimal.

Step 4: If SOLlOc equals LBlOC, then the initial solution associated with this node is locally optimal. Close this node and return to Step 2.

Step 5: Select, among open nodes, the node with the least lower bound; call this node the parent node, and go to Step 1.

In the above we have identified open and closed nodes. An open node is a node that does not have successors, but may be selected as the node to




be branched from next. A closed node is a node that cannot have successors. In our algorithm nodes for which the initial solution is optimal are always closed.

f) 2,o3,o l ko5 ) {12

1 21 OR {1 (2,3,'u1,5) 2 3 (1,3,2,4,5 )

2,0 0 10 0 10O

(3,o2,4,5,o1 3j (3,4,o5, 2)

(3,4,22,51 ) 7 1,0 0

(3,o4,5,2,1 0,0

Figure 1

We illustrate the algorithm by obtaining the optimal solution for the first example introduced in section 2. The tree of solutions generated is given in Fig. 1.

For each node we indicate the associated sequence, the generating set in curly brackets, the solution value, and the lower bound. Since the lower bounds for nodes 2 and 3 are equal, we arbitrarily choose node 2. The algorithm generates only 8 out of a total of 120 sequences.




3. NUMERICAL EXPERIMENTS

We tested the algorithm on the same series of problems reported in reference 2. These equivalent problems consist of minimizing the make span by sequencing n jobs on one facility, with ready times as, processing times di and additional processing times qi that may be carried out in parallel on another facility. They were generated by choosing the number

TABLE III

Number Failures to Running times(a) of jobs amax dmax qmax find optimum

n ~~~~~~~~~~~~in 2 sec out of 100 Max Min Average

10 0 0.096 0.005 0.009

250 25 25 0 0.615 0.005 0.018

75 2 1.767 0.005 0.063 20 _ _ _ _ _ __ _ _

10 0 0.032 0.005 0.007

1000 25 25 0 0.016 0.005 0.007

75 0 0.073 0.005 0.007

10 1 0.194 0.020 0.025

600 25 25 1 0.133 0.019 0.026

75 10 1.032 0.019 0.066 50 __ _ _ ___

10 0 0.058 0.018 0.022

2500 25 25 0 0.191 0.018 0.023

75 0 0.080 0.018 0.024

(a) All times are in seconds on a CYBER 74 using the optimizing Fortran compiler (FTN).

of jobs n and three parameters amax, dmax, and qmax. The values of as were selected randomly from a uniform distribution between 1 and amax; the values of di were selected randomly from a uniform distribution between 1 and dmax; and the values of qi were selected randomly from a uniform distribution between 1 and qmaxy

We give the results obtained in Table III, and compare them with the results obtained in reference 2, Table 4. It is easy to see that the results given in Table III are better than those of Table IV. The most impres- sive improvement is that only 14 problems are not solved in a time limit of




TABLE IV

Number Failures to Running times(a) of jobs amax dmax qmax find optimum ____ _________ of

Jobs anz~axdrna~c qmasin 2 sec out

of 100 Max Min Average

10 2 0.120 0.005 0.009

250 25 25 19 0.179 0.005 0.010

75 21 0.233 0.005 0.016 20

10 0 0.010 0.006 0.008

1000 25 25 0 0.011 0.007 0.008

75 0 0.011 0.006 0.009

10 2 0.039 0.024 0.030

600 25 25 7 0.109 0.021 0.029

75 14 0.791 0.022 0.030 50 _

10 0 0.048 0.032 0.041

2500 25 25 0 0.047 0.031 0.039

75 0 0.047 0.031 0.038

(a) All times are in seconds measured on a CYBER 74 using the optimizing Fortran compiler (FTN).

2 seconds, compared with 64 problems that are not solved in this time with the algorithm given in reference 2.

Also, we solved the three scheduling problems in reference 4 by using our algorithm to compute lower bounds. If the initial solution for the sub-

TABLE V

Value ofNubro Number Number previously Value of Value of iterations oCYBE 74 Problem of of best the first the best to optimal seconds

machines operations computed solution obtained or best(a) solution o eta

1 6 36 55 55 55 36 1.43 2 5 100 1175 1198 1165 2259 151.81 3 10 100 980 1037 972 26692 (a) 698.05

(a) Indicates that calculations were terminated without proving optimality. The best unexamined bound for this problem was 808.




problems was not optimal, we limited to 500 the number of nodes generated in the enumeration tree. The results are given in Table V and are the best reported so far in the literature. The previous best results for these bench- mark problems were given in reference 2.

ACKNOWLEDGMENT

We would like to acknowledge the help of GILBERT Dupuis, who coded the algorithm and carried out some of the experiments with the code. Also, we are grateful to J. K. LENSTRA and A. R. KAN at the Stichting Mathematisch Centrum, Amsterdam for a relevant comment.

REFERENCES

1. K. R. BAKER AND ZAW-SING SU, "Sequencing with Due-Dates and Early Start Times to Minimize Maximum Tardiness," Naval Res. Logist. Quart. 21, 171- 176 (1974).

2. P. BRATLEY, M. FLORIAN, AND P. ROBILLARD, "On Sequencing with Earliest Starts and Due-Dates with Application to Computing Bounds for the (n/m/ G/Fmax) Problem," Naval Res. Logist. Quart. 20, 57-67 (1973).

3. M. FLORIAN, P. TREPANT, AND G. MCMAHON, "An Implicit Enumeration Algorithm for the Machine Sequencing Problem," Management Sci. Applica- tions 17, 782-792 (1971).

4. J. F. MUTH AND G. L. THOMPSON, Industrial Scheduling, Prentice-Hall, Engle- wood Cliffs, N. J., 1963.

5. L. SCHRAGE, "Obtaining Optimal Solutions to Resource Constrained Network Scheduling Problems," unpublished manuscript (March, 1971).



Documents

On Scheduling with Ready Times and Due Dates to Minimize Maximum Lateness