Single machine scheduling with discretely controllable processing times

ELSEVIER

Operations Research Letters 21 (1997) 69-76

Single machine scheduling with discretely controllable processing times Zhi-Long

C h e n a'*, Q i n g L u b, G u o c h u n

Tang c

aDepartment of Civil Engineering & Operations Research, Princeton University, Princeton, NJ 08544, USA bDepartment of Decision Sciences, National University of Singapore, 10 Kent Ridge Crescent, Singapore 0511, Singapore cDepartment of Management, Shanghai Second Polytechnic University, Shanghai 200041, People's Republic of China

Received 1 April 1995; revised 1 December 1996

Abstract In the field of machine scheduling problems with controllable processing times, it is often assumed that the possible processing time of a job can be continuously controlled, i.e. it can be any number in a given interval. In this paper, we introduce a discrete model in which job processing times are discretely controllable, i.e. the possible processing time of a job can only be controlled to be some specified lengths. Under this discrete model, we consider a class of single machine problems with the objective of minimizing the sum of the total processing cost and the cost measured by a standard criterion. We investigate most common criteria, e.g. makespan, maximum tardiness, total completion time, weighted number of tardy jobs, and total earliness-tardiness penalty. The computational complexity of each problem is analyzed, and pseudo-polynomial dynamic programming algorithms are proposed for hard problems. © 1997 Elsevier Science B.V. Keywords: Single machine scheduling; Discretely controllable processing times; NP-hardness; Dynamic programming

I. Introduction Scheduling problems with controllable processing times have received increasing attention during the last decade. Work on this area was initiated by Vickson [18, 19], and Van Wassenhove and Baker [17]. For a survey of this area till 1990, the reader is referred to [13]. Recent results include [20, 14, 2,16, 4-7]. It was assumed in most of the above papers that the processing time of a job is continuously controllable from its normal length to its minimum

* Corresponding author.

possible length, i.e. the actual processing time of a job can be controlled to be any number in a specific interval. This assumption is valid for some practical situations. For example, in a job shop environment where the processing of jobs is controlled by the machine speed which depends on the amount of a divisible resource (e.g. electricity) allocated and hence can vary continuously from its normal speed to its maximum possible speed, the possible processing time of a job can be controlled to be any number in the interval corresponding to the speed interval of the machine. While in another job shop where the machine consists of a main facility and several auxiliary facilities (e.g. support devices) and its speed is determined by the pattern of the

0167-6377/97/$17.00 © 1997 ElsevierScienceB.V. All rights reserved PII S0 1 67-63 77(97)000 1 0-2

70

Z-L. Chen et al. / Operations Research Letters 21 (1997) 69-76

auxiliary facilities used, the machine can only have a finite number of speeds because there are a limited number of possible patterns of the auxiliary facilities. Under such a situation, the possible processing time of a job can only be one of a few specified lengths, for instance, two possible lengths with respect to the case where the auxiliary facilities have two patterns. For another example, in a manufacturing system where job processing times depend on the units of an indivisible resource (e.g. labor) allocated, job processing times can only have finitely many (up to the maximum units of the resource) possibilities. The continuous model used in the above-cited literature does not fit these situations where processing times are only discretely controllable. The aim of this paper is to introduce a discrete model to handle these situations. The discrete model can be formally described as follows. We are given a set of jobs N = { 1, 2 . . . . . n} to be processed on a machine. Each job j ~ N has k (k ~> 1 and given) possible processing times: with a j l 2> aj2 > ... > ajk, where ajl is called the normal processing time and ajk the minimum possible processing time of job j. A processing cost cji is associated with each possible a j l , aj2, ... ,ajk

processing time aji (i = 1, 2,...,k). It is assumed that 0 ~< c jl < cj2 < ... < Cjk. This assumption is reasonable since more resource (e.g. a faster speed of the machine, or more units of labor) and hence higher costs are needed to achieve smaller processing times. Let xj denote the actual processing time of job j in a schedule; then x~ must be one of the possible processing times associated with job j, i.e. x j ~ {a~, a j2 . . . . , a~k}. A processing cost c~i is incurred if the actual processing time of job j is xj = aj~. To the best of our knowledge, there is only one published paper [7] dealing with the discrete model. Daniels and Mazzola [7] considered an NP-hard flow shop scheduling problem where job processing times are discretely controllable through the allocation of a limited amount of resource and the objective is to minimize the makespan. They gave an optimal algorithm and a heuristic for solving the problem. In this paper, we investigate a class of single machine scheduling problems with controllable processing times under the discrete model. The objective of each problem is to minimize the sum of

the total processing cost and the cost measured by a standard criterion. We examine each of the common criteria: makespan, maximum tardiness, total completion time, weighted number of tardy jobs, and total earliness-tardiness penalty. We clarify the complexity of each problem. To facilitate the presentation, we define the following notation: r~ ready time of job j dj due date of job j Cj completion time of job j in a given schedule Ej max(0,d~ - Ci), earliness of job j in a given schedule Tj max(0, C~ - dj), tardiness of job j in a given schedule U~ 1 if Cj > dj and 0 otherwise c~ unit cost of earliness /3 unit cost of tardiness wj cost if job j is tardy, i.e. Cj > d~ lji(xj) 1 if xj = a~i and 0 otherwise (i = 1, 2 .... , k) TPC Y~j~N~=lcjilji(x~), total processing cost in a given schedule C~,ax maxiEN{Cj}, makespan of a given schedule T~,ax max~N {T~}, maximum tardiness of a given schedule Suppose that all the parameters are nonnegative integers and any preemption is not allowed when processing. For ease of problem formulation, we use the three-field problem classification "1"[" (introduced by Graham et al. I-9]) to define a machine scheduling problem. The first field represents the machine environment, the second field describes the scheduling constraints, and the third field gives the objective function. We use the following notation in the second field. "rj" indicates that job ready times are not all equal, "d~ = d" indicates that jobs have a common due date, and "dj = d > D" indicates that jobs have a common and unrestrictively large due date (e.g. d r - d >1 ~ j~N a j l ) where D represents a large enough number and has no other meaning. See 1-3] for a discussion of "restrictive" and "unrestrictive" versions of common due date scheduling problems. Finally, "cm" and "dm" denote the models where processing times are, respectively, continuously controllable and discretely controllable. Now, we can state the seven problems we consider in this paper as follows, where P4' is the

Z-L. Chen et al. / Operations Research Letters 21 (1997) 69-76

special case of P4 with dj = d, and P5' is the special case of P5 with dj = d and wj = w. (P1) lldmly~Cj + TPC. (P2) 1 Idj = d > D, dmla ~ Ej + fl y~ Tj + TPC. (P3) 1 Irj, dml Cm,x + TPC. (P4) 1 Idml Tmax + TPC. (P4') lid j - d, dmlTm~x + TPC. (P5) l l d m l y w i U j + TPC. (P5') l[dj - d, d m l w E Us + TPC. Note that, through a suitable scaling of the processing costs, the objective functions in the above problems are capable of capturing the trade-off between traditional scheduling performance measures and expenditure on resources. In Section 2, we show that P1 and P2 are polynomially solvable. In Section 3, we prove that P3,P4' and P5' are all NP-hard. We then give pseudopolynomial dynamic programming algorithms in Section 4 for solving the hard problems P3, P4 and P5. This implies that P3,P4,P4',P5 and P5' are all NP-hard in the ordinary sense. Note that in the following sections, when we refer to problems with controllable processing times under the continuous model, as often assumed in the literature, we assume that the total processing cost TPC = ~j~N fj(xj) with all f~(. ) being nonincreasing linear functions.

2. Polynomial solvability of P1 and P2 The problems lll~wjCj and l[di==-d>D] ~ Ej + fl~ Tj (with uncontrollable processing times), and the problems 1 ]cml 5~ Cj and 1 Idj = d > D, cmlct~Ej + fly. T i (with continuously controllable processing times) are all polynomially solvable. It is well-known that the weightedsmallest-processing-time-first (WSPT) sequence is optimal for 1 I[~wiC j. For the other three problems, see 1-15, 18, 14], respectively. The complexity of the problem: l l c m l E w i C j + TPC remains open 1-13] despite that its uncontrollable version: l ll~wjCj is extremely easy. When the given common due date is restrictive, the problem lldj-dlct~Ej+fl~Tj is NP-hard [10], and hence the problems 1 ]dj = d, cm ]ot~, Ej + f l ~ T j + TPC and l l d j = d , d m l c t Z E j + f l Z T j + TPC are also NP-hard.

71

In this section, we show that both problem PI: ltdmp~ Cj + TPC, and problem P2: lrdj - d > D, dml~ K Ej + fl 5" Tj + TPC are polynomially solvable by formulating them as n × n assignment problems.

2.1. Assignment problem formulation for P1 Consider problem PI: 1 IdmlY, Cj + TPC. There are n positions in the schedule, each of which must contain exactly one job. If job l is scheduled at position m in a schedule, then the contribution made by job l to the total objective function is k

fi,,(xt) = (n - m + 1)xt + ~ ctilli(xt), i=1

where the first term is the contribution to the total completion time and the second term is that to the total processing cost. To minimize f/,.(xt), one should set the actual processing time of job l, xt, to be all for some 1 ~< i ~< k such that f t m ( a u ) = Vt,n, where

vt,, = min {ftm(Xl) lXt e {a, =

min

.....

alk }

{(n--m+l)atj+czj}.

} (1)

j ~ { 1 . . . . . k}

It follows that the cost incurred by assigning job l at position m, and then selecting its actual processing time optimally, is exactly v~,, given by (1), independent of the other jobs. This permits us to formulate problem P1 as the following n x n assignment problem:

/=1 m=l

~ytm=

1, m = 1 , 2 . . . . . n,

(3)

/=1

• Ylr,=l

l-----1,2, ... ,n,

(4)

m=l

where Y~,, = {~

if job 1 is scheduled at position m't5~tJ otherwise

and vt,,, are given by (1).

Z-L. Chen et al. / Operations Research Letters 21 (1997) 69 76

72

The above n × n assignment problem can be solved in an O(n 3) time (see, e.g., [1]). Hence, we have shown that P1 can be solved in an O(n 3) time. However, we do not known whether its weighted version: l ldml~ w~Cj + T P C is polynomially solvable or NP-hard. We conjecture that this problem is NP-hard (even when k = 2).

The first terms in (6) and (7) are the contributions, respectively, to the total earliness penalty and to the total tardiness penalty. The second terms in (6) and (7) are the contributions to the total processing cost. Define min {(m - 1)ctat; + clj} j~{l ..... k} L'lm

2.2. Assignment problem formulation for P2 Clearly, in any optimal schedule for problem P2: 1 Id~ = d > D, dm [~ Y, Ej + fl ~ Tj + TPC, there is no inserted idle time between jobs. (However, idle time at the beginning of the schedule may exist). The following lemma states an important property about the optimal solution for the problem. Lemma 1. There exists an optimal schedule for P2 such that the hth job completes at common due date d, where h = F nfl/(7 + fl) ~, and Fx qdenotes the least integer no less than x. Proof. In the case with uncontrollable processing times, Panwalker et al. [15] proved this property for the problem I [ d ~ = = - d > D I e ~ E ~ + ~ y T j . Since the value of h is independent of the job processing times, this property is also valid for P2. [] Thus, there exists an optimal schedule for P2 in which exactly h = [- nfl/(~ + fl)~ jobs are either early or completed at the due date and n - h jobs are tardy. As in Section 2.1, we assume that there are exactly n positions on the machine, numbered 1,2 .... ,n. Suppose that in a schedule, job l is scheduled at position m. There are two cases. If m ~< h, then job I is early and the contribution made by it is k

f//,.(xl) = (m - 1)~xl + ~" culli(Xl).

(6)

i=1

If m > h, then job l is tardy and the contribution made by it is k

fl,,(x,) = (n - m + 1)fix, + ~ c,illi(x,). i=1

(7)

rain { ( n - m + j~{1..... k}

1)[3at~+clj}

if m ~< h, if m > h .

(8) Then to minimize the contribution of job l (if it is at position m), one should set xt = au for some 1 ~< i ~< k such that f~,,(a,) = V~m.By the same argument as in Section 2.1, we can formulate P2 as the assignment problem defined by (2)-(5) except that V~mis now given by (8). Hence, problem P2 can be solved in an O(n 3) time.

3. NP-hardness of P3, P4' and P5' In the case with uncontrollable processing times, it is well known that the smallest-ready-time-first (SRT) schedule, and the earliest-due-date-first (EDD) schedule are optimal, respectively, for the problem l l r j l C m a x and for the problem l i l T . . . . and the problem 1 ]l~ Uj is polynomially solvable by Moore's algorithm [12]. But the weighted version of the last problem: 1 ]lS wJ Uj is NP-bard even with a common due date [11]. In the case with continuously controllable processing times, the problems 1 Ir j, cml Cmax + TPC, and 1 Icml Tm,x + T P C are both polynomially solvable (see [13, 19], respectively), while the problem 1 Icml Y.wj Uj + T P C becomes NP-hard even with dj - d and wI = w [-6]. Surprisingly, under the discrete model, problems P3: llrj, dm[Cm,x + TPC and P4: lldmLTm,x + T P C become NP-hard even with dj - d for P4. The NP-hardness proofs for P3 and P4' (i.e. P4 with d r = d) are given in this section. Also, problem P5': lldj = d, dmlwY~ Ui + T P C (a special case of P5) is proved to the NP-hard here. Note that when jobs are simultaneously available, the problem l ldmlCmax + T P C can be easily solved by sequencing jobs in an arbitrary order and letting

73

Z-L. Chen et al. / Operations Research Letters 21 (1997) 69-76

CL(~Z) ~< r~+ l, implying that

Xj = aji where i is the index such that aji + cji =

Hence

min{ajt + cjtll = 1, ... ,k}. For all proofs, we use the NP-complete problem: K N A P S A C K (see, e.g., [8]) for a reduction. An instance of K N A P S A C K problem can be stated as follows: K N A P S A C K : Given a set S = {1,2 . . . . . s} of s objects, a cost coefficient pj ~ Z + and a weight qj ~ Z + for each object j ~ S, and two parameters A ~ Z + and B e Z+, is there a subset T of S such that ~j~TPJ ~ A and ~j~TqJ ~ B?

zc, C,nax(rc) = r~+ l + Xs+ l = 2 + n + Q ( R - A). On

Let R = ~ j , s PJ and Q = Y.j~s qi. To avoid trivial cases, we assume that R > A and Q > B.

Theorem 1. P r o b l e m P3 is N P - h a r d . Proof. Given an instance of K N A P S A C K , we construct the corresponding instance of P3 as follows: P3: Job set N = S w { s + 1}; k = 2 possible processing times for each job; for j E S, let rj = 0, aja = 1 + Qp~,

aj2 = 1,

Cjl ~- O,

Cj2 = qj;

for

j=s+l, let r ~ + I = n + Q ( R - A ) , a~+1,1=2, a s + l , 2 = 1, c~+1,1=0, c ~ + x , 2 = 2 + n + B + Q R ; threshold y = 2 + n + B + Q ( R - A). We prove the theorem by showing that there exists a feasible schedule for the instance of P3 with the objective function no more than the threshold y if and only if there exists a solution to the instance of K N A P S A C K . (1) " I f " : Let T be a subset of S such that ~ j ~ r p j >~ A and ~jETqJ ~ B. Construct a schedule for the instance of P3 as follows. Let the actual job processing times be: xj = aj2 for each j ~ T, xi=ail for each i t S \ T , and X~+l=a~+l,a. Schedule jobs of S in an arbitrary order, followed by job s + 1. Denote the completion time of the last job of S in zc by Ce(r0. Clearly, =

= y, a . + jES

j~T

j~Sk T

<<.n + Q ( R - A).

Z j~S\T

aj,

the makespan of

the other hand, the total processing cost in n is T P C = ~~j~TCj2 = ~ , j e T q j ~ B. So, the objective function of n is F(n) = Cmax(n) + T P C ~< 2 + n + B + Q ( R - A) = y. (2) " O n l y / f " : We prove this part by contradic-

tion. Suppose that there is no solution to the instance of K N A P S A C K , we need to prove that there is no feasible schedule for the instance of P3 with the objective function no more than the threshold y. Given any feasible schedule for the instance of P3. Without loss of generality, suppose that job s + 1 is scheduled last. If x~+ 1 = as+ 1,2, then the processing cost incurred by job s + 1 is Cs+ 1,2 = 2 + n + B + Q R > y, implying that the objective function of the schedule F > y. On the other hand, if x~+l = as+l.1, we define T = { j ~ S l x j = aj2}. Since there is no solution to the instance of K N A P SACK, we have two cases: Case 1: ~ j E r P j ~ A, and ~ r q J > B. In this case, the total processing cost T P C = yq~rcj2 = ~ i ~ r q i > B. Clearly, the makespan of the schedule Cmax >>-r~+ l + X,+ I = 2 + n + Q ( R - A). Thus, the objective function is F = Cmax + T P C > y. Case 2: Y q ~ r P j < A, and ~ i ~ r q i ~< B. In this case, the completion time of the last job in S is CL = Z j ~ T a j 2 + Z j ~ s \ r a j l = n + Q ( Z j ~ s \ r P J ) = n + Q R - Q(Y~j~rPJ) >>"n + Q ( R - A + 1) > rs+a.

The makespan is then Cmax = CL + X~+I /> 2 + n+Q+Q(R-A)>y since we assume Q > B . This means that the objective function F > y. []

Theorem 2. Problem P4' is N P - h a r d . Proof. Given an instance of K N A P S A C K , we construct the corresponding instance of P4' as follows: P4': Job set N = S; let the c o m m o n due date d = n + Q ( R - A); k = 2 possible processing times for each job; for each j E S, a~l = 1 + Qpj, aj2 = 1, cjl = 0, cj2 = qj; threshold y = B. Similar to the proof of Theorem 1, we prove the result here by showing that there exists a feasible schedule for the instance of P4' with the objective function no more than the threshold y if and only if there exists a solution to the instance of K N A P SACK.

Z-L. Chen et al. / Operations Research Letters 21 (1997) 69-76

74

(1) "If": Let T be a subset of S such that ~jETPJ >/ A and ~ j E T q J ~ B. Construct a schedule

a for the instance of P4' as follows. Let the actual job processing times be: xj = aj2 for each j ~ T, and xi = a i l for each i ~ S \ T. Schedule jobs of S in an arbitrary order. As in the proof of Theorem 1, we can prove that the completion time of the last job in a is CL(a) = n + Q ( R -- ~,

pj) ~ n + Q(R - A).

jET H e n c e , CL(O") ~ d, implying that there is no tardy job in a. Thus, the objective function of a is equal to the total processing costs T P C = ~ E T C j 2 - - Y.jETqi <<"B = y. (2) " O n l y / f " : It can be proved easily using the same argument as in the second part of the proof of Theorem 1. The first case is exactly the same. In the second case, the completion time of the last job C L ~ n + Q ( R - A + 1) = Q + d, implying that Tmax >t Q > B = y, and hence the objective function of the schedule F > y. []

Theorem 3. Problem P5' is NP-hard. Proof. Given an instance of KNAPSACK, we construct the corresponding instance of P5' as follows: P5': Job set N = S; let the common due date d = n + Q ( R - A), the identical weight w = 2B; k = 2 possible processing times for each job; for each j e S, a jl = 1 + Qpj, a j2 1, cjx = O, c~2 =- qj; threshold y = B. Noticing the fact that since w = 2B in the instance of P5', any schedule with at least one tardy job must have an objective function greater than y, we can prove this theorem easily using the same argument as in the proof of Theorem 2. [] =

4. Dynamic programming algorithms for P3, P4 and P5 In this section, we present two pseudo-polynomial dynamic programming algorithms, one for solving P3: l[r~,dm[Cmax + T P C , the other for

solving P4: 1Ldm[Tmax+TPC and P5: lldml y~ wj Uj + TPC. The following result are straightforward and we thus omit the proofs. Remark 1. The smallest-ready-time-first (SRT) order is an optimal sequence for P3. Remark 2. The earliest-due-date-first (EED) order is an optimal sequence for P4. Remark 3. There exists an optimal schedule for P5 satisfying the following properties: (I) Each tardy job is processed after all on-time jobs (a job j is said to be on-time if C~ ~< dj). (II) On-time jobs are sequenced in the E D D order, tardy jobs are with an arbitrary order. (III) The actual processing time of any tardy job is its normal processing time, i.e. xj = aj~ for any tardy job j. 4.1. A D P algorithm f o r P3

By Remark 1, we design in the following a straightfoward dynamic programming algorithm which iteratively constructs a schedule by assigning an unscheduled job with the smallest ready time to the last position of the current partial schedule.

Algorithm 1 (al) Reindexjobs such that rl ~ r2 ~< "'" ~< r,. Let /7max maxj~N {rj + ~ 7 = j a n } . Note that tmax is the maximum possible makespan of a schedule. (bl) Let f ( j , t ) the minimum total processing cost of a partial schedule containing the first j jobs, 1,2, ... ,j, given that the completion time of job j is no more than t. (cl) Recursive relations: For j = 2,3 . . . . . n and =

t = 0, 1, ... ,trnax:

f ( j , t ) = m i n { g , ( j , t ) l i = 1 . . . . . k},

xj = a~, if f ( j , t) = Yi(J, t),

Z.-L. Chen et al. / Operations Research Letters 21 (1997) 69-76

where

gi(j, t)

problem P5, then we show that this algorithm can also be used to solve problem P4. By Remark 3, for problem P5, each job j e N has k + 1 possible cases: j can be on-time and its actual processing time can be one of the k specified numbers, i.e. xj = a jl (i = 1,2, ..., or k); job j can also be tardy and then its actual processing time must be ajl. Based on this observation, we now present a dynamic programming algorithm for problem P5. Similar to Algorithm 1, the algorithm iteratively constructs a schedule, assigning an unscheduled job with the smallest due date either to the last position of the current ontime jobs or to the last position of the current tardy jobs.

=

f ( j - 1, t - aji) + cji if t >>.rj + a~g, otherwise. (dl) Initial values: For t = 0, 1.... , tmax:

f(l't)=Ic~ (cl I

if t>~r~ + a l ~ , if rl + all <~ t < rl + al.i-1, and 2 <~ i <~ k, if t < r l + a ~ k ,

if f(1, t) = cli and 1 ~< i ~< k.

X 1 =ali

(el) An optimal solution can be obtained by computing min {f(n, t) + t[ t = 0 .... , t m a x } .

Algorithm2

Remark 4. The complexity of Algorithm 1 is O(kntm~x) since we are trying all possible values of j ( j = 1,2 .... ,n) and all possible values of t (t = 0, 1, ..., tma~), and the computation of f ( j , t) needs O(k) time for each possible state (j, t).

(a2) Reindex jobs such that dl ~< d 2 ~ " " ~ d,. Let drnax = max{dj[ j e N}. (b2) Let f ( j , t) =- the minimum total cost (weighted number of tardy jobs plus total processing cost) of a partial schedule containing the first j jobs, 1,2, ... ,j, given that the completion time of the on-time jobs in this partial schedule is exactly t. (c2) Recursive relations: For j = 2,3 .... ,n and t = 0, 1.... , dmax:

4.2. A DP algorithm for P4 and P5 In this subsection, we first propose a pseudopolynomial dynamic programming algorithm for

f(j,t) =

xj =

{mi

ajl ajl a jl

min { f ( j - n {1 .
f(1,t) = lWc~ + Cll

~ all (ali

f(j--

l,t) + cjl + w~}, if t <~dj, otherwise,

if t <<,dj and f ( j , t ) = f ( j - l , t ) + cjl +wj, if t <~dj, f ( j , t ) = f ( j - 1,t - a~i) + cji and 1 ~< i ~< k, otherwise.

(d2) Initial values: For t = 0, 1....

X1 =

l,t--aji) +cji},

75

,dmax:

if t -- O, if da ~> t = ali and 1 ~< i ~< k, otherwise,

if f(1, t) --- wx + C 1 1 , f(1,t) = cll or f(1, t) = 0% i f f ( l , t ) = c l i and 2~
(e2) An optimal solution can be obtained by computing min {f(n,t)l t = 0, ..., dmax}.

76

Z-L. Chen et al. / Operations Research Letters 21 (1997) 69-76

R e m a r k 5. The c o m p l e x i t y of A l g o r i t h m 2 is O(knd,nax), which can be shown by the same argum e n t as in R e m a r k 4. R e m a r k 6. A l g o r i t h m 2 can be used to solve p r o b lem P4 by the following way. I n p u t an instance of p r o b l e m P4. Let Zmax be the m a x i m u m tardiness of the E D D sequence u n d e r the n o r m a l processing times of the instance. T h e n Zmax is the m a x i m u m possible Tma x in an o p t i m a l schedule for the instance. N o w , for every integer z ~ [0, Zm,~], d o the following: (1) reset the due d a t e for each j o b j ~ N: d) = d r + z, a n d i n t r o d u c e a weight for each j o b : wy = ~ ; (2) solve this new instance by A l g o r i t h m 2. If the o p t i m a l objective function value is finite, then record the c o r r e s p o n d i n g o p t i m a l schedule. In this r e c o r d e d o p t i m a l schedule, there is no t a r d y j o b under the new due dates, a n d Tma x ~< z u n d e r the original due dates. After each possible z is e x a m ined, c o m p a r e all the r e c o r d e d schedules a n d the one with the smallest total cost Tma~ + T P C is then o p t i m a l for P4. T h e a b o v e p r o c e d u r e needs an O(kndmaxZmax) time since it calls A l g o r i t h m 2 once for each possible z = 0, I . . . . . Z m a x .

Acknowledgements This research was s u p p o r t e d in p a r t by the N a tional N a t u r a l Science F o u n d a t i o n of C h i n a when the first a n d the second a u t h o r s were in China. The a u t h o r s w o u l d like to t h a n k the associate e d i t o r a n d an a n o n y m o u s referee for their helpful suggestions on the earlier versions of this paper.

References [1] R.K. Ahuja, T.L. Magnanti, J.B. Orlin, Network Flows: Theory, Algorithms, and Applications, Prentice-Hall, Englewood Cliffs, N J, 1993. [2] B. Alidaee, A. Ahmadian, Two parallel machine sequencing problems involving controllable job processing times, European J. Oper. Res. 70 (1993) 335-341. [3] K.R. Baker, G.D. Scudder, Sequencing with earliness and tardiness penalties: a review, Oper. Res. 38 (1990) 22-36.

[4] T.C.E. Cheng, Z.-L. Chen, C.-L. Li, Parallel machine scheduling with controllable processing times, liE Trans. 28 (1996) 177-180. [5] T.C.E. Cheng, Z.-L. Chen, C.-L. Li, Single-machine scheduling with trade-off between number of tardy Jobs and resource allocation, Oper. Res. Lett. 19 (1996) 237 242. [6] T.C.E. Cheng, Z.-L. Chen, C.-L. Li and B.M.T. Lin, Scheduling to minimize the total compression and late costs, in submission. [7] R.L. Daniels, J.B. Mazzola, Flow shop scheduling with resource flexibility, Oper. Res. 42 (1994) 504-522. [8] M.R. Garey, D.S. Johnson, Computers and Intractability: A Guide to the Theory of NP-Hardness, Freeman, San Francisco, CA, 1978. [9] R.L. Graham, E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, Optimization and approximation in deterministic sequencing and scheduling: a survey, Ann. Discrete Math. 5 (1979) 287-326. [10] N.G. Hall, W. Kubiak, S.P. Sethi, Earliness-tardiness scheduling problems, II: deviation of completion times about a common due date, Oper. Res. 39 (1991) 847-856. [11] R.M. Karp, in: R.E. Miller, J.W. Thatcher (Eds.), Reducibility among Combinatorial Algorithms, Complexity of Computer Computations, Plenum, New York, 1972. [12] J.M. Moore, An n job, one-machine sequencing algorithm for minimizing the number of late jobs, Management Science 15 (1968) 334-342. [13] E. Nowicki, S. Zdrzalka, A survey of results for sequencing problems with controllable processing times, Discrete Appl. Math. 25 (1990) 271-287. [14] S.S. Panwalkar, R. Rajagoplan, Single-machine sequencing with controllable processing times, European J. Oper. Res. 59 (1992) 298-302. [15] S.S. Panwalkar, M.L. Smith, A. Seidman, Common due date assignment to minimize total penalty cost for the one-machine scheduling problem, Oper. Res. 30 (1982) 391-399. [16] M. Trick, Scheduling multiple variable-speed machines, Oper. Res. 42 (1994) 234-248. [17] L.N. Van Wassenhove, K.R. Baker, A bicriterion approach to time/cost trade-offs in sequencing, European J. Oper. Res. 11 (1982)48-52. [18] R.G. Vickson, Choosing the job sequence and processing times to minimize total processing plus flow cost on a single machine, Oper. Res, 28 (1980) 1155-1167. [19] R.G. Vickson, Two single machine sequencing problems involving controllable job processing times, AIIE Trans. 12 (1980) 258 262. [20] S. Zdrzalka, Scheduling jobs on a single machine with release dates, delivery times and controllable processing times: worst-case analysis, Oper. Res. Lett. 10 (1991) 519-524.