ELSEVIER Int. J. Production Economics 42 (1995) 205-216

production economics

Scheduling with two job classes and setup times to minimize the number of tardy jobs

Jatinder N.D. Gupta”,*, Johnny C. Hob

“Department of Management. Ball State Universit,v, Muncie. IN 47306-0350, USA

bAbbott Turner School of Busrness. Columbus College, Columbus, GA 31907-5645. USA

Received 10 April 1994; accepted 24 August 1995

Abstract

This paper considers the problem of minimizing the number of tardy jobs to be processed on a single machine with two job classes where a job’s setup time depends on its job class. This is an increasinbly important problem due to the growing popularity of group technology manufacturing techniques, where jobs are divided into job classes (families). Using the optimal properties of Moore’s algorithm, two approximate algorithms are developed and illustrated with an example. A simulation study conducted to examine the effectiveness of the proposed algorithms shows that the proposed algorithms perform significantly better than Moore’s algorithm and its extension.

Kevwords: Single machine scheduling; Number of tardy jobs; Heuristics; Branch-and-bound; Family setups; Empirical evaluation

1. Introduction

The requirements of setup times of jobs, which reflect the changeover times from one job to the next, are very common in many practical situ- ations. For example, before running (processing time) a job on a computer, the computer may first have to load the necessary program into memory (setup time). However, if the next job uses the same program (belongs to the same group (family or class) as the current job), then a setup will no longer be necessary for the next job. Setup times are also very common and important in many real manu-

*Corresponding author.

facturing situations [l]. For instance, the tools and fixtures of a machine may have to be changed or cleaned before running a job that belongs to a dif- ferent job family (or class) than its immediate pre- decessor. Other industrial applications involving family setups can be found in Refs. [2,3].

This paper considers a single machine scheduling problem with two job classes where a job’s setup depends only on its class. In many manufacturing scenarios, especially in group technology produc- tion, the number ofjob classes is usually very small, perhaps limited to two or three. Our objective is to minimize the total number of tardy jobs. A job is tardy when its due date is smaller than its comple- tion time. The number of tardy jobs objective is well recognized in the literature and is important, since the penalty cost often depends on whether

0925-5273/95/$09.50 ic’ 1995 Elsevier Science B.V. All rights reserved SSDI 0925.5273(95)00156-5

206 J.N.D. Gupta. J.C. Hoilnt. J. Pmduction Economics 42 (1995) 205-216

a job is tardy or not, rather than how tardy the job is [4].

Moore [S] developed the well-known construc- tive algorithm to solve the single-machine problem where the setup times are either zero or are in- cluded in the processing times. Kise et al. [6] ex- tended Moore’s algorithm to handle the non-zero ready times case, with the assumption that the ready times must increase in the same order as the due dates. Villarreal and Bulfin [7] developed a branch-and-bound procedure to minimize the weighted number of tardy jobs for the single machine. Lawler and Martel [8] presented a dy- namic programming approach to schedule two uni- form machines with preemption to minimize the number of tardy jobs. Lee et al. [9] solved the problem of minimizing weighted number of tardy jobs and weighted earliness-tardiness penalties

about a common due date by dynamic program- ming. Ho and Chang [lo] develop a heuristic to minimize the number of tardy jobs for the parallel machines.

Research involving multiple job classes include the following. Gupta [ll] described a heuristic algorithm to minimize the sum of completion time on a single machine with two job classes. Potts [12] proposed a dynamic programming algorithm to solve optimally the same problem. Gupta [ 131 developed a heuristic to minimize the mean flow time for the single machine with multiple job classes. Ahn and Hyun [3] developed a heuris- tic based on the modified Psaratis’s [14] dynamic programming algorithm to solve the mean flow time, single-machine problem with multiple job classes.

The rest of this article is organized as follows. Section 2 states the problem, major assumptions, and its formulation as a mathematical program. The development of the proposed heuristic algo- rithms is discussed in Section 3. Section 4 solves a numerical example to illustrate the proposed al- gorithms. The computational results obtained from a simulation experiment used to evaluate the effec- tiveness of the proposed algorithms in finding a schedule with minimum number of tardy jobs are discussed in Section 5. Finally, Section 6 concludes the paper and suggests fruitful directions for future research.

2. The problem

We consider the problem of scheduling a set of jobs on a single machine or processor with the objective of minimizing the number of tardy jobs. The major assumptions are given as follows: l All jobs are available at time zero. l Processing times, setup times, and due dates are

deterministic and known. l Each job belongs to either one of the two job

classes. l A setup is required for the first job on the

schedule. l A setup is required whenever there is a change

from one job class to another. l The jobs belonging to the same job class may not

be identical, i.e., their processing times are not necessarily the same.

The following notations will be used to define the problem.

pi the number of jobs the job i

Jri, the job placed in sequence position i of the schedule

Pi the processing time of job Ji

di the due date of Ji Si the setup time of Ji

Bi the group (class) number of Ji, gi E {l, 2$ Ci the completion time of Ji Xi a binary variable that indicates whether

a setup is required for Ji (1 + setup; 0 + no setup)

)‘ik a binary variable that indicates whether job Ji is placed in position k of the schedule (1 + yes; 0 + no)

zi a binary variable that indicates whether Ji is tardy (1 + tardy; 0 + not tardy)

Z”*’ the optimal number of tardy jobs of a prob-

lem M a very large number. This problem can be formulated as the following mathematical program.

Minimize

Zopt = i Zi i=l

J.N.D. Gupta, J.C. Ho/h. J. Production Economics 42 (1995) 205-216 207

subject to

kc, 4’ik = 1 vi; $1 4(ik = 1 vk;

S[k] = i$l L)ikSi v’k,

P[k] = i 4(ikPi vk; d[k] = i J’ikdi Vk; i=l i=l

g[k] = c yikgi v’k, i=l

k=l

x[l] = 1; qk] = lg[k] - g[k-I]/, 2 6 k d n,

J’ik=OOr 1 vi,k; Zi=OOr 1 v’i.

The optimal solution of this problem is given by the variables, 4’ik. However, the above formulation can be used to solve problems containing only a few jobs. Therefore, other solution approaches includ- ing heuristics that provide quick and near-optimal solutions are very desirable.

3. Heuristics algorithms

It is easy to see that an optimal schedule belongs to one of the n! non-preempted sequences. There- fore, all preempted sequences can be ignored, and we can limit our search to the non-preempted solu- tions. We now describe two heuristic algorithms to find an approximate solution to the problem.

3.1. Algorithm A

The first proposed algorithm, called Algorithm A, proceeds as follows. It first obtains an initial se- quence of all n jobs according to the EDD (earliest due date) order, as in Moore’s algorithm. Then, it minimizes the setup times by executing a leftshif or a rightshi& where appropriate, for each job that requires a setup in the sequence, starting from JrZ1, .Jr3, and so forth.

Let Jrp, be the current job under consideration and Jr,, be the latest job among the first (p - 2) jobs that belongs to the same class as job Jcpl, i.e.,

gIpl = gcml # gli, for cI < i < (p - 2). We set c( = 0 if x does not exist. The leftshift moves Jcsl to the left and places it directly after Jr,,, while the rightshift moves Jcal to the right and places it directly before JLP,. If executing a leftshift or rightshift does not leave any tardiness to the jobs assigned in positions

c( + l,cx + 2, . . . ,/I, then the execution is considered a success; otherwise, the execution is considered a failure and is therefore reversed. It is important to note that the EDD order within each class ofjobs is always maintained. Let S be the original sequence under consideration, and S’ be the new sequence after executing a successful leftshift or rightshift operation. Moreover, let z(S) and r(S’) denote the total setup time in sequences S and S’, respectively, and let 6 = r(S) - r(S’). We now analyze the re- sults of executing a leftshift and a rightshift under different cases.

Case 1: grpl = 91p+11. Case la: x = 0.

Leftshift: 6 = - scpl. Rightshift: Infeasible. Action: None.

Case lb: c( = 1. Leftshift: 6 = 0. Rightshift: 6 = scBI. Action: A rightshift is executed. If it is not successful, a leftshift is executed. Since a left- shift pushes the setup from Jcpl to JrP + i, and may make Jrpl early if otherwise tardy.

Case lc: CI 2 2 and xlarl = 1. Leftshift: 6 = 0. Rightshift: S = scpl + sla_ i,. Action: A rightshift is executed. If it is not successful, a leftshift is applied (see case lb).

Case Id: M 2 2 and xCal = 0. Leftshift: 6 = 0. Rightshift: 6 = 0. Action: A leftshift is executed (see case lb).

Case 2: srp] f sto+ 11. Case 2a: c1 = 0.

Leftshift: 6 = scB + i,. Rightshift: Infeasible Action: A leftshift is executed.

Case 2b: sl = 1. Leftshift: 6 = slpl + scfl+ i,. Rightshift: 6 = seal.

208 J.N.D. Gupta. J.C. Ho!lnt. J. Production Economics 42 (1995) 205-216

Action: A leftshift is executed. If it is not a suc- cessful, a rightshift is applied.

Case 2c: x 2 2 and xl%, = 1. Leftshift: fi = scp, + scB+ i,. Rightshift: 6 = slB, + scII+ i,. Action: A leftshift. is-executed. Though 6 is also positive for a rightshift, it is not needed because a leftshift (cases lb, lc, Id, and 2b) has failed for Jta + 11.

Case 2d: r 3 2 and xlz, = 0. Leftshift: 6 = slpl + .sIB+il. Rightshift: 6 = 0.

Action: A leftshift is executed. If the leftshift does not lead to tardiness for Jt,, i, of S’ but creates tardiness for JIs+21 of S’, then make additional leftshifts for jobs J,, + z1, JIz + 3 , , . ..) Jcsl, as long as they are tardy. If the addi-

tional leftshifts are successful, then 6 = sra,. Case 3: JLII+ 11 does not exist.

Case 3a: x = 0. Leftshift: 6 = 0. Rightshift: Infeasible. Action: None.

Cuse 3b: x = 1. Leftshift: 6 = .sIsl. Rightshift: ii = .sIB,. Action: A leftshift is executed. If it is not suc- cessful, a rightshift is applied.

Case 3c: x 2 2 and ~~~~ = 1. Leftshift: 6 = sllr,. Rightshift: S = sllrl + sr8+ 11. Action: A leftshift is executed. Though 6 is also positive for a rightshift, it is not needed because a leftshift (cases lb, lc, Id, and 2b) has failed for Jr,, 1 ,.

Case 3d: c( 3 2 and .qsr, = 0. Leftshift: 6 = sIB,. Rightshift: 6 = 0. Action: A leftshift is executed.

Fig. l(a) summarizes the overall logic of procedure SETUP based on the above three cases, while Fig. l(b), (c) and (d) correspond to cases 1,2, and 3, respectively. The following additional notations are needed for describing algorithm A. S 0.n the schedule obtained by ordering the jobs

in EDD order

n1 the number of jobs that have been deleted from schedule Sni .nL

n2 the number of jobs that remains in schedule S n,,n2, i.e., n = nl + n2

N the set of n jobs; N = (1,2, . . . ,n) Z* the number of tardy jobs given by the pro-

posed algorithm S” the schedule given by the proposed algo-

rithm

Fig. l(a). Procedure SETUP.

(b)

Fig. l(b). Case 1

J.N.D. Gupta, J.C. Ho/M J. Production Economics 42 (1995) 205-216 209

(c) Leftshift

I I

+

lM”lTl

Fig. l(c). Case 2.

(d)

Leftshift Lri Nil A If YPC

-TX Yes

23 Return

Fig. l(d). Case 3.

K,(S) the slack for Ji of schedule S, i.e., K,(S) = di - Ci.

The steps of the proposed algorithm A is given below. 1. Initialize S* = 4, Z* = n1 = 0, and n2 = n. Ob-

tain schedule S,, , n2 by arranging jobs in EDD

order. Break ties using SPT (shortest processing time) rule. Let fi = 2. Enter step 2.

2. If gcpl # gIp_il, let Jt,, be the job such that $pl = glal # g[i] for C! d i < (/3 - 2) (set sI = 0 if a does not exist) and apply procedure SETUP (Fig. 1). Enter step 3.

3. If K,,,(S,,,,,) > 0 and /I < nz, set p = fl + 1 and return to step 2. If K,,,(S,,,,,) < 0 and fl < n,,

enter step 4. If KtIr,(S,,,,,) < 0 and p = n2, de- lete Jrpl, let n2 = n2 - 1, n, = n - n2 and go to step 5. If K,,,(S,l,n2) 3 0 and /I = n2, proceed to step 5.

4. Find and delete J, such that the following condi- tions are met:

(i) 1 d (x < P; (ii) the deletion of .Jra, and application of pro-

cedure SETUP to JL1,,.Jr2,, . ,Jrp_ 1, re- sults in a schedule that has the smallest

%I; and (iii) there does not exist a job, say Jib,

(1 d h < P), such that pral < plhl and

&a, ’ d[h,, or P[~I = p[bl and d,,, > dlbl, or

P[~I < PC~I and &I = &,I~ and gral = g[bl. Update n2 = n 2 - 1, nl = n - n2, and S,,,, from the best schedule (the one with the smallest C,,,) obtained in (ii). Return to step 2.

5. Update Z* = n1 and S* = S,l,,i. Append the jobs in S” in any order to S*, where S” = {jENlj$S*}, and accept this schedule as

the solution to the problem. Step 1 initializes the procedure. Step 2 deter-

mines whether procedure SETUP is applied to Jclr,. It is applied if Jcp, requires a setup. In step 3, if Jrpl is not tardy and p < n2, then increment p by 1 and return step 2. This step also determines which step to execute next. In step 4, if Jcp, is tardy and /I < n2, then a job is selected, according to the three conditions in the step, to be removed from the schedule. It should be noted that condition (iii) ensures that no job dominates the selected job J,, in processing time and due date. Step 5 updates Z* and S* and terminates the algorithm with schedule

210 J.N.D. Gupta, J.C. Hoilnt. J. Pwductiun Economics 42 (1995) X15-216

S* where the jobs not included in schedule S* can be appended at the end of S* in any order.

The computational time required for ordering jobs in EDD in O(n log n) while the SETUP pro- cedure can be done in O(n) time. Therefore, remain- ing steps of algorithm A can be executed in O(n’) time. Thus, the computational time requirements of algorithm A is O(n’). By suitable selection of cod- ing schemes, it may be possible to reduce the com- putational time requirements to O(M log n).

3.2. Algorithm B

We now discuss a heuristic branch-and-bound search method, called Algorithm B which improves the effectiveness of Algorithm A in finding a sched- ule with minimum total number of tardy jobs. One major difference between the conventional branch-and-bound application to scheduling and Algorithm B is the way in which they derive a per- mutation schedule. The conventional branch-and- bound method starts with an empty root node, and gradually adds jobs to the partial sequence in the branching step. On the other hand, Algorithm B starts with a complete sequence of jobs at the root node, and gradually removes jobs from the node until all (remaining) jobs are early or it is no longer fruitful to explore the node. Another major difference between algorithm B and conventional branch and bound is the fact that not all possible branches are evaluated. Through a judicial prun- ing, only a subset of the branches are examined. Because of this difference, the proposed algorithm B does not always guarantee an optimal schedule.

If the current job under consideration, say J,,,, remain tardy after applying procedure SETUP to minimize setup times, then a proposed heuristic branch-and-bound search procedure is be applied to reduce the number of tardy jobs. The branching step is accomplished by removing a job from the subproblem. It should be noted that Moore’s algo- rithm always removes the job with the largest pro- cessing time among the first k (where Jrkl is the first tardy job) jobs in sequence. The branching process works as follows. For each unfathomed subprob- lem we partition (branch) it into two subproblems. The first subproblem removes a job, say J,,, such

that 1 d a d /J and grtil = 1, from an unfathomed node, while the second subproblem deletes a job, say J,,,, such that 1 < u < /I and gCul = 2 from the unfathomed node. If all jobs in position 1 through position b belong to either group 1 or group 2, then only one subproblem is created. Furthermore, Jr,, must meet the three conditions in step 4 of Algorithm A. It is important to note that branching always selects the most recently created (depth-first rule) problem, since we can get a better bound more quickly. A subproblem is fathomed if (1) all jobs in the sequence are early; (2) the subproblem has been branched twice (or once if Jil,,J12,, . . , JIp 1 below to either group 1 or group 2); or (3) further branch- ing would lead to a schedule that is inferior to the incumbent solution. When a subproblem is fathomed, we update the incumbent lower bound (LB), where LB denotes the incumbent lower bound of the number of non-tardy jobs, and the incumbent solution if the lower bound of the sub- problem under consideration (denoted by LB’) is larger than LB. These branching, bounding, and fathoming steps continue until all subproblems are fathomed.

The steps of the proposed algorithm B are as follows:

1. Initialize LB = 0, S* = 4, Z* = n, = 0, and n2 = n. Obtain schedule S,I,,I (root node) by arranging jobs in EDD order. Break ties using SPT (shortest processing time) rule. Let b = 2. Enter step 2.

2. If grill # yLB_ll, let Jr,, be the job such that g[fil = yIgl # YCi] for c( d i < (/I - 2) (set c( = 0 if x does not exist) and apply procedure SETUP (Fig. 1). Enter step 3.

3. If K,,,(SH,J12 ) 3 0 and b < n2, set fi = a + 1 and return to step 2; otherwise, enter step 4.

4. If LB < n2 - 1 and fi < n2, enter step 5; other- wise go to step 7.

5. Among the unfathomed nodes, select the one that was created most recently: l If it has been branched twice or LB 3 n2 - 1,

fathom the subproblem and go to step 8. l If it has never been branched, let gp = 1 and

enter step 6. l If it has been branched once, let gp = 2 and

enter step 6.

J.N.D. Gupta. J.C. Ho/M. J. Production Economics 42 (1995) 205-216 211

6. Branch from this subproblem by removing

Jbl (i)

(ii) (iii)

from S,,.,,, such that

S[al = SP; ldU<J$ the deletion of Jc,, and application of pro- cedure SETUP to Jc1,,Jc2,, . . . ,JIp_l, re- sult in a schedule that has the smallest C,,,; and

(iv) there does not exist a job, say

$,I (1 < b d /I, such that pcaI < p[b] and

&, > d[b,, or &a] = P[b] and &a] > d[b], Or

&a] < P[b] and d,a, = d[b,r and $a] = g[b].

If Jcal is found, update n2 = n2 - 1, ni = n - n2,

and Sn,,n2 from the best schedule (the one with

the smallest C,,,) obtained in (iii), set b = 2 and return to step 2; else return to step 5.

7. Fathom the subproblem. If Klp,(Sn,,n2) > 0, then LB’ = nz; else LB’ =/I - 1. If LB’ > LB, then set LB = LB’ and update S* = S,,,,,. Enter step 8.

8. If every subproblem is fathomed, then set Z* = n - LB, and append the jobs in S” in any order to S*, where S” = ( j E N Ij#S* }, and stop; else return to step 5.

As in Algorithm A, steps 1 initializes the proced- ure. Moreover, steps 2 and 3 are essentially the same as in Algorithm A. In step 4, if the two conditions are not met, then it is no longer profit- able to explore further the subproblem (fathoming). LB 2 n2 - 1, implies that LB is at least as good as the best solution of the subproblem. Similarly,

B=n2, implies that the best possible bound of the subproblem is found. Hence, in either of the above two cases, we can fathom the subproblem in step 7. Step 5 identifies if the subproblem should be bran- ched further while step 6 gives the details of the branching process and is executed if Jrpl is tardy, fi < n2 and LB < n2 - 1. Step 7 fathoms the sub- problem and updates LB and S*, if necessary. Finally, step 8 terminates the algorithm if all subproblems are fathomed.

The maximum number of nodes generated by Algorithm B is approximately (2.2”“‘). Hence, the smaller the number of tardy jobs in a problem, the faster the Algorithm B terminates. More important, the memory requirement is n2 at the most, since only one subproblem corresponding to each nl (job

deletion level) has to be stored at any time. There- fore, Algorithm B can be implemented on a micro- computer to solve very large size problems.

As stated earlier, the above algorithm B does not always produce optimal results since in its branch- ing and decision making scheme, it does not exhaust all possible branches. Hence, a branch containing an optimal schedule may either not be considered or fathomed creating a situation for a sub-optimal solution. It is because of this reason that we call algorithm B as a heuristic branch and bound algorithm.

4. An Example

A small example with seven jobs is used to illus- trate the working of Algorithm B. The processing times, due dates, and setup times of the seven jobs are shown in Table 1. Jobs J1, J2, and J, belong to the first group since they share the same setup time, while the other four jobs belong to the second group for the same reason. To initialize, LB = 0, S* = 4, Z* = n1 = 0, and n2 = 7. We obtain the root node (subproblem), So,, = (3,4,7,1,6,2,5) by arranging jobs in EDD order. We set fi = 2. For the first two iterations of Procedure SETUP (fi = 2 and 3), J3, J4, and 5, are early and remain in the same positions in So,,, since neither a leftshift nor

a rightshift operation is applicable. When fi = 4, Jc4, or J1 is still tardy after applying Procedure SETUP. Since Jr4, is tardy, (LB = 0 < n, - 1 = 6)

and (/I = 4 < n2 = 7), we find and delete J3 from schedule So,, . Now, we update n2 = 6 and n, = 1, and obtain the schedule S1,6 = (4,7,1,6,2,5) after

Table 1

Example data

Ji Pi di si

1 10 65 5

2 19 71 5

3 12 41 5

4 18 56 12

5 13 75 12

6 11 70 12

7 11 58 12

212 J.N.D. Gupta, J.C. Ho!lnt. J. Production Economics 42 (1995) 205-216

applying procedure SETUP. For fl = 3, we have case 2a since g1 # g6 and c( = 0. Therefore, we apply a leftshift to J1 and update Sl,h from

(4,7,1,6,2,5) to (1,4,7,6,2,5). The algorithm is applied to subproblem S,., as it

is utilized in So,,. When p = 5, Jrs, or Jz remain tardy after applying procedure SETUP. We find and delete J2 from SI,6 and create the subproblem, S2.5 = (1,4,7,6,5). The algorithm is now applied to subproblem S,,,. Again for p = 5, Jrsl or J2 re- mains tardy after applying procedure SETUP. Since /I = nz = 5, we fathom S2.5, and update LB to 4 and S* to (1,4,7,6).

We now branch from S1,6 (the most recently created unfathomed subproblem) by removing J4, and obtain a new S 2,5 = (1,7,6,2,5). For p = 2 and 3, no shift is made. For B = 4, we have case 2b since

la) s 0.7

4 41 56 58 65 70 71 75

3 47 1625

c* 17 47 58 73 96 120 145

56 58 65 70 71 75

471625

30 41 56 79 103 128

1 A leftshift for job I

65 56 i8 70 71 75

147625

I5 45 56 67 91 116

S, 5 (second) -.- 65 56 58 70 75 65 58 70 71 75

11 1117161211

15 45 56 67 80 I5 38 49 75 100

Fathomed: (p = “2 = 5) LB =4. s’ = (1.4.7.6) A leftshift for job 2

17 27 50 61 74

Fathomed: (J = n2) Fathomed:(Lf3=42n,-1=4) LB=% S’= (3.1,7,6,5)

Fig. 2(a). The left-hand side of the branch-and-bound tree. Fig. 2(b). The right-hand side of the branch-and-bound tree.

g2 # g5 and a = 1. Therefore, we apply a leftshift to J2 and update S2,5 from(1,7,6,2,5)to(1,2,7,6,5). The algorithm is then applied to the new subprob-

lem S2,,. For b = 5, JL5, or J5 remains tardy after

applying procedure SETUP. Since LB = 4 3 n2 - 1 = 4, we fathom subproblem S2,5. We also fathom subproblem S1,6 because it has been branched twice. Fig. 2(a) summarizes the left-hand side of the branch-and-bound tree.

Next, we branch from S0.7 and obtain a new S I,h = (3,7,1,6,2,5). For p = 2 (case 2a), we per- form a leftshift by inserting J, before J, and obtain an updated S1,6 = (7,3,1,6,2,5). For /I’ = 4 (case 2b), we perform a leftshift for JE4, or Jb, but the leftshift makes J3 and J1 tardy and fails. Therefore, we perform a rightshift for J6 instead according to

(b) s 0.7

4 41 56 58 65 70 71 75

347 16 2 s

c, 17 47 58 73 96 I20 145

41 58 6?70 71 75

31 7) 11 612 ) 5 17 40 55 78 102 127

1

A leftshift for job 7

58 41 65 70 71 75

131625

23 40 50 73 97 122

1

A leftshift for job 6 fails, so a rightshift for job 6 instead

41 65 58 70 71 75

3111716 215

17 27 50 61 X5 II0

41 65 58 70 75

J.N.D. Guptu, J.C. Ho/M J. Production Economics 42 (1995) 205-216 213

case 2b and obtain an updated S1,6 = (3,1,7,6, 2,5). For /J = 5, Jrs, or J2 remains tardy after ap- plying procedure SETUP. Hence, we create a new subproblem S2,5 = (3,1,7,6,5) by deleting J2 from S I,h. For fi = n2 = 5 of subproblem S2,5, we fathom the subproblem, and update LB to 5 and S* = (3,1,7,6,5). Now, we check the two remaining subproblems that have not been fathomed. Subproblem S1,, is fathomed since LB = 5 > n 2 - 1 = 5. Subproblem So,, is also fathomed as it has been branched twice. Since every subproblem is now fathomed, the algorithm terminates and gives a solution of (3,1,7,6,5,2,4) or (3,1,7,6,5,4,2) with Z* = 2. Fig. 2b summarizes the right-hand side of the branch-and-bound tree.

5. A simulation experiment

We perform a simulation experiment to evaluate the effectiveness of the proposed algorithms. The simulation consists of two phases. Phase 1 consists of 2400 small size problems, with jobs ranging from seven to nine, while phase 2 consists of 2000 large number of medium- and large-size problems, with jobs ranging from 15 to 50. We compare the pro- posed algorithms to Moore’s algorithm and an extension of Moore’s algorithm. The extension of Moore’s algorithm differs from Moore’s algorithm in that it removes the job that results in the largest reduction in completion time among the first k (where jCkl is the first tardy job) jobs in sequence. The extension is used for comparison purpose, since there is no heuristic method designed to solve this problem. The preliminary results show that the extension outperforms Moore’s algorithm con- siderably. Moreover, optimal solutions for small problems (phase 1) are found by full enumeration to serve as a comparison standard. All heuristics are programmed in FORTRAN on an IBM PSI2 Model 70 computer.

5. I. Generation of problems

The processing time is assumed to follow a discrete uniform distribution between 1 and 50, i.e., DU(l, 50). The due date is assumed

to follow DU(l, 1.5pn/q) for large problems and (DU(1,2pn/q) for small problems, where p is the average processing time, and q serves as an indi- cator of shop congestion, similar to the traffic congestion ratio (TCR) in Ref. [15]. The higher the q, the more congested the shop, hence higher the number of tardy jobs. It should be noted that if di < pi, then a new di will be generated until di > pi. The setup time is assumed to follow DU(l, 2pr) + pr, where r is used to specify to mag- nitude of setup time. Furthermore, the number of jobs of each group is assumed to be n/2. If n is odd, then groups 1 and 2 consist of (n - 1)/2 and (n + 1)/2 jobs, respectively. The selection of jobs in each class as above is designed to create more dijficult problems, since the extreme cases (all jobs in class 1 or class 2) reduce to the easy one-class problem solvable by Moore’s algorithm. If the pro- portion of jobs in each class varies from those considered above, the problems are still easier to solve since the total number of setups required will decrease. In fact, our computational results with problems involving 75% jobs in one group and 25% jobs in the other group confirmed this observation. Therefore, we report the simulation results only for the case where the number of jobs in each group is almost equal as these problems are the most difficult problems to solve by the proposed algorithms.

Three factors are considered: the number ofjobs, n; due-date tightness, q; and setup time magnitude, Y. For phase 1, the number of jobs are set at three levels, 7,8, and 9; the due date tightness is specified by q, and set at two levels, 1.75 (high) and 1.25 (low); the setup time magnitude is specified by r, and set at two levels, 1.0 (high) and 0.5 (low). For phase 2, the number of jobs are set at five levels, 15, 20, 30, 40, and 50; the due date tightness and setup time mag- nitude are set in the same manner as in phase 1. Hence, 12 and 20 sets of problems are run in phases 1 and 2, respectively. For each set of problems in phases 1 and 2, we make 200 and 100 replications, respectively.

5.2. Computational results

For each set of problems in phase 1, we report the total number of tardy jobs, and the percentage

214 J.N.D. Gupta. J.C. Ho/M. J. Production Economics 42 (1995) 205-216

(of the number of tardy jobs) above the optimum for each heuristic where the optimal solution to each problem was found through complete enu- meration of all n! schedules. For each set of prob- lems in phase 2, we gather the statistics on the total number of tardy jobs for each heuristic. A perfor- mance ratio, computed by dividing the total num- ber of tardy jobs of a heuristic by that of Algorithm B, is also reported.

Table 2 gives the phase 1 simulation results. It shows that Algorithm B has the best performance. It is 100% optimal in six sets of problems and is at least 99% optimal in eleven sets of problems. Over- all, Algorithm B optimally solves 2392 problems (it is one job above the optimum for the other eight problems), or over 99.6% of all problems. The mean percent deviations above optimum for algo- rithms A and B, Moore’s algorithm, Moore’s exten- sion are 2.75, 0.14, 19.3, and 15.0, respectively.

Table 3 gives the phase 2 simulation results. It clearly shows that Algorithms A and B perform significantly better than Moore’s algorithm and Moore’s extension. The average performance ratios for Algorithm A, Moore’s algorithm and Moore’s extension are 1.035, 1.64, and 1.78, respectively. It is interesting to note that the relative performance of Moore’s algorithm and Moore’s extension improve when the percentage of tardy jobs is relatively high,

Table 2

Evaluation results for heuristics on small problems

i.e., q = high. This may suggest that Moore’s algo- rithm and Moore’s extension produce many tardy jobs that should have been early when the shop is less congested. When the shop is more congested, those jobs would have been tardy anyway. Hence, the performance ratio decreases as the shop be- comes more congested.

As stated before, we solved additional 2000 me- dium- and large-sized problems generated as above except that the total number of jobs to the two classes were distributed as 25% to class 1 and 75% to class 2. The proposed algorithms for these prob- lems outperformed Moore’s algorithm and its ex- tension. Further, the results obtained were better than those reported in Table 3 indicating that the problems with about equal number of jobs in each class are the hardest problems to solve by the proposed algorithms. While the performance of the heuristic algorithms is not independent of the dis- tribution of the number of jobs in each class, given the results of the simulation experiments, we can conclude that the proposed algorithms are relat- ively more effective than Moore’s algorithm and its extension in finding the optimal solution.

Table 4 gives the results on CPU time. It shows that the average CPU time for Algorithm A, Algo- rithm B, Moore’s algorithm, and Moore’s extension are 0.16, 33.9, 0.01 and 0.02 s, respectively. For

n 4 r Total number of tardy jobs/percent deviation

Optimal Moore’s Moore’s Algorithm Algorithm

algorithm extension A B

7 L H

L

H

8 L

H L

H

9 L

H L H

L

L

H

H

L

L H

H

L L

H H

278 0.0

455 0.0

480 0.0

710 0.0

264 0.0

470 0.0 483 0.0

754 0.0

264 0.0

488 0.0

488 0.0 773 0.0

328 18.0 319 14.7

516 13.4 511 12.3

556 15.8 520 8.3

779 9.7 754 6.2

329 24.6 323 22.3

569 21.1 549 16.8 611 26.5 572 18.4

848 12.5 810 7.4

330 25.0 331 25.4

581 19.1 570 16.8 635 30.1 592 21.3 899 16.3 847 9.6

283 1.8 278 0.0

466 2.4 456 0.2

491 2.3 480 0.0

744 4.8 710 0.0

267 1.1 264 0.0

481 2.3 473 0.6

492 1.9 483 0.0

786 4.2 755 0.1

272 3.0 265 0.4

497 1.8 489 0.2

507 3.9 489 0.2

800 3.5 883 0.0

J.N.D. Gupta, J.C. HolInt. J. Production Economics 42 (1995) 205-216 215

Table 3

Evaluation results for heuristics on large problems

n 4 r Total number of tardy jobs/performance ratio

Moore’s Moore’s Algorithm Algorithm

algorithm extension A B

15 L L 346 1.45 335 1.41 243 1.02 238 0.0

H L 554 1.23 539 1.20 460 1.02 450 0.0

L H 574 1.45 530 1.34 414 1.05 396 0.0

H H 777 1.25 725 1.16 652 1.04 624 0.0

20 L L 434 1.56 413 1.49 282 1.01 278 0.0

H L 724 1.35 692 1.29 550 1.02 537 0.0

L H 738 1.62 657 1.44 477 1.05 456 0.0

H H 1017 1.38 934 1.27 774 1.05 737 0.0

30 L L 565 1.86 540 1.78 309 1.02 303 0.0

H L 1001 1.45 976 1.41 704 1.02 690 0.0

L H 1034 2.06 908 1.81 524 1.04 503 0.0

H H 1446 1.56 1295 1.39 977 1.05 929 0.0

40 L L 690 2.30 653 2.18 307 1.02 300 0.0

H L 1300 1.61 1259 1.56 821 1.02 806 0.0

L H 1309 2.55 1145 2.23 544 1.06 513 0.0

H H 1905 1.79 1680 1.58 1115 1.05 1062 0.0

50 L L 795 2.47 756 2.35 332 1.03 322 0.0

H L 1575 1.71 1504 1.63 951 1.03 922 0.0

L H 1585 3.00 1382 2.62 560 1.06 528 0.0

H H 2311 1.93 2027 1.70 1251 1.05 1195 0.0

Table 4

CPU time (s)

n 4 r Moore’s Moore’s Algorithm Algorithm

algorithm extension A B

15 L L 0.00 0.00 0.02 0.12

H L 0.00 0.00 0.03 0.27

L H 0.00 0.00 0.02 0.14

H H 0.00 0.00 0.02 0.29

20 L L 0.00 0.01 0.03 0.26

H L 0.00 0.00 0.05 1.05

L H 0.01 0.01 0.04 0.43

H H 0.01 0.00 0.05 1.42

30 L L 0.01 0.01 0.08 0.74

H L 0.01 0.01 0.14 8.66

L H 0.01 0.01 0.09 1.84

H H 0.01 0.01 0.14 16.93

40 L L 0.02 0.02 0.12 1.28

H L 0.02 0.02 0.30 37.53

L H 0.02 0.02 0.16 2.82

H H 0.02 0.02 0.27 92.92

50 L L 0.03 0.04 0.2 1 2.54

H L 0.04 0.03 0.55 148.65

L H 0.03 0.04 0.25 6.47

H H 0.03 0.03 0.52 354.12

problems with 25% jobs in class 1 and 75% jobs in class 2, the CPU time requirements of the proposed algorithms decrease considerably while the CPU time requirements of Moore’s algorithm and its extension stay about the same. Hence, we can con- clude that Algorithm A seems to have the best performance and CPU time trade-off, since its max- imum performance ratio and CPU time are 1.06 and 0.55 s, respectively.

6. Conclusions

Two heuristic algorithms are developed to solve the single-machine problem with two job classes with the objective of minimizing the number of tardy jobs. The first proposed algorithm incorpor- ates Moore’s algorithm with a job shifting routine, while the second proposed algorithm adds the branch-and-bound search feature to the first pro- posed algorithm. A numerical example is given to illustrate the working of the proposed algorithms. Our simulation experiment shows that the pro- posed algorithms are relatively more effective than Moore’s algorithm and its extension in minimizing the total number of tardy jobs. Future research can be directed at solving problems with more than two job classes and finding worst-case performance bounds for the proposed algorithms.

Acknowledgements

A careful and thorough review of an earlier draft by an anonymous reviewer has significantly enhanced the clarity of this paper.

References

[l] Baker, K.R., 1974. Introduction to Sequencing and Sched- uling. Wiley, New York.

[2] Monma, C.L. and Potts, C.N., 1989. On the complexity of scheduling with batch setup times. Oper. Res., 37: 798-804.

[3] Ahn. B.H. and Hyun, J.H., 1990. Single facility multi-class job scheduling. Comput. Oper. Res., 17: 2655272.

[4] French, S., 1982. Sequencing and Scheduling: An Introduc- tion to the Mathematics of the Job Shop. Ellis Horwood, Chichester.

216 J.N.D. Gupta. J.C. HoiInt. J. Production Economics 42 (1995) 205-216

Moore, J-M., 1968. An n-job, one-machine sequencing

algorithm for minimizing the number of late jobs. Mgmt. Sci., 15: 1022109.

Cl01 Ho, J.C. and Chang, Y.L., 1995. Minimizing the number of

tardy jobs for m parallel machines. Eur. Oper. Res., 84:

3433355.

[61

c71

PI

c91

Kise. H., Ibraki, T. and Mine, H., 1978. A solvable case of

the one machine scheduling problem with ready times and

due dates. Oper. Res., 26: 121-126. Villarreal, J.V. and Bulfin, R.L.. 1983. Scheduling a single

machine to minimize the weighted number of tardy jobs.

IIE Trans.. 15: 337.-343.

Lawler. E.L. and Martel, CU., 1989. Preemptive schedul-

ing of two uniform machines to minimize the number of

late jobs. Oper. Res., 37: 314-318.

Lee, C.Y.. Danusaputro, S.L. and Lin. C.S., 1989. Minimiz-

ing weighted number of tardy jobs and weighted earliness- tardiness penalties about a common due date. Oper. Res.,

31: 3799389.

[I 11

1121

-[la]

r141

Cl51

Gupta, J.N.D., 1984. Optimal schedule for single facility with two job classes. Comput. Oper. Res., 1 I: 4099413.

Potts, C.N.. 1991. Scheduling two job classes on a single

mach_ine._Comput. Oper. Res., 18: 41 l-415.

Gupta. J.N.D., 1988. Single facility scheduling with mul-

tiple job classes. Eur. J. Oper. Res., 8: 42-45.

Psaraftis, H.N., 1980. A dynamic programmmg approach

for sequencing groups of identical jobs. Oper. Res., 28:

1347-1359.

Ho, J.C. and Chang, Y.L., 1991. Heuristics for minimizing

mean tardiness form parallel machines. Naval Res. Logist..

38: 367~m381.