Single machine earliness and tardiness scheduling

EUROPEAN JOURNAL

OF OPERATIONAL RESEARCH

E L S E V I E R European Joumal of Operational Research 96 (1997) 546-558

T h e o r y a n d M e t h o d o l o g y

Single machine earliness and tardiness scheduling

G e o r g e L i

Department of Information and Operations Management, School of Business Administration, University of Southern California, Los Angeles, CA 90089-1412, USA

Received 1 May 1995; accepted 1 February 1996

Abstract

We examine the problem of scheduling a given set of jobs on a single machine to minimize total early and tardy costs without considering machine idle time. We decompose the problem into two subproblems with a simpler structure. Then the lower bound of the problem is the sum of the lower bounds of two subproblems. A lower bound of each subproblem is obtained by Lagrangian relaxation. Rather than using the well-known subgradient optimization approach, we develop two efficient multiplier adjustment procedures with complexity O(nlog n) to solve two Lagrangian dual subproblems. A branch-and-bound algorithm based on the two efficient procedures is presented, and is used to solve problems with up to 50 jobs, hence doubling the size of problems that can be solved by existing branch-and-bound algorithms. We also propose a heuristic procedure based on the neighborhood search approach. The computational results for problems with up to 3 000 jobs show that the heuristic procedure performs much better than known heuristics for this problem in terms of both solution efficiency and quality. In addition, the results establish the effectiveness of the heuristic procedure in solving realistic problems to optimality or near optimality.

Keywords: Scheduling theory; Branch and bound; Heuristics; Search theory

1. Introduction

In this paper, we examine the problem of scheduling a set of jobs on a single machine to minimize total early and tardy costs without considering machine idle time. Specifically, we are to find the schedule that minimizes the total earliness and total tardiness costs of all jobs, subject to the constraints that no pre-emption of jobs is allowed, no idle time is permitted, and all the jobs are initially available. Unlike weighted tardiness scheduling, the problem includes an early cost in the objective function. The inclusion of the early cost, as Sidney [22] points out, may represent the cost of completing a project early in PERT-CPM analyses or deterioration in the pro-

duction of perishable goods. The problem does not consider machine idle time. Therefore, it reflects a type of industry setting where early and tardy costs are involved, jobs are processed on a single machine (or a single process), and the machine cost of being kept idle is higher than the early cost caused by processing a job early; or the capacity of the machine is limited compared with demands, so the machine is kept running and no idle time is permitted in the work day. Some specific examples are the Los Angeles Westvaco Envelope plant (Landis [14]) and pioneering Video Manufacturing in Carson of California (Korman [13]).

As a generalization of weighted tardiness scheduling (Karp [12], Lawler [15], Lenstra [16]), the prob-

0377-2217/97/$17.00 Copyright © 1997 Elsevier Science B.V. All rights reserved. PII S0377-221 7(96)00062-8

G. Li / European Journal of Operational Research 96 (1997) 546-558 547

lem can be easily regarded as NP-complete, and has been considered by Abdul-Razaq and Potts [1 ], Ow and Morton [17], and Azizoglu, Kondakci and Kirca [2]. It should be pointed out that there are a large number of papers considering weighted tardiness and earliness scheduling, but here we only review the three papers above because they examine the same problem as ours, i.e., jobs have distinct due dates, idle time is not allowed, and the objective function is to minimize the total earliness and tardiness costs. For more information on earliness and tardiness scheduling, interested readers are referred to Baker and Scudder's [4] elegant review and some recent works (see, for example, Yano and Kim [25], Soroush and Fredendall [24]).

Abdul-Razaq and Potts present a branch-and- bound algorithm. Their lower bound procedure is based on the well-known subgradient optimization approach and the dynamic programming state-space relaxation which maps a larger problem state space 2 ~ into a smaller problem state space ~ = ~ pj, where pj is the processing time of job j and n is the number of jobs in the problem. Their computational results indicate that the lower bound procedure is tight but time consuming. Therefore, problems with more than 25 jobs may require excessive solution times. Since their algorithm is based on the dynamic programming state-space relaxation approach, there could be storage problems when Y'.7= l Pj is very large. Ow and Morton propose a series of heuristics: early/tardy dispatch priority rules and the filtered beam search procedure. Their computational study shows that the early/tardy dispatch rules, although performing much better than known heuristics that ignore early costs, are far from optimal, and that the filtered beam search procedure is not only efficient but also consistent in providing optimal or near optimal solutions if the number of jobs in a problem is less than 30. But for large problems (more than 100 jobs), the filtered beam search procedure needs large solution times, especially when the filtered width and the beam width are set at large values. More recently, Azizoglu, Kondakci and Kirca examine a special case of our problem, where all the jobs have the same tardiness penalty and the same earliness penalty, and the tardiness penalty plus the earliness penalty is 1. They also propose a branch-and- bound algorithm. Their computational tests suggest

that the algorithm may need excessive solution times for problems with more than 20 jobs.

So the existing branch-and-bound algorithms discussed above cannot efficiently obtain optimal solutions to problems with more than 25 jobs; the known heuristics mentioned above cannot effectively solve to optimality or near optimality problems with more than 100 jobs.

In this paper, we present a branch-and-bound algorithm and a heuristic procedure. The branch- and-bound algorithm is based on a decomposition of the problem into two subproblems and two efficient multiplier adjustment procedures for solving two La- grangian dual subproblems. The branch-and-bound algorithm has been used to solve problems with up to 50 jobs, hence doubling the size of problems that can be solved by the existing algorithms. The heuristic procedure relies on the neighborhood search approach. It has been tested with problems of up to 3 000 jobs. The computational results show that the heuristic procedure is not only efficient but also robust in producing optimal or near optimal solutions, and that the procedure is superior to the known heuristics for this problem in terms of both solution efficiency and quality.

The remainder of the paper proceeds as follows. In the next section, the extension of two dominance rules for weighted tardiness scheduling is discussed; in addition, two simple dominance rules for early/tardy scheduling are developed. Section 3 de- scribes the decomposition of the problem and the derivation of a lower bound procedure. Section 4 presents an efficient heuristic procedure. The implementation of the branch-and-bound algorithm is discussed in Section 5. Computational results are presented in Section 6. Finally, conclusions are pro- vided in Section 7.

2. Simple dominance rules

This section gives a formal statement of the early/tardy problem and examines some simple dominance rules for an optimal schedule. In the problem, each job j is assumed to have an integer processing time pj, due date d j, tardiness penalty wj

548 G. Li / European Journal o f Operational Research 96 (1997) 546-558

and earliness penalty hi. Hence, the objective function is to find a schedule to minimize

]ET= 1 ( hj max( dj - c i, 0) + % max( % - d~, 0)),

where n is the number of jobs tO be scheduled and % is the completion time of job j.

In the following, Lemma 2.1 and Lemma 2.2 are extensions of Smith's [23] WSPT and WLPT rules, respectively. These extensions have been considered by Fry, Armstrong and Blackstone [8], and Yano and Kim [25]. Lemma 2.3 and Lemma 2.4 are two simple dominance rules developed here.

Lemma 2.1. In an optimal schedule, i f two adjacent jobs i and j satisfy w i / P i > h j / p j and are tardy regardless o f the order o f i and j , then i precedes j.

Lemma 2.2. In an optimal schedule, i f two adjacent jobs i and j satisfy h i / P i < h i / p j and are early regardless o f the order o f i and j, then i precedes j.

Lemma 2.3. In an optimal schedule S, i f two non- adjacent jobs i and j satisfy Pi = Pj and w i > wj, and are tardy irrespective o f the order o f i and j , then i precedes j .

Proof. Suppose by contradiction that j precedes i in the optimal schedule S. Let S' be another schedule which is the same as S except that i precedes j. Since p; = p j, exchanging i and j has no influence on other parts of the schedule. So it is easy to calculate that S has a larger cost than S', a contradiction that S is the optimal schedule. Thus i precedes j in an optimal schedule. []

Lemma 2.4. In an optimal schedule S, i f two non- adjacent jobs i and j satisfy Pi = Pj and h i < hi, and are early irrespective o f the order o f i and j , then i precedes j.

Proof. Similar to the proof of Lemma 2.3. []

3. Decomposit ion of the problem and derivation of a lower bound procedure

In this section, we formulate the problem, decompose the problem into two subproblems with a sim-

pier structure, and use the multiplier adjustment method developed by Potts and Van Wassenhove [20] to derive two efficient lower bound procedures for two subproblems. Then we give two examples to illustrate how the developed procedures can be used to obtain a lower bound for the problem.

Let I be the set of all n! sequences for the problem. Then the problem, denoted by (P), can be formulated as follows:

( P ) V = Min ~ (hi jE U -I- wijTij ) i ~ l j= 1

subject to

E i j > O , j---- 1 . . . . . n,

T i j>O, j = 1 . . . . . n,

Ei j >_ d i j - Cij , j = 1 . . . . . n,

T 0 > cij - dij, j = 1 . . . . . n.

With only early costs or tardy costs considered in the objective function, problem (P) can be decom- posed into two subproblems: (P1) and (P2).

(P t ) V l = M i n ~ h o E i i i ~ l j= 1

subject to

Ei j> 0, j = 1 . . . . . n, (1)

E O > d i j - c O , j = l . . . . . n.

(P2) V 2 = M i n ~ w o T i j i ~ l j= 1

subject to

T,.j > 0, j = I . . . . . n,

Tij ~ c i j -- dij, j = 1 . . . . . n. (2)

This decomposition has two motivations. First, (P1) and (P2) have a simpler structure than (P), and thus appear easy to solve. Second, (P2) is the well studied weighted tardy problem, for which many solution procedures exist (see, for example, Fisher [6], Potts and Van Wassenhove [20], Rinnooy Kan, Lageweg and Lenstra [21]). Without idle time permitted, (Pl) can be considered symmetrical to (P2) in structure, so (P~) can be solved by the solution procedures similar to those for (P2). Hence, it is


intuitively appealing to solve (P t ) and (P2) for obtaining a solution to (P) .

Nevertheless, (P2) is NP-complete (Karp [12], Lawler [15], Lenstra and Rinnooy Kan [16]), and (P1), because of its symmetry to (P2) in structure, may also be considered NP-complete. Moreover, solving (PI) and (P2) does not yield a direct solution to (P). So in this paper, rather than directly solving the two subproblems, we develop an efficient lower bound procedure for (P l ) and (P2), respectively, to derive a lower bound for (P) .

It should be noted here that (P l ) and (P2) are not symmetrical in structure when machine idle time is allowed. In this case, V~ is always zero.

Theorem 3.1. V t + V 2 < V, where V I, V 2 and V are the minimum objective function values o f (Pl ) , ( e2) and ( P ), respectively.

Proof. Let k be the optimal schedule to (P ) and V = C I + C 2, where C l = E" ~= L hkjEkj, the total early costs of k, and C 2 = E~.=lWkjTkj, the total tardy costs of k. Clearly, k is feasible to (PI) and (P2). Hence C l>V~ and C z > V 2, yielding V = C l + C 2 > V~ + V 2. []

Lemma 3.1. I f L 1 is a lower bound for (P~) and L 2 is a lower bound for (P2 ), then L 1 + L 2 is a lower bound for (P).

Proof. Since L l is a lower bound for (PI) and L 2 is a lower bound for (P2), then L t < V 1 and L 2 < V 2. Thus L ~ + L 2 < V 1 + V 2. From Theorem 3.1, we have V~ + V 2 < V. Therefore, L~ + L 2 < V, a lower bound for (P). []

3.1. A lower bound procedure for subproblem (P1)

Relaxing constraint (1) in (P i ) yields the La- grangian subproblem (Ll):

(Ll)

Z,( A)= Min ~ [ ( h 0 - }tij)Eij-~- l~ij(dij--Cij)] i~l j= I

subject to

E i j ~ O , j = 1 . . . . . n,

where A = ( h i l , hi2 . . . . . hi,) is the vector of corresponding nonnegative multipliers for sequence i.

As pointed out by Fisher [7] and Geoffrion [9], for any choice of nonnegative A, Zl(h) provides a lower bound for (Pj) . In (LI), the objective function can be expanded as follows:

Z,(3,) = Min ]~ ( h i j - A, j)Eij iEl j= I

+ ~ A i j d i j - Max ~-~ Aijcij j=l iEI j=l

For any sequence i, the minimization of the first term in Z~(A) is achieved by setting E ; j - - 0 if hij - Aij > 0 for all j or by setting Eij = oo if h o - A o < 0 for all j. Since the latter case tends to give Zi(A)= -0% a situation where the lower bound is useless, we consider only the first case in the following discussion. The second term is constant. For any sequence i, the maximization of the third term, according to Smith's [23] weighted longest processing time (WLPT) rule, is obtained by making the jobs in i satisfy h J p j < A j+ J p j + 1, J = 1 . . . . . n - 1. Since any sequence can be used to solve (Li), we use in this paper only the sequence generated by Smith's WLPT role; that is, in the sequence, hy/pj < h j + J p j + l , j = l . . . . . n - 1.

There are two considerations regarding the use of WLPT to produce a sequence for solving (L~). First, WLPT is very efficient in producing a sequence and, in our computational study, often results in a tighter lower bound for (P~) than other similarly simple heuristics. Second, a complicated, time consuming heuristic may be used here to produce a sequence for obtaining a tighter lower bound for (P~); however, the complicated heuristic is likely to reduce the efficiency of the lower bound procedure to be discussed later, and it is not clear how much the complicated heuristic can improve a lower bound for (PO.

For ease of exposition, we assume that the jobs are renumbered so that the sequence generated by the WLPT rule is (1 . . . . . n). In addition, we drop sequence index i unless it is needed for clarity, and let Cj" be the completion time of job j, j = 1 . . . . .

550 G. Li / European Journal o f Operational Research 96 (1997) 546-558

n, in the sequence. Hence, the Lagrangian dual subproblem (D 1) of Eq. LI is

(o1) Zl=Max j=l

subject to

a j / p j < a j + , / p j + , , j = 1 . . . . . n - l , (3)

O<_Aj~hj, j = 1 . . . . . n. (4)

Although the subgradient optimization approach can be used here to update the multipliers for im- proving the lower bound, we use the multiplier adjustment approach developed by Potts and Van Wassenhove [20] to obtain a solution procedure to (D1). In general, the subgradient optimization approach adjusts all the multipliers simultaneously at each iteration, and thus does not produce a series of monotonically increasing lower bounds. It zigzags in the beginning and converges slowly at the end (Held, Wolfe and Crowder [11]). Unlike the subgradient approach, the multiplier adjustment approach varies a limited number of multipliers in each iteration, and hence guarantees the monotonic improvement of the bound. Furthermore, the multiplier adjustment approach is problem specific, so it can exploit the structure of the problem, and thus often leads to simple, fast solution procedures (see, for example, Potts and Van Wassenhove [18-20]).

Duall . Multiplier adjustment procedure to solve (D 1 )

Step 1. Produce the sequence by the WLPT rule. Set Ej = dj - c j, j = 1 . . . . . n. Then set Vj = E~=jp, E,, j = 1 . . . . . n. Step 2. Set Vn+t=0 S t = { n + l } , a n d k = n . Step 3. If (k < 1), go to step 4. Let m be the smallest integer in S v If V m < Vk, set S I --- S 1 ~.J {k}. Set k = k - 1. Go to step 3. Step 4. Set k = l , and S ~ = S l - { n + l } . Step 5. If (k = 1 and k ~ St), set A k = 0. If (k > 1 and k ~ S l), set A k = A k_ l( Pk/P, - t). If (k ~ S t), set A~ = h k. Set k = k + l . Step 6. If (k < n), go to step 5. Otherwise, termi- nate.

In the procedure above, cj denotes Cj*, and S t

can be regarded as an ordered integer set {s k . . . . . Sl} with its elements in descending order of their values, where k is the number of jobs in S I. More precisely, S l is the set of those jobs that each have a positive contribution to the maximum objective function value Zl. Therefore, the larger Aj is for j ~ S~, the larger is Z r In (DI) , the largest value of Aj is hj for j ~ Sp However, each job j ~ S 1 has a negative contribution to ZI. So the smaller Aj is for j ~ S 1, the larger is Z t. In (DI), the smallest value of aj is A j_ 1( Pj/Pj- 1) for j ~ S l and j :# 1 or zero for j ~ S I and j = l .

Theorem 3.2. Procedure Duall optimally solves (Dr); i.e., A* obtained from Duall is the optimal solution to (D 1), where A* has the following structure:

at = o /f 1 ~s~, A~ = hj i f j E St,

A; = A f _ l ( P j / p j _ , ) i f j ~ S , andj> 1.

Proof. See the Appendix A. []

Procedure Dual l, requiring a computation effort O(nlog n), is very efficient. In some cases, it also generates a very tight lower bound for (P) .

Lemma 3.2. In ('°1), let Q = E~=, pj. I f dj > Q for all j and the sequence used to solve Eq. ( t 1 ) is generated by the WLPT rule, then V = Z 1 , where Z t is the lower bound obtained from Duall and V is the minimum objective function value of (P).

Proof. Since Q = E~= i Pj and dj > Q for all j, all the jobs are early (scheduling is assumed to start at time zero), the WLPT rule then minimizes the total early costs (Ow and Morton [17]), and set S 1 in Duall contains all the jobs. Therefore,

V = M i n k ( hijEij + wijTij) i ~ l j= 1

= Min ~ hijEij= Min ~ hij ( d i i - cij ) i ~ l j= 1 t e l j= l

=

j=l j=l


where C~ is the completion time of job j in the sequence produced by WLPT. []

Lemma 3.2 indicates that when all the jobs of a problem are early, then the lower bound generated by Duall is the minimum objective function value of (P) . Lemma 3.2 also implies that when most jobs of a problem are early, Duall can be used to produce a tight lower bound for (P).

3.2. A lower bound procedure for subproblem (P2 )

A Lagrangian relaxation of constraint (2) in (P2) leads to the Lagrangian subproblem (L2).

( L2)

×Z2( A) Min ~ [(wi i - Aii)T/: + A,j(cij-do) ] i~ l j= 1

subject to

T / j>0 , j = l . . . . . n,

where /~-~-( /~i1 ' /~i2 . . . . . I~in) is the vector of corresponding nonnegative multipliers for any sequence i.

Similar to (Ll), for any sequence i, (L 2) can be solved by setting Tj = 0 and wj > Aj for all j, and by making the jobs in i satisfy h J p i > h~+ ~/Pi+ 1, j = 1 . . . . . n - 1, where sequence index i is sup- pressed. The sequence used to solve (L 2) is produced by Smith's [23] WSPT rule.

As in (L~), there are two considerations concern- ing the use of WSPT to produce a sequence for solving (L2). First, WSPT is very efficient in producing a sequence and, in our computational study, often yields a tighter lower bound for (P2) than other similarly simple heuristics. Second, a complicated heuristic may be used to produce a sequence for obtaining a tighter lower bound for (P2), but the complicated heuristic is likely to reduce the efficiency of the lower bound procedure to be described in the following and it is not clear that how much the complicated heuristic can improve a lower bound for (P2).

The Lagrangian dual subproblem (D 2) of (L 2) is

( 0 2 ) ZE=Max ~ A:(C~*-d, ) j = l

subject to

Aj/pj>__Aj+Jpj+ t, j = 1 . . . . . n, (5)

wj>Aj>__0, j = 1 . . . . . n, (6)

where Cj* is the completion time of job j in the sequence generated by the WSPT rule.

The following procedure is a simpler version of the lower bound procedure developed by Potts and Van Wanssenhove [20] in that our procedure consis- tently uses the WSPT heuristic to produce the initial job sequence throughout. Also, we use cj to denote C;.

Dual2. Multiplier adjustment procedure to solve (D 2) Step 1. Produce the sequence by the WSPT rule. Set L j = c j - d j, j = 1 . . . . . n. Set Vj = Y'.~ = l Pk Lk, J = 1 . . . . . n. Step 2. Set V o = 0 , S 2={0}and k = l . Step 3. If (k > n), go to step 4. Let m be the largest integer in S 2. If V m < V , , s e t S 2 = S 2U{k}. Set k = k + 1. Go to step 3. Step 4. Set k = n, and S 2 = S 2 - {0}. Step 5. If (k = n and k q~ $2), set A n = 0. If (k < n and k ~ $2), set A k = Ak+ l(Pk/Pk+ l)" If (k ~ $2), set A k = w k. Set k = k - 1. Step 6. If (k < 1), go to step 5. Otherwise, termi- nate.

In procedure Dual2, S 2 can be regarded as an ordered integer set {s I . . . . . s,} with its elements in ascending order of their values, where k is the number of jobs in S 2. In essence, S 2 is also the set of those jobs that each have a positive contribution to the maximum value Z 2. Therefore, the larger Aj is for j ~ $2, the larger is Z 2. In (D2), the largest value of Aj is % for j ~ S 2. However, each job j ~ S 2 has a negative contribution to Z 2. Therefore, the smaller Aj is for j ES2, the larger is Z 2. In (D2), the smallest value of ;tj is Aj+ I(Pj/Pj+ 1) for j~E S 2 and j ~ n or zero for j ~ S 2 and j = n.

552 G. Li / European Journal of Operational Research 96 (1997) 546-558

Theorem 3.3. Procedure Dual2 solves (D e) optimally; i.e., A* obtained from Dual2 is the optimal solution to (D 2), where A* has the following structure:

a~ = o ifn~s2, A; = wj if j ~ S 2,

af = a;+ 1( p j / p j+, ) ifj ~ n andj ~ S 2 .

Proof. See the proof of Theorem 1 in [20]. []

Like procedure Duall, procedure Dual2 needs a computational effort O(nlog n), very efficient. In some special cases, it also can produce a very tight lower bound for (P).

Lemma 3.3. In (P2), if dj < pj for all j and the sequence used to solve (L e ) is yielded by the WSPT rule, then V = Z2, where Z e is the lower bound obtained from Dual2, and V is the minimum total early and tardy cost of (P).

Proofi Since dj < pj for all j, all the jobs are tardy, the WSPT rule then minimizes the total tardy costs (Ow and Morton [17]), and set S 2 in Dual2 contains all the jobs. Therefore,

n

V= Min • (hiiEij + wif, . j) iEl j~ 1

n

= Min k wijTij= Min E wi i ( c i j - dii) i~ l j ~ l iEI j= 1

= w; (c ; -d , )= * ; ( c ; - d ; ) =z2 j= l j = l

where Cj is the completion time of job j in the sequence generated by WSPT. []

Table 1 A single machine early/tardy scheduling problem with 6 jobs

Job w h p d

1 4 1 8 15 2 6 2 10 10 3 5 4 6 9 4 6 3 4 2 5 2 5 3 12 6 1 2 7 17

Lemma 3.3 shows that when all the jobs of the problem are tardy, the lower bound generated by Dual2 is the optimal schedule cost of (P). Lemma 3.3 also implies that when most jobs of the problem is tardy, Dual2 can be used to yield a tight lower bound for (P),

3.3. Two examples

The following two examples illustrate how Duall and Dual2 can be used to obtain a lower bound for problem (P).

Example 1. Consider the scheduling problem given in Table 1.

In order to obtain a lower bound for (P¿), we sequence the jobs using the WLPT rule and obtain the sequence 126345. From Duall, we have

E2 d2 _ c2 [ _ 7

E 3 i d 3 - c 3 ~ =

E = ' E 4 ' = ' d 4 - c41 - 2 6 J E5 d5- c5 / -33

i E6 L d6 - c6 ]

l/{,} A2 0

A3 = 0 0

A= A4

A5

A6

and S 1 = { }.

Therefore, ZI = 0. In order to obtain a lower bound for (P2), we

sequence the jobs using the WSPT rule and obtain the sequence 435 216. From Dual2, we have ILl/el dl/ L2 c2 d2 2

L3 c3 d3 --

L = L4 = c4 d4 1 '

L5 c 5 d 5 [ 1 6 J L6 c6 d6 21


A4

A5

h 6

and S 2 =

wl 6 h2 w 2

A3 - ~ , W3 ~=

w4 I w 5 w 6

{ 1 , 2 , 3 , 4 , 5 , 6 } .

Table 2 A single machine early/tardy scheduling problem with 6 jobs

Job w h p d

I 6 1 8 5 2 3 4 9 43 3 5 2 8 12 4 2 5 7 54 5 4 3 9 17 6 ! 6 7 62

So Z 2 = 182. Finally, the lower bound for ( P ) is ZI + Z 2 = 182.

The optimal schedule for ( P ) is 435216 and has the minimum cost of 182. In this example, the lower bound for problem (P~) happens to be zero, but this does not imply that the lower bound obtained from Duall is always zero (see Example 2).

Example 2. Consider the scheduling problem given in Table 2.

In this example, the sequences produced by WLPT and WSPT rules are the same, that is, 135246.

From Duall , we have

E2 d2 _ c2 - 3

E 3 d 3 - c 3 ~ =

E = , E4 = , d4 _ C4 [

iE6 ~d6 - c 6 !

h2 0

A = '~4 =

h5

h 6

S l = {4, 5, 6} and Z I = 185. From Dual2, we have

L2 [ c2

L3 c3 4

L = ~ L4 = c4 = - 9 ' -13J L5 c5 - 14

, L6 C 6

A2 6

h3 , = A ~- h4[

h5

A6

S 2 = { 1 , 2 , 3 l a n d Z 2 = 7 0 .

So the lower bound for ( P ) is 255. The optimal schedule for ( P ) is 135246 and has the minimum schedule cost of 255.

4. A n e w h e u r i s t i c p r o c e d u r e

In this section, we develop an efficient heuristic procedure based on the neighborhood search approach. One of the two basic elements in neighborhood search is an operator which generates a neighborhood for a seed. The operator decides the size of the neighborhood it produces and thus impacts the performance of neighborhood search. Traditionally, only one operator is used throughout the search process. For scheduling problems, the most com- monly used operator in neighborhood search is the adjacent pairwise interchange or the all pairwise interchange. Typically, the adjacent pairwise interchange produces a small neighborhood for a seed, thus making search quite efficient, but can easily get trapped in local optima, whereas the all pairwise interchange yields a large neighborhood for a seed, hence making search rather slow, but can possibly result in lower cost schedules. Therefore, the neighborhood search approach using either operator above may result in a poor schedule or a long solution time.


To overcome these shortcomings of the traditional neighborhood search approach for scheduling problems, we propose a new neighborhood search approach.

Unlike the traditional neighborhood search approach, which uses only one operator throughout the search process, our approach uses a set of small neighborhood operators, and changes an operator when search is stuck in local optima. In this new neighborhood search approach, the operators used to produce small neighborhoods are designed as follows. Let n be the number of the jobs in the problem. Let O P d denote the pairwise interchange of jobs i and j with d jobs between them, d = 0 . . . . . n - 2. Then OP o represents the adjacent pairwise interchange, producing a small neighborhood, and OPj produces a larger neighborhood than OPj+I, j = 0 . . . . . n - 3 .

Two observations can be made about this new neighborhood search approach. First, the use of a set of small neighborhood operators can make search quite efficient. Second, changing an operator in the search process may help break out of local optima, and possibly lead to the global optimum.

The other basic element in the neighborhood search approach is a seed which is an initial solution to the problem. Like the operator, the seed has a significant influence on the performance of the neighborhood search approach. For scheduling problems, the initial schedule, or the seed, can be produced by efficient dispatch priority rules. One of them, the early/tardy dispatch priority rule by Ow and Morton [17] is

'wJpj, sj<0 - h j /p j + ( h j /p ) + w j / p j ) e x p ( - s j / k ~ ) ,

~( j) = O<_sj<k~

- h j / p j , # > k~

where s /= dj - t - pj is the slack of job j, t is the earliest machine available time, pj is the processing time of j, fi is the average processing time of the jobs in the problem, k is an empirical integer, and /3(j) is the local priority value assigned to job j. In this dispatch priority rule, whenever the machine is available, and there are jobs waiting to be processed, the dispatch rule is used to select the next job.

However, the schedule produced by this early/tardy rule, as shown in their computational study (Ow and Morton [17]), is far from optimal. Therefore, we propose a new dispatch priority rule based on the early/tardy dispatch priority rule to select the next unscheduled job.

The new dispatch priority rule works as follows: Suppose J is the current partial schedule of rn jobs, and S is the set of k unscheduled jobs. For each job j ~ S, we schedule j as the first job following J and then use the early/tardy dispatch priority rule to schedule the other jobs in S following j. Then for each j ~ S, we obtain a corresponding schedule of (m + k) jobs, and assign to job j the total early and tardy cost of the schedule as its cost value. Select job i ~ S with the smallest cost value to schedule next.

When the number of jobs in the problem is more than 100 but less than 500, the new dispatch rule described above may be computationally expensive. In this case, the early/tardy dispatch rule is used to select a subset of the unscheduled jobs. Each job in the subset has a larger local priority value than a job not in the subset. Then the new dispatch rule is used to assign a cost value to each job in the subset and the job with the smallest cost value is selected. When the number of jobs in the problem is more than 500, we directly use the early/tardy dispatch rule to select the next job.

The new heuristic procedure Step 1. Let n be the number of jobs in the

problem. If n < 500, use the new dispatch priority rule discussed above to yield an initial schedule as the seed; otherwise, use the early/tardy dispatch priority rule to produce the seed. Let OP d with d = 0 be the initial operator. Set the stopping condition.

Step 2. Start with the first job or the last job in the seed, apply the current operator to produce a neighborhood of the seed, and calculate the total early and tardy cost for each schedule in the neighborhood. If one of the schedules in the neighborhood has a lower total early and tardy cost than the seed, go to step 3. If none of the schedules in the neighborhood has a lower total early and tardy cost than the seed, then if the stopping condition is met, stop; if the stopping condition is not met, change to another operator by setting d = d + l if d < k or by setting d = O if


d = k (k is an empirical integer parameter), and go to step 2 (try to move out of local optima).

Step 3. Select one of the schedules in the neighborhood which has a lower total early and tardy cost than the seed. Let this new schedule be the new seed and go to step 2.

Two aspects of this new heuristic procedure need to be clarified. The first is the stopping condition. In the traditional neighborhood search approach, search stops when local optima are reached. In the new heuristic procedure, search can continue by changing to another operator when local optima are reached. Two types of stopping conditions can be considered in this new heuristic procedure. One stopping condition is to set a maximum search time for the heuristic procedure. The other condition is to stop search when it gets trapped in local optima and changing to another operator still cannot help break out of local optima.

The second aspect to consider is the choice of k. k is an empirical parameter that depends on a specific scheduling problem. Generally, the choice of k should reflect the average number of jobs that clash in the initial schedule. Therefore, when job due dates are close together and the lead times of jobs are not long, many jobs will clash and a large k should be used; when job due dates are evenly distributed, few jobs will clash and a small k should be used.

5. Implementation of the branch-and-bound algorithm

In this section, we briefly discuss the implementation of our branch-and-bound algorithm. First, we use the new heuristic procedure discussed above to produce an upper bound on the optimal schedule cost of ( P ) before we start to search the tree. Motivated by Lemmas 3.2 and 3.3, when the tardy factor of a problem is large ( > 0.5), we adopt a forward-sequencing branching rule, where a node at level k of the search tree corresponds to a sequence with k jobs fixed in the first k positions. When the tardy factor of a problem is small (_< 0.5), we adopt a backward-sequencing branching rule, where a node at level k of the search tree corresponds to a sequence with k jobs fixed in the last k positions. We

use four sequencing tests to decide whether a non- root node should be fathomed or not. In the first test, the 4 dominance roles discussed in Section 2 are applied. In the second test, the adjacent pairwise interchange technique is used at the current node to compare the cost of the last two jobs in the partial sequence with the corresponding cost when the two jobs are interchanged. If the former cost is larger, the node should be fathomed. In the third test, the dominance principle of dynamic programming is used. Finally, if the node is not fathomed by the three tests above, a lower bound is calculated for this node. If the lower bound plus the associated partial schedule cost of the node is larger than the current best upper bound, the node is fathomed. We use the first-depth strategy to search the tree, and branch from the node with the smallest value of the associated partial schedule cost plus the associated lower bound.

6. Computational results

The branch-and-bound algorithm has been tested on problems with up to 50 jobs, whereas the heuristic procedure has been tested on problems with up to 3 000 jobs. Problems are generated as follows. For each job j, an integer processing time p j, earliness penalty hi, and tardiness penalty wj are generated from the uniform distribution [1,10]. Let P be the sum of processing times of all the jobs. For each job j, an integer due date is generated from the uniform distribution [P(1 - T - R/2), P(1 - T + R/2)] , where T is the tardy factor, set at 0.0, 0.2, 0.6, 0.8 and 1.0, and R is the range factor, set at 0.2, 0.4, 0.6 and 0.8. For each combination of parameters, two problems are generated.

The branch-and-bound algorithm and the heuristic procedures are coded in C and run on a PMAX- 5000/2000 computer. In the computational results reported below, Heuristic 1 represents the new heuristic procedure developed in Section 4. Heuristic2 refers to the filtered beam search procedure (Ow and Morton [17]) with filtered width set at 6 and with beam width set at 5, and Heuristic3 refers also to the filtered beam search procedure with filtered width and beam width set at 3 and 2, respectively. Heuris- tic4 denotes the neighborhood search approach where


the operator is the all pairwise interchange and the initial schedule is the same as that in Heuristic l. In addition, the lower bound mentioned below refers to the bound generated by Dual l and Dual2 on the optimal schedule cost of (P) .

Table 3 contains the computational results for the lower bound procedure of (P ) and the branch-and- bound algorithm. The results include the average percentage deviation of the lower bound from the optimum (AB), the average optimal solution time in seconds (AT), and the average number of nodes in the search tree (AN). Whenever a problem cannot be solved within 100 CPU seconds, computation is stopped. Although the average lower bound is within about 15% of the optimum, the lower bound procedure is extremely efficient. Therefore, the branch- and-bound algorithm appears capable of solving problems with up to 50 jobs. During the computational study, we have found that problems with larger values of R seem harder to solve than ones with smaller values of R, and problems with T = 0.8 appear less difficult to solve than ones with T = 0.2. This finding is consistent with that by Abdul-Razaq and Potts [ 1 ].

Table 3 also contains the computational results for Heuristicl and Heuristic2, including the average computation time in seconds (AT) and the average percentage deviation of the heuristic solution from the optimum (AD). The average computation time for Heuristicl is much less than that for Heuristic2; the average percentage deviation for Heuristicl is also less than that for Heuristic2. So Heuristicl

Table 3 Computational results for the lower bound procedure of (P) , branch-and-bound algorithm, Heuristicl, and Heuristic2

the

Branch-and-Bound Heuristic 1 Heuristic2

n AB AT AN AD AT AD AT

15 12.2 1.20 300 0.17 0.05 0.42 0.15 20 11.4 3.40 950 0.49 0.10 1 . 1 6 0.38 25 10.9 15.8 5210 0.51 0.18 0.96 0.72 30 17.8 a 65.7 a 27100 a 0 . 8 1 0.42 1.1 1.13 40 16.9 b 80.7 b 35000 b 0.65 0.86 1.24 2.78 50 15.8 c 95.6 c 42000 c 0.91 1.86 2.12 4.20

The results in Table 3 represent the average value over 40 problems for each n. Within the time limit of I00 seconds, a. b and c indicate that 7, 11, and 18 problems were not solved, respectively.

Table 4 Computational resultsfor Heuristicl, Heuristic3, and Heuristic4

Heuristic 1 Heuristic3 Heuristic4

n AD AT AD AT AD AT

100 14.5 9.1 16.8 15.4 16.2 12.4 500 13.9 28.5 17.8 547.3 15.4 43.5

1000 17.3 45.8 20.8 1456.3 19.4 72.6 2000 15.7 90.1 21.7 2567.3 17.4 135.4 3000 15.1 178.4 22.9 3789.2 18.9 245.6

The results in Table 4 represent the average value over 40 problems for each n.

dominates Heuristic2 in terms of both solution efficiency and quality for problems with up to 50 jobs.

Table 4 reports for Heuristic l, Heuristic3, and Heuristic4 the average computation time in seconds (AT), and the average percentage deviation of the heuristic solution from the lower bound (AD) for large scheduling problems. Heuristic2 is not considered here because it needs excessive solution times for large problems. The average computation time and the average percentage deviation for Heuristic l are the smallest among three heuristics. As indicated in Table 3, the average percentage deviation of the lower bound from the optimum is about 15%. So the solutions from Heuristicl are typically optimal or near optimal since the average percentage deviation of the Heuristicl solution from the lower bound is approximately 15%. Therefore, even for large problems, Heuristicl is not only efficient but also robust in producing optimal or near optimal solutions, showing superiority over Heuristic3 and Heuristic4 with respect to both solution efficiency and quality.

7. Conclusions

In this paper, we have presented a branch-and- bound algorithm for the single machine early/tardy scheduling problem. The algorithm, based on the very efficient lower bound procedure developed by using Potts and Van Wassenhove's [20] multiplier adjustment method, has been used to solve to optimality problems with up to 50 jobs, doubling the size of problems that can be solved by the known branch- and-bound algorithms. This result is compatible with the result obtained by Potts and Van Wassenhove

G. Li / European Journal o f Operational Research 96 (1997) 546-558 557

[20] for the weighted tardiness problem, where the branch-and-bound algorithm based on the multiplier adjustment method outperforms the algorithms based on the subgradient approach or dynamic programming. We have also proposed a heuristic procedure that is based on the neighborhood search approach. The heuristic procedure uses a set of small neighborhood operators and changes to alternative operators to break out of local optima. The heuristic procedure has been tested with a large number of problems with up to 3 000 jobs. Computational results show that it dominates the known heuristics for this problem in terms of both solution efficiency and quality.

Acknowledgements

The author sincerely thanks professors S. Ra- jagopalan, G.L. Thompson and Alex Zhang for their thoughtful comments on the paper, especially for their effort in helping me revise the paper.

Appendix A

Theorem 3.2. Procedure Duall optimally solves (D1); i.e., A* obtained from Duall is the optimal solution to (D I), where A* has the following structure:

A~ = 0 if I ~ S , , (7)

A] =hi i f jES l , (8)

* ~ A * ;tj ~-I(Pj/Pj-I) i f j ~ S ~ a n d j> 1 (9)

Proof. In procedure Duail, S~ can be regarded as an ordered integer set {s k . . . . . s~} with its elements in decreasing order of their values. It is clear that A* is feasible to (D~).

To establish (8) and (9), we first prove by contradiction that Aj+! = Aj (pj+ J p ) for j = s k + 1 . . . . . n. Suppose that m is the largest integer such that A,~+ iva A~,(p,,+ JPm), where m ~ {s k + 1 . . . . . n}.

Then A m + l / P m + l = . . - = A * , / p , . Let / 3 = A~,,+ l /P~+t- A~/p~. From constraint (3) of (Dr), /3 > O. So we have

ZI = Aj E j = E )~j E j -~- E j = l j = l j = s , + l

= E A;Ej+ A;E~+ j= 1 j=sk+ l

= E A~e~+ Aje~ j = 1 j = s k + 1

+ ~ (h*,,/p,,+/3)pjEj. j = m + l

Since E~=,,+ ~ pjE~ < 0 and /3 > O,

a~ej_ E Ajej+ a~ej j= 1 j= I j ~ s k + l

+ E (V#pm)p:. j=rn+ l

So we can get another feasible solution A as follows:

j j = {(A~/p, , )pj , j E { m + 1,. . . . . n},

A;, j ~ {1 . . . . . m}, , k

Solution A has a larger objective function value than the optimal solution A*, a contradiction. So Ai+ 1 = A t ( pj+ J p ) for j= s k + 1 . . . . . n. Next, we prove by contradiction that A; = hj for j = s k. Sup- pose that A* = 'k ~'s, < h,,. Then

Aje~= E a~e~+ A~e~ j = l jffi 1 jffis,

s,-- 1

= E A]Ej+ (TLk/p.~,)pjE; j= 1 j = s ,

s k - 1

= E A;e~ + (,~.,/p.,) p : . j= 1 j = s ,

Since E'~ A* 7r,~ < h,,, j=s~p~Ei > O a n d , , = ~

i . , l . i ) A t Ej < ~_, A i E i + (h,~/p,~) pjEj. j = l j = l j = s t

Aj E~

A; ej j = m + l


Aj E j = j = l

$ 1 - Since ~j=j lpjEj < O, the maximum r t * E j= l Aj Ej is achieved when A~ = 0. []

This means we can find another feasible solution that follows

= f (h~k/ps,) pj, j E { s k . . . . . n}, Af , j ~ {1 . . . . . s , - 1}.

Again, A has a larger objective function value than the optimal solution A*, a contradiction. So Aj.* = hj for j = s,.

Repeat the above process for j = I . . . . . s , - 1, hence establishing (8) and (9).

Finally, we need to establish Eq. (7). I f 1 ~ S t, we have

S I - - 1 n

E ;,;Ej+ E jEj" j= 1 j f s l

s I - 1

E ( A t / P l ) P . i E j + ~-~ A ] E j . j = 1 j = s I

value of

References

[1] Abdul-Razaq, T., and Potts, C.N., "Dynamic programming state-space relaxation for single machine scheduling", Jour- nal of Operations Research Society 39 (1988) 141-152.

[2] Azizoglu, M., Kondakci, S., and Kirca, O., "Bicriteria scheduling problem involving total tardiness and total earliness penalties", International Journal of Production Eco- nomics 23 (1991) 17-24.

[3] Baker, K.R., Introduction to Sequencing and Scheduling, Wiley, New York, 1974.

[4] Baker, K.R., and Scudder, G.D., "Sequencing with earliness and tardiness penalties: a review", Operations Research 38 (1990) 22-57.

[5] Bilde, O., and Krarup, S., "Sharp lower bounds and efficient algorithms for the simple plant location problem", Annals of Discrete mathematics" 1 (1977)79-88.

[6] Fisher, M.L., "A dual algorithm for the one-machine scheduling problem", Mathematical Programming 11 (1976) 229-251.

[7] Fisher, M.L., "The Lagrangian relaxation method for solving integer programming problems", Management Science 27 (1981) 1-18.

[8] Fry, T.D., Armstrong, R., and Blackstone, J., "Minimizing weighted absolute deviation in single machine scheduling", AIIE Transaction 19 (1987) 445-450.

[9] Geoffrion, A.M., "Lagrangian relaxation and its uses in integer programming", Mathematical Programming Study 2 (1974) 82-114.

[10] Hariri, A.M.A., and Potts, C.N., "An algorithm for single machine sequencing with release dates to minimize total weighted completion time' ', Discrete Applied Mathematics 5 (1983) 99-109.

[11] Held, M., Wolfe, P., and Crowder, H., "Validation of subgradient optimization", Mathematical Programming 6 (1974) 62-88.

[12] Karp, R.M., "Reducibility among combinatorial problems", in: Miller, R.E. and Thatcher, J.W. (eds.), Complexity of Computer Computations, Plenum Press, New York, 1972, 82-103.

[13] Korman, K., "A pressing matter", Video, February (1994) 46-50.

[14] Landis, K., "Group technology and cellular manufacturing in the Westvaco Los Angeles VH department", Project Report in IOM 581, School of Business, University of Southern California, 1993.

[15] Lawler, E.L., "A "pseudopolynomial' algorithm for sequencing jobs to minimize total tardiness", Annals of Discrete Mathematics 1 (1977) 331-342.

[16] Lenstra, J.K., Rinnooy Kan, A.H.G., and Brucker, P., "Com- plexity of machine scheduling problems", Annals of Dis- crete Mathematics 1 (1977)343-362.

[17] Ow, P.S., and Morton, E.T., "The single machine early/tardy problem", Management Science 35 (1989) 177-191.

[18] Potts, C.N., and Van Wassenhove, L.N., "A decomposition algorithm for the single machine total tardiness problem", Operations Research Letters 1 (1982)343-362.

[19] PoUs, C.N., and Van Wassenhove, L.N., "An algorithm for single machine sequencing with deadlines to minimize total weighted completion time", European Journal of Opera- tional Research 12 (1983) 379-387.

[20] Potts, C.N., and Van Wassenhove, L.N., "A branch and bound algorithm for the total weighted tardiness problem", Operations Research 33 (1984) 363-377.

[21] Rinnooy Kan, A.H.G., Lageweg, B.J., and Lenstra, J.K., "Minimizing total costs in one-machine scheduling' ', Opera- tions Research 23 (1975) 908-927.

[22] Sidney, J., "Optimal single-machine scheduling with earliness and tardiness penalties", Operations Research 25 (1977) 62-69.

[23] Smith, W.E., "Various optimizers for single-stage production", Naval Research Logistics Quarterly 3 (1956) 59-66.

[24] Soroush, H.M., and Fredendall, L.D., "The stochastic single machine scheduling problem with earliness and tardiness costs", European Journal of Operation Research 77 (1994) 287-303.

[25] Yano, C.A., and Kim, Y.D., "Algorithms for a class of single-machine weighted tardiness and earliness scheduling problems", European Journal of Operation Research 52 0991) 167-178.

Documents

Single machine earliness and tardiness scheduling