Single machine scheduling with discretely controllable processing times

E L S E V I E R Operations Research Letters 21 (1997) 69-76

Single machine scheduling with discretely controllable processing times

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

aDepartment of Civil Engineering & Operations Research, Princeton University, Princeton, NJ 08544, USA b Department of Decision Sciences, National University of Singapore, 10 Kent Ridge Crescent, Singapore 0511, Singapore

c Department 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 speci- fic interval. This assumption is valid for some prac- tical 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 Elsevier Science B.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 cont inuous 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: a j l , a j2 , . . . ,a jk with aj l 2> aj2 > . . . > ajk, where ajl is called the normal processing t ime and ajk the minimum possible processing t ime of job j. A processing cost cji is associated with each possible processing time aji (i = 1, 2 , . . . ,k) . It is assumed that 0 ~< c j l < 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~ l j i ( x j ) 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"[" (in- troduced 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 aj 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 71

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 I dj = d > D, dmla ~ Ej + fl y~ Tj + TPC. (P3) 1 I rj, dml Cm,x + TPC. (P4) 1 I dml Tmax + TPC. (P4') l id j - d, dmlTm~x + TPC. (P5) l l d m l y w i U j + TPC. (P5') l[dj - d, dmlwE U s + 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 l l l~wjCj and l[di==-d>D] ~ Ej + f l~ Tj (with uncontrollable processing

times), and the problems 1 ]cml 5~ Cj and 1 I dj = d > D, cmlct~Ej + fly. T i (with continuously controllable processing times) are all polynomially solvable. It is well-known that the weighted- smallest-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 cmlEwiCj + 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 l l d j - d l c t ~ E j + f l ~ T j 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 , dmlc tZEj+ f l Z T j + TPC are also NP-hard.

In this section, we show that both problem PI: l tdmp~ 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, . . . . . alk } }

= min { ( n - - m + l ) a t j + c z j } . (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

~ y t m = 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).

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

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 + TPC is polynomially solvable or NP-hard. We conjecture that this problem is NP-hard (even when k = 2).

2.2. Assignment problem formulation for P2

Clearly, in any optimal schedule for problem P2: 1 I d~ = 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 F x qdenotes the least integer no less than x.

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 j~{l ..... k}

L'lm rain

j~{1 ..... k}

{(m - 1)ctat; + clj} if m ~< h,

{ ( n - m + 1)[3at~+clj} 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~m is now given by (8). Hence, problem P2 can be solved in an O(n 3) time.

3. NP-hardness of P3, P4' and P5'

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,). (7) i = 1

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 lT . . . . and the problem 1 ]l ~ Uj is polynomially solvable by Moore's algorithm [12]. But the weighted version of the last problem: 1 ]l S wJ Uj is NP-bard even with a common due date [11].

In the case with continuously controllable processing times, the problems 1 I r j, cml Cmax + TPC, and 1 Icml Tm,x + TPC are both polynomially solvable (see [13, 19], respectively), while the problem 1 I cml Y. wj Uj + TPC becomes NP-hard even with dj - d and w I = w [-6].

Surprisingly, under the discrete model, problems P3: llrj , dm[Cm,x + TPC and P4: lldmLTm,x + TPC 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~ U i + TPC (a special case of P5) is proved to the NP-hard here. Note that when jobs are simultaneously available, the problem l ldmlCmax + TPC can be easily solved by sequencing jobs in an arbitrary order and letting

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

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

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:

KNAPSACK: 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?

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. Problem P3 is NP-hard .

Proof. Given an instance of KNAPSACK, 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; fo r 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 KNAPSACK.

(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, x i = a i l 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 . + Z aj, jES j~T j~S \T

j~Sk T

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

Hence CL(~Z ) ~< r~+ l, implying that the makespan of zc, C,nax(rc) = r~+ l + Xs+ l = 2 + n + Q(R - A). On the other hand, the total processing cost in n is TPC = ~~j~TCj2 = ~ , j e T q j ~ B. So, the objective function of n is F(n) = Cmax(n) + TPC ~< 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 KNAPSACK, 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 KNAP- 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 TPC = 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 + TPC > y.

Case 2: Y q ~ r P j < A, and ~ i~ rq 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 NP-hard .

Proof. Given an instance of KNAPSACK, we construct the corresponding instance of P4' as follows:

P4': Job set N = S; let the common 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.


(1) " I f" : Let T be a subset of S such that ~jETPJ >/ A and ~ jETqJ ~ 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

solving P4: 1Ldm[Tmax+TPC and P5: l ldml 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.

CL(a) = n + Q ( R -- ~, pj) ~ n + Q(R - A). jET

Remark 2. The earliest-due-date-first (EED) order is an optimal sequence for P4.

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. []

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-t ime if C~ ~< dj).

(II) On-time jobs are sequenced in the EDD 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.

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

4.1. A D P algori thm 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

/7ma x = 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. Recursive relations: For j = 2,3 . . . . . n and t = 0, 1, .. . ,trnax:

(cl)

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

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 75

where

gi(j, t) =

f ( j - 1, t - aji) + cji if t >>. rj + a~g, otherwise.

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

(cl I f(l't)=Ic ~ if t>~r~ +a l~ ,

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

if t < r l + a ~ k ,

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

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

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).

4.2. A DP algorithm for P4 and P5

In this subsection, we first propose a pseudopolynomial dynamic programming algorithm for

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 on- time jobs or to the last position of the current tardy jobs.

Algorithm 2 (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 . . . . , dma x:

{mi min { f ( j - - l , t - -a j i ) +cji}, f ( j - - l , t) + cjl + w~}, if t <~ dj, f ( j , t ) = n {1 .<i~, otherwise,

x j =

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

(d2) Initial values: For t = 0, 1 . . . . , d m a x :

f (1 , t ) = lWc~ + Cll if t -- O, if da ~> t = ali and 1 ~< i ~< k, otherwise,

~ al l if f(1, t) --- wx + C 1 1 , f (1 , t ) = cl l or f(1, t) = 0% X 1 =

( a l i i f f ( l , t ) = c l i and 2~<i~<k.

(e2) An optimal solution can be obtained by computing min { f (n , t ) l t = 0, . . . , dmax}.


R e m a r k 5. The complex i ty of A lgor i thm 2 is O(knd,nax), which can be shown by the same argument as in R e m a r k 4.

R e m a r k 6. A lgor i thm 2 can be used to solve p rob- lem P4 by the fol lowing way. Inpu t an instance of p r ob l em P4. Let Zmax be the m a x i m u m tardiness of the E D D sequence under the no rma l process ing t imes of the instance. Then Zmax is the m a x i m u m possible Tma x in an op t ima l schedule for the instance. Now, for every integer z ~ [0, Zm,~], do the following: (1) reset the due da te for each j o b j ~ N: d) = d r + z, and in t roduce a weight for each job: wy = ~ ; (2) solve this new instance by Algor i thm 2. If the op t imal object ive function value is finite, then record the co r respond ing op t ima l schedule. In this recorded op t ima l schedule, there is no t a rdy j o b under the new due dates, and Tma x ~< z under the original due dates. After each possible z is exam- ined, compare all the recorded schedules and the one with the smallest to ta l cost Tma~ + T P C is then op t ima l for P4. The above p rocedure needs an O(kndmaxZmax) t ime since it calls A lgor i thm 2 once for each possible z = 0, I . . . . . Z m a x .

Acknowledgements

This research was suppor t ed in par t by the Na- t ional Na tu r a l Science F o u n d a t i o n of Ch ina when the first and the second au thors were in China. The au thors would like to thank the associa te ed i tor and an a n o n y m o u s referee for their helpful sugges- t ions on the earl ier versions of this paper .

References

[1] R.K. Ahuja, T.L. Magnanti, J.B. Orlin, Network Flows: Theory, Algorithms, and Applications, Prentice-Hall, En- glewood 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, Sched- uling 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.), Reduci- bility 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.

Documents

Single machine scheduling with discretely controllable processing times