Scheduling with controllable release dates and processing times: Makespan minimization

European Journal of Operational Research 175 (2006) 751–768

www.elsevier.com/locate/ejor

Discrete Optimization

Scheduling with controllable release datesand processing times: Makespan minimization q

T.C. Edwin Cheng a, Mikhail Y. Kovalyov b, Natalia V. Shakhlevich c,*

a Department of Logistics, The Hong Kong Polytechnic University, Hung Hom, Kowloon, Hong Kongb Faculty of Economics, Belarus State University and United Institute of Informatics Problems,

National Academy of Sciences of Belarus, Skorini 4, 220050 Minsk, Belarusc School of Computing, University of Leeds, Leeds LS2 9JT, UK

Received 27 April 2004; accepted 1 June 2005Available online 31 August 2005

Abstract

The paper deals with the single-machine scheduling problem in which job processing times as well as release dates arecontrollable parameters and they may vary within given intervals. While all release dates have the same boundary val-ues, the processing time intervals are arbitrary. It is assumed that the cost of compressing processing times and releasedates from their initial values is a linear function of the compression amount. The objective is to minimize the makespantogether with the total compression cost. We construct a reduction to the assignment problem for the case of equalrelease date compression costs and develop an O(n2) algorithm for the case of equal release date compression costsand equal processing time compression costs. For the bicriteria version of the latter problem with agreeable processingtimes, we suggest an O(n2) algorithm that constructs the breakpoints of the efficient frontier.� 2005 Elsevier B.V. All rights reserved.

Keywords: Scheduling; Single-machine; Makespan; Controllable processing times; Controllable release dates

1. Introduction

We study the problem of optimal scheduling a set of n jobs on a single-machine. Each job is characterizedby two parameters, processing time and release date, both of which may vary within certain limits. The

0377-2217/$ - see front matter � 2005 Elsevier B.V. All rights reserved.doi:10.1016/j.ejor.2005.06.021

q This research was supported in part by The Hong Kong Polytechnic University under a grant from the Area of StrategicDevelopment in China Business Services. The research of the second and third authors was additionally supported by INTAS (ProjectINTAS-96-0820).

* Corresponding author. Tel.: +44 113 343 5444; fax: +44 113 343 5468.E-mail address: [email protected] (N.V. Shakhlevich).

mailto:[email protected]

752 T.C.E. Cheng et al. / European Journal of Operational Research 175 (2006) 751–768

release date of a job corresponds to the duration of the preprocessing stage and it may be compressed if someamount of a resource is consumed incurring an additional cost. The processing time of the main stage canalso be compressed if a partial job completion is allowed or if the processing can be speed up by consumingadditional resources. Compressing both job parameters may decrease the makespan of the schedule but willincur additional costs. The objective is to minimize the makespan together with the total compression cost.

Scheduling problems with controllable release dates and controllable processing times arise in variouscontexts:

• in manufacturing systems where preprocessing and processing of the jobs depend on a common resourcesuch as fuel, catalyzer, raw materials, etc. (see the real-life examples of such problems in [6,8–10,20] inthe context of steel production),

• in supply chain scheduling where cooperation between the elements of the supply chain allows to coor-dinate the supplier�s decisions, i.e., job release dates, and the manufacturer�s decisions, i.e., the process-ing times (see [13]),

• in computing systems that support imprecise computations where the release times are related to inputgeneration and they can be decreased incurring an input error, while the processing times are related tothe computation times at the main stage and they can also be decreased incurring a computation error(see [4]).

Metallurgy is the most extensively cited application area for scheduling with resource dependent jobparameters. The preprocessing stage corresponds to casting and keeping the produced slabs in heat pres-ervation pits; the processing stage consists in preheating of the slabs in a furnace followed by hot-rolling.The time required for each of the two stages depends essentially on the energy consumption. The objectiveis to find the energy consumption levels for the slabs in the heat preservation peat at the preprocessing stageand in the heat furnace at the processing stage such that the total energy consumption and the machineusage time (makespan) are minimized. If final products—steel strips—feed downstream operations in a sup-ply chain, then mean flow time can be more appropriate objective function than the makespan.

Prior work in the area of scheduling with controllable parameters has considered either controllable pro-cessing times and fixed release dates [2,4,6,10,11,18], or controllable release dates and fixed processing times[1,7–9,12,14–16]. A survey of scheduling models with controllable processing times is given in [17]. In thispaper, we examine the problems with controllable release dates are studied in [7–9,12,19]. In this paper, weexamine a single-machine scheduling problem with the makespan minimization criterion where both releasedates and processing times are controllable.

The problem can be formulated as follows. A set of independent non-preemptive jobs N = {1, . . ., n} isto be processed on a single-machine. For every job i, i 2 N, its normal (maximum) release date �ri is given,which is the instant at which job i is ready for processing. It can be compressed by some amount xi to thevalue ri ¼ �ri � xi at a cost aixi. A lower bound ri for the compressed release date ri is also given, i.e.,

ri 6 ri 6 �ri

and the maximum compression amount is equal to �xi ¼ �ri � ri.Similarly, for the processing time pi of job i 2 N, its lower and upper bounds pi and �pi are given:

pi 6 pi 6 �pi.

Compressing the normal (maximum) processing time �pi by some amount yi to the actual processing timepi ¼ �pi � yi incurs the resource consumption cost biyi, and the maximum compression amount is givenby �yi ¼ �pi � pi.

Job i is called crashed, if its processing time is compressed to its minimum value, i.e., if pi = pi, and job i

is called uncrashed, if it has the maximum processing time, i.e., if pi ¼ �pi. Job i is called partially crashed, if

T.C.E. Cheng et al. / European Journal of Operational Research 175 (2006) 751–768 753

pi < pi < �pi. We will say that the job is early if it starts strictly before time �ri. Observe that the meaning ofthe term early in this paper differs from its meaning in the context of just-in-time scheduling.

The problem with controllable release dates and controllable processing times is defined on the set offeasible schedules S ¼ fðx; y; pÞj0 6 xi 6 �xi; 0 6 yi 6 �yi; i 2 Ng, where p is a permutation of the jobs fromN. We assume that the jobs start at their earliest possible times with respect to their release dates �ri � xi

and permutation p. Given a schedule s 2 S, the job completion times Ci, i = 1, . . ., n, can easily be deter-mined. The objective is to minimize

F ðx; y; pÞ ¼ Cmaxðx; y; pÞ þ Kðx; yÞ ð1Þ
that represents the sum of the makespan
Cmaxðx; y; pÞ ¼ max16i6nfCiðx; y; pÞg

and the linear compression cost function

Kðx; yÞ ¼Xn

i¼1

ðaixi þ biyiÞ.

In addition to the single criterion problem of minimizing F(x, y,p), we also consider the bicriteria problemof constructing the efficient frontier in the (Cmax, K)-space and the corresponding efficient schedules. A sche-dule s 0 = (x 0, y 0,p 0), s 0 2 S, is called efficient (Pareto optimal) if there exists no schedule s00 = (x00, y00,p00),s00 2 S, such that Cmax(s00) 6 Cmax(s 0) and K(x00, y00) 6 K(x 0, y 0), where at least one of these relations is astrict inequality. As we will show, the efficient frontier is a piecewise linear curve in our case.

Adapting the three-field classification scheme from [5], the two problems under consideration are de-noted by 1j�ri � xi; �pi � yijCmax þ K and 1j�ri � xi; �pi � yijðCmax;KÞ.

In this paper we assume that release date compression costs are equal:

ai ¼ a; i ¼ 1; . . . ; n;

the release dates have common bounds:

ri ¼ r;�ri ¼ �r; i ¼ 1; . . . ; n ð2Þ

and that the length of the time interval ½r;�r� is large enough to allow processing all jobs:

�r � r PXn

i¼1

�pi. ð3Þ

Observe that the problem with arbitrary (unequal) costs ai is NP-hard even if (2) and (3) hold [19].Release date assumptions (2) and (3) have been popularly adopted in scheduling research for problems

with controllable release dates [1,6,8,9,12,14–16]. If (2) does not hold, then the single criterion problem isNP-hard [17]; if (3) does not hold, then the problem is NP-hard as well [19]. Both results hold even if pro-cessing times are fixed (non-controllable).

The paper is organized as follows. Section 2 introduces some schedule transformations, which will beused in Sections 3 and 4. The single criterion problem is studied in Sections 3 and 4. In Section 3 we reduceit to an assignment problem solvable in O(n3) time; in Section 4 we develop an O(n2) solution algorithm ifcondition bi = b is satisfied. The complexity of the latter algorithm reduces to O(n log n) in the case ofagreeable processing times, i.e., when the jobs can be numbered such that

�p1 P �p2 P � � �P �pn and p1 P p2 P � � �P pn. ð4Þ

The bicriteria problem with objective functions Cmax(x, y,p) and K(x, y) is investigated in Section 5where we develop an O(n2) algorithm to construct the breakpoints of the efficient frontier and the


corresponding schedules if job processing times are agreeable and bi = b, i = 1, . . ., n. Note that if the pro-cessing times are not agreeable, the number of breakpoints of the efficient frontier is exponential. This fol-lows from the result obtained in [18] for the problem 1j�pi � yijð

PCi;P

yiÞ with zero release dates andcontrollable processing times, which may be transformed into a special case of our bicriteria problem.

In Section 6 we demonstrate that the single criterion problem with parallel machines is strongly NP-hardeven if bi = b, i = 1, . . ., n. The concluding remarks are given in Section 7.

2. Schedule transformations

Consider an arbitrary schedule s = (x, y,p) 2 S. Let h denote the number of early jobs in s, p(i) denotethe job processed in position i, and n(i) denote the position of job i in schedule s. The following types oftransformations will be used in order to establish the properties of an optimal schedule. For each transfor-mation, the change in the objective function F is estimated, where F is the sum of the makespan and thecompression cost (see (1)).

Right shift. The whole schedule s is shifted t units later in such a way that the last early job which is pro-cessed in position h starts in the resulting schedule s 0 not later than �r (see Fig. 1(a)). It means that the valueof t is no larger than the compression amount xp(h) of the release date of that job. For this transformation,Cmax increases by t and the release dates of the early jobs also increase by t. The change in the objectivefunction is equal to

DF ¼ F ðs0Þ � F ðsÞ ¼ ð1� ahÞt. ð5Þ
Left shift. This transformation shifts the whole schedule t units earlier so that the number of early jobs in
the resulting schedule s 0 becomes h 0, h 0 P h (see Fig. 1(b)). Since the makespan decreases by t while therelease date compression cost increases by no more than ah 0t, the total change in the objective functioncan be estimated as

DF ¼ F ðs0Þ � F ðsÞ 6 ðah0 � 1Þt. ð6Þ
Crash i. The processing time of job i is compressed by an amount t. If job i is early, then after its com-
pression, this job together with all preceding jobs is right-shifted so that in the resulting schedule s 0 all jobsare processed contiguously. For this transformation the makespan does not change while the cost of releasedate compression decreases by at for each job processed in positions 1, . . ., n(i), where n(i) is the position ofjob i in schedule s. It follows that the objective function value changes by

DF ¼ F ðs0Þ � F ðsÞ ¼ ðbi � anðiÞÞt. ð7Þ

(a)

(b)

Fig. 1. ‘‘Right shift’’ and ‘‘left shift’’ schedule transformations.


If job i is not early, then after its compression all jobs following job i are left-shifted such that the makespandecreases by t and

DF ¼ F ðs0Þ � F ðsÞ ¼ ðbi � 1Þt. ð8Þ

Uncrash i is a transformation opposite to crash i. It changes the objective function by the opposite value:

DF ¼�ðbi � anðiÞÞt; if job i is early;

�ðbi � 1Þt; otherwise.

�ð9Þ

A sequential application of uncrash i and crash i does not change the original schedule.

3. Single criterion problem: Arbitrary bi

We start with establishing the properties of an optimal schedule. Let us say that a job straddles the re-lease date �r if it starts before and completes after time �r.

Statement 1. There exists an optimal schedule with no straddling job.

Proof. Suppose in an optimal schedule s* the jobs are processed according to the sequence (p(1), . . .,p(n))and the job p(h) processed in position h straddles �r. Let t1 be the duration of the part of job p(h) processedbefore �r and let t2 = pp(h) � t1. If Q ¼ 1�

Phi¼1apðiÞ < 0, then ‘‘right shift’’ by t1 decreases the objective

function (see (5)) and hence s* is not optimal. If Q P 0, then ‘‘left shift’’ by t2 does not increase the objectivefunction (see (6)) and it leads to an optimal schedule with the job in position h + 1 starting exactly at �r. h

Statement 2. There exists an optimal schedule with no partially crashed jobs.

The statement is easily proved by using the transformations ‘‘crash’’ or ‘‘uncrash’’ for a partially crashedjob.

Statement 3. There exists an optimal schedule for problem 1j�r � xi; �pi � yijCmax þ K with

h ¼ min1

a

� �; n

� �ð10Þ

early jobs. If n > 1a

� �, then the job in position h + 1 starts exactly at time �r. Otherwise an optimal schedule

starts at time r.

Proof. Let s* be an optimal schedule, the number of early jobs in s* be h and the job in position h + 1 startexactly at time �r.

If n > 1a

� �and h > 1

a

� �, then ‘‘right shift’’ decreases the objective function (see (5)). If h 6 1

a

� �� 1, then

‘‘left shift’’ leads to a schedule with h 0 = h + 1 early jobs without increasing the objective function (see (6)),and the resulting schedule satisfies the statement.

If n 6 1a, then ‘‘left shift’’ does not increase the objective function and hence an optimal schedule may

start at r. h

In what follows we describe how the problem under consideration can be reduced to an assignmentproblem. Consider first the case n > 1

a

� �. Suppose the values yi, i = 1, . . ., n, and the job sequence p are

given. Then the compression amounts for the release dates of h ¼ 1a

� �early jobs can be determined by

xpðiÞ ¼Ph

j¼ið�ppðjÞ � ypðjÞÞ; i ¼ 1; . . . ; h, since in accordance with Statement 3, a job in position h completesexactly at time �r. The two components of the objective function F are given by the formulas:


Cmax ¼ �r þXn

j¼hþ1

ð�ppðjÞ � ypðjÞÞ;

Kðx; yÞ ¼Xh

j¼1

ajð�ppðjÞ � ypðjÞÞ þXn

j¼1

bpðjÞypðjÞ

and thus

F ðx; y; pÞ ¼ �r þXh

j¼1

ðaj�ppðjÞ þ ðbpðjÞ � ajÞypðjÞÞ þXn

j¼hþ1

ð�ppðjÞ þ ðbpðjÞ � 1ÞypðjÞÞ. ð11Þ

It is easy to see that the cost of assigning job i to position j does not depend on the assignment of theremaining jobs. Furthermore, function F(x, y,p) achieves its minimum for

ypðjÞ ¼

�ypðjÞ; if j 6 h and bpðjÞ � aj < 0;

0; if j 6 h and bpðjÞ � aj P 0;

�ypðjÞ; if j > h and bpðjÞ � 1 < 0;

0; if j > h and bpðjÞ � 1 P 0.

8>>><>>>:

ð12Þ

Consider now the case n 6 1a

� �. If the values yi, i = 1, . . ., n, and the job sequence p are given, then the

release date of the first job p(1) is compressed by xpð1Þ ¼ �r � r and the compression amounts for the releasedates of all other jobs are given by xpðiÞ ¼ ð�r � rÞ �

Pi�1j¼1ð�ppðjÞ � ypðjÞÞ; i ¼ 1; . . . ; n. The components of the

objective function F are given by the formulas:

Cmax ¼ r þXn

j¼1

ð�ppðjÞ � ypðjÞÞ;

Kðx; yÞ ¼ a nð�r � rÞ �Xn

j¼1

ðn� jÞð�ppðjÞ � ypðjÞÞ" #

þXn

j¼1

bpðjÞypðjÞ

and thus

F ðx; y; pÞ ¼ r þ anð�r � rÞ þXn

j¼1

ð1� aðn� jÞÞ�ppðjÞ þXn

j¼1

ðbpðjÞ � 1þ aðn� jÞÞypðjÞ. ð13Þ

As in the previous case, the cost of assigning job i to position j does not depend on the assignment of theremaining jobs. Furthermore, function F(x, y,p) achieves its minimum for

ypðjÞ ¼�ypðjÞ; if bpðjÞ � 1þ aðn� jÞ < 0;

0; otherwise.

�ð14Þ

We can summarize the results obtained for n > 1a

� �and n 6 1

a

� �in the following theorem.

Theorem 1. An optimal schedule for problem 1j�r � xi; �pi � yijCmax þ K can be constructed in O(n3) time by a

reduction to an assignment problem with costs ,ij for assigning jobs i = 1, . . ., n to positions j = 1, . . ., n given by

the formulas:

,ij ¼aj�pi þminfðbi � ajÞ�yi; 0g for 1 6 j 6 h;

�pi þminfðbi � 1Þ�yi; 0g for hþ 1 6 j 6 n;

�if n >

1

a

� �; ð15Þ

,ij ¼ ð1� aðn� jÞÞ�pi þminfðbi � 1þ aðn� jÞÞ�yi; 0g if n 61

a

� �. ð16Þ


4. Single criterion problem: Equal bi

In this section we show that if condition bi = b is satisfied, then the problem can be solved in O(n2) time.Also, we demonstrate that the running time of the algorithm reduces to O(n log n) in the case of agreeableprocessing times.

First we study the properties of an optimal schedule. It is easy to see that minimizing function F(x, y,p)given by (11) or (13) is equivalent to minimizing function F(p1, . . ., pn,p) represented as the sum of two com-ponents depending on actual processing times pi ¼ �pi � yi and the job sequence p:

F ðp1; . . . ; pn; pÞ ¼Xn

q¼1

kqppðqÞ þXn

i¼1

bð�pi � piÞ. ð17Þ

Here kq are constants defining the positional penalty for assigning a job to position q.It follows from (11) and (13) that

kq ¼minfaq; 1g; if an > 1;

1� aðn� qÞ; otherwise.

�ð18Þ

Observe that k1 6 k2 6 � � � 6 kn. If the processing times of the jobs are fixed and given by~pi; pi 6 ~pi 6 �pi, i = 1, 2, . . ., n, then the second component of function F is constant and the first componentis minimized by sequencing the jobs in accordance with non-increasing order of their actual processingtimes:

~pi1 P ~pi2 P � � �P ~pin .

We consider various combinations of parameters a and b and describe the structure of an optimalschedule.

Case a > 1. An optimal schedule starts at �r (Statement 3); all jobs are either uncrashed if b P 1 orcrashed, otherwise (see (12)).

Case a = 1. According to Statement 3, one job is early. Due to (5), right shifting does not change theobjective function value, and we can consider an optimal schedule that starts at �r. As above, all jobs areuncrashed if b P 1 or crashed, otherwise.

Case 1n < a < 1. The number of early jobs is h ¼ 1

a

� �(Statement 3). It follows from (12) that

• if b < a, then all jobs are crashed;• if b P 1, then all jobs are uncrashed;• if a 6 b < 1, then according to (15), the jobs processed in positions 1, . . .,h1 are early and uncrashed; the

jobs processed in positions h1 + 1, . . ., h are early and crashed; the job processed in position h + 1 startsat �r and it is crashed; the remaining jobs processed in positions h + 2, . . ., n are crashed as well, where

h1 ¼ba

� �ð19Þ

is the number of uncrashed jobs. The corresponding schedule is illustrated in Fig. 2(a).

Case a 6 1n. All jobs are early and start at r (see Statement 3). It follows from (14) that

• if b < 1 � na, then all jobs are crashed;• if b P 1, then all jobs are uncrashed;• if 1 � na 6 b < 1, then according to (16), the jobs processed in positions 1, . . .,h2 are uncrashed and the

remaining jobs processed in positions h2 + 1, . . ., n are crashed, where

(a)

(b)

Fig. 2. The structure of an optimal schedule for problem 1j�r � xi; �pi � yijCmax þ K if (a) 1n < a 6 b < 1 and (b) 0 6 1�na 6 b < 1.


h2 ¼ n� 1� ba

� ð20Þ

is the number of uncrashed jobs. The corresponding schedule is illustrated in Fig. 2(b).

Thus in all but two cases all jobs are fully crashed or all jobs are fully uncrashed and they are sequencedin non-increasing order of their processing times. In what follows we study the two non-trivial cases illus-trated in Fig. 2(a) and (b). We will refer to the case 1/n < a 6 b < 1 as Case A and to the case0 6 1 � na 6 b < 1 as Case B. For these two cases our objective is to determine h jobs (h = h1 orh = h2 depending on the values of a and b) that are uncrashed. The optimal schedule is then obtainedby sequencing the jobs in non-increasing order of their actual processing times.

For Cases A and B we develop an algorithm that considers the classes of schedules Sg withh ¼ minf 1

a

� �; ng early jobs, g of which are uncrashed, g = 0, 1, . . .,h. Let s�g denote a schedule optimal in

Sg. Clearly, a global optimal schedule is given by s�h.The algorithm starts with constructing an initial schedule s�0 with all jobs fully crashed and h early jobs.

Schedule s�0 is modified to obtain schedule s�1 optimal in the class of the schedules with one uncrashed job. Inits turn, schedule s�1 is modified into schedule s�2 with two uncrashed jobs, etc. A transition s�g ! s�gþ1 is per-formed by uncrashing one job (say, job j) and resequencing it maintaining the non-increasing order of ac-tual processing times and keeping the number of early jobs equal to h. It means that if a and b satisfy theconditions of Case A and job j is early in schedule s�g, then after its uncrashing and resequencing, the set ofearly jobs does not change (see Fig. 3(a)). If job j is processed at or after �r in schedule s�g, then after itsuncrashing and resequencing, it is placed in the early part of the schedule. As a result the whole scheduleis shifted to the right by the processing time of the last early job (job u in Fig. 3(b)) so that the number ofearly jobs does not change. On the other hand, in Case B all schedules s�g, g = 0, 1, . . .,h, start at time r (seeFig. 4).

Suppose the current schedule s�g is given by job permutation s�g ¼ ðpð1Þ; pð2Þ; . . . ; pðnÞÞ, such that

ppð1Þ P ppð2Þ P � � �P ppðnÞ; ð21Þ

and crashed job j is subject to decompression. If in the resulting schedule s�gþ1 job j is inserted in-betweentwo subsets of jobs Z1 and Z2 keeping the non-decreasing order of job processing times:

(a)

(b)

Fig. 3. Transition from schedule s�g to s�gþ1 (Case A) by uncrashing job j if (a) job j starts before �r and (b) job j starts after �r.

Fig. 4. Transition from schedule s�g to s�gþ1 by uncrashing job j (Case B).


s�g ¼ ðpðZ1Þ; pðZ2Þ; j; pðZ3ÞÞ ðjob j is crashedÞ;s�gþ1 ¼ ðpðZ1Þ; j; pðZ2Þ; pðZ3ÞÞ ðjob j is uncrashedÞ;

then the change in the value of the objective function F is determined as

DF j ¼ kz1þ1�pj � kz1þz2þ1pj � bð�pj � pjÞ þXm2Z2

ðkmþ1 � kmÞppðmÞ; ð22Þ

where the values of kq are calculated in accordance with (18) and z1 = jZ1j, z2 = jZ2j.Below we describe the algorithm that performs a series of transitions s�g ! s�gþ1 thus constructing an opti-

mal schedule s�h.

Algorithm A

1. Crash all jobs to pi, i = 1, . . ., n. Renumber the jobs in accordance with p1 P p2 P � � �P pn. Determineinitial job sequence s�0 ¼ ð1; 2; . . . ; nÞ.

2. FOR g = 0 TO h � 1 (h = h1 or h = h2 depending on the values of a and b).3. For every crashed job j calculate DFj by formula (22).4. Select job i with the minimum value DFi.5. Perform transition s�g ! s�gþ1 by uncrashing job i and resequencing it maintaining non-increasing

order of actual processing times.6. END FOR7. Output the resulting schedule s�h with h early jobs (h is given by (10)), h of which are uncrashed.

The time complexity of steps 3 and 4 is O(n) and the complexity of step 5 is O(log n). These steps are
repeated h times, h 6 n. Thus the overall complexity of solving problem 1j�r � xi; �pi � yijCmax þ K with equalcosts ai = a and bi = b is O(n2).
The proof of the correctness of Algorithm A is based on the following lemma.

Lemma 1. Let �pi 6 �pj and pi 6 pj, and at least one of the inequalities is strict. Then in class Sg there is no

optimal schedule s�g with job i uncrashed and job j crashed.

Proof. We prove the lemma for Case A when n > 1a

� �and a 6 b < 1. The proof for Case B is similar.

Suppose s�g is an optimal schedule in the class Sg that complies with (21) with job i uncrashed and job j

crashed, where i and j satisfy the conditions of the lemma. Observe that in accordance with Statement 3 inthis schedule there are h ¼ 1

a

� �early jobs and job in position h + 1 starts at time �r. We show that schedule s�g

can be transformed into another schedule in class Sg with a smaller objective function value.First we swap jobs i and j, decompress the processing time of job j to p0j ¼ �pi 6 �pj and compress job i to

the processing time p0i ¼ pj P pi thus obtaining a new schedule ~sg without changing the value of theobjective function (see Figs. 5 and 6).

If in schedule ~sg job j can be uncrashed further (say, by an amount t), then ‘‘uncrash’’ j changes theobjective function value by DF determined by (9):


DF ¼ �ðb� anðjÞÞt 6 0; ð23Þ
where n(j) is the position of job j in schedule ~sg, i.e., n(j) 6 h1 = bb/ac.
If in schedule ~sg job i can be compressed further, then ‘‘crash’’ i also decreases the objective functionvalue. Indeed, if we have a situation as shown in Fig. 5, then after the transformation job i is processed after�r and the change in the objective function is determined according to (8):

DF ¼ ðb� 1Þt < 0. ð24Þ
If we have a situation as shown in Fig. 6, then after the transformation job i is processed before �r and thechange in the objective function is determined according to (7):
DF ¼ ðb� anðiÞÞt < 0; ð25Þ
where n(i) is the position of job i in schedule ~sg, i.e., n(i) P bb/ac + 1.
Finally, since at least one of the inequalities given in the lemma is strict, at least one of the above valuesDF is strictly negative.

Fig. 5. Transformation of schedule s�g if job j starts after �r.

Fig. 6. Transformation of schedule s�g if job j is early.


Observe that the arguments above are based on the assumption that �pi P pj. If the opposite conditionholds, then there is no need to swap jobs i and j, decompressing j to p0j and compressing i to p0i. In this case theuncrashed job j precede the crashed job i in schedule s�g due to (21), i.e., schedule s�g has in fact the structure of~sg, the second schedule shown in Figs. 5 and 6. In such a schedule, job j can be uncrashed decreasing the valueof F in accordance with (23), while job i can be crashed decreasing the value of F in accordance with (24) or(25) depending on its early/non-early position is s�g. This finishes the proof of the lemma. h

We are able now to demonstrate that Algorithm A is correct.

Theorem 2. If schedule s�g is optimal in class Sg, then schedule s�gþ1 constructed by Algorithm A is optimal in

class S�gþ1.

Proof. The proof of the theorem is based on the general formula for the objective function value (17) thatuses positional penalties kq. The formula holds for both Cases A and B. We demonstrate that the structureof schedule s�gþ1 differs from that of schedule s�g by exactly one job, which is crashed in s�g and uncrashed ins�gþ1.

Suppose that there are k > 1 jobs A = {a1, . . ., ak} that are uncrashed in schedule s�g and crashed inschedule s�gþ1 and k + 1 jobs B = {b1, . . ., bk+1} that are crashed in schedule s�g and uncrashed in schedules�gþ1. The status of the remaining jobs is the same in both schedules. Let the jobs be numbered in accordancewith �pa1

P �pa2P � � �P �pak

and �pb1P �pb2

P � � �P �pbkþ1. As it follows from Lemma 1, for any pair of jobs

ai and bj, their processing times cannot be agreeable (otherwise one of the schedules s�g or s�gþ1 cannot beoptimal in its class). This means that

either ½pai ; �pai� � ½pbj ; �pbj

� ð26Þor ½pbj ; �pbj

� � ½pai ; �pai�. ð27Þ

We prove our statement by constructing two additional schedules rg 2 Sg and rg+1 2 Sg+1. Since s�g isoptimal in class Sg,

F ðrgÞ � F ðs�gÞP 0. ð28Þ

We will demonstrate that

F ðs�gþ1Þ � F ðrgþ1ÞP F ðrgÞ � F ðs�gÞ; ð29Þ

which together with inequality (28) means that either schedule s�gþ1 is not optimal, or it can be replaced byschedule rg+1 without increasing the value of F, where schedule rg+1 differs from schedule s�g by decompres-sion of one job.

Depending on the value of minf�pai; �pbjjai 2 A; bj 2 Bg we consider the following two cases.

Case 1: minf�pai; �pbjj ai 2 A; bj 2 Bg ¼ �pbkþ1

, i.e., bk+1 is the ‘‘inner’’ job in terms of relations (26) and(27).

Since one of the conditions (26) or (27) holds for each pair of jobs ai 2 A and bj 2 B, we can split sets A

and B into subsets A = A1 [ A2 [ � � � [ Al, B = B1 [ B2 [ � � � [ Bl in such a way that the following‘‘embeddings’’ hold:

� for any job i 2 A1 and any job j 2 B condition (27) is satisfied;

� for any job j 2 B1 and any job i 2 A n A1 condition (26) is satisfied;

� for any job i 2 A2 and any job j 2 B n B1 condition (27) is satisfied;

� for any job j 2 B2 and any job i 2 A n ðA1 [ A2Þ condition (26) is satisfied; etc.

ð30Þ


Denoting the remaining jobs by X [ Y we can represent the structure of schedules s�g and s�gþ1 asfollows:

s�g ¼ ðpðX 1 [ A1Þ; pðY 1Þ; pðX 2 [ A2Þ; pðY 2Þ j pðY 3 [ B2Þ; pðX 3Þ; pðY 4 [ B1Þ; pðX 4ÞÞ;

s�gþ1 ¼ ðpðX 1Þ; pðY 1 [ B1Þ; pðX 2Þ; pðY 2 [ B2Þ j pðY 3Þ; pðX 3 [ A2Þ; pðY 4Þ; pðX 4 [ A1ÞÞ.

Here symbol ‘‘j’’ separates uncrashed and crashed jobs. In our illustration we consider l = 2 and p(G) de-notes an arbitrary permutation of the jobs from G.

We describe now how auxiliary schedules rg and rg+1 are constructed. To this end, we define theboundary values �p and p of the processing times for set B:

�p ¼ �pbkþ1¼ minf�pjjj 2 Bg;

p ¼ pbu ¼ maxfpjjj 2 Bg.ð31Þ

Observe that we may have bu = bk+1.The structure of schedule rg+1 is similar to that of schedule s�g except for job bu. Its processing time is

crashed in schedule s�g and (partially) decompressed in rg+1 to the value of pbu¼ �p 6 �pbu

. Besides it isresequenced in order to keep the non-increasing order of actual processing times:

Here B02 ¼ B2 n fbug, Y 02 [ Y 002 ¼ Y 2 and Y 03 [ Y 003 ¼ Y 3.The structure of schedule rg is similar to that of schedule s�gþ1 except for job bk+1. Its processing time is

uncrashed in schedule s�gþ1 and (partially) compressed in rg to the value of p, p P pbkþ1:

Here B002 ¼ B2 n fbkþ1g.Consider transition s�g ! rgþ1. If position of job bu changes from e to d, then positions of jobs

Y 002 [ Y 03 ¼ fpðdÞ; . . . ; pðe� 1Þg increase by one and positions of other jobs do not change:

F ðrgþ1Þ � F ðs�gÞ ¼ kd�p þXe�1

m¼d

ðkmþ1 � kmÞppðmÞ � kep � bð�p � pÞ. ð32Þ


For transition s�gþ1 ! rg, position of job bk+1 changes from d to e (observe that jB1j þ jB002j ¼jBj � 1 ¼ jAj ¼ jA1j þ jA2j), while positions of jobs Y 002 [ Y 03 ¼ fpðdÞ; . . . ; pðe� 1Þg decrease by one:

F ðrgÞ � F ðs�gþ1Þ ¼ �kd�p �Xe�1

m¼d

ðkmþ1 � kmÞppðmÞ þ kep þ bð�p � pÞ.

Summing up the last two equations we obtain:

½F ðrgþ1Þ � F ðs�gÞ� þ ½F ðrgÞ � F ðs�gþ1Þ� ¼ 0;

i.e., inequality (29) holds as an equation. Moreover, if job bu is decompressed further in schedule rg+1 to�pbu

P �p and job bk+1 is compressed further in schedule rg to pbkþ16 p, then the values of F(rg+1) and

F(rg) become smaller so that (29) holds as an inequality.

Case 2: minf�pai; �pbjj ai 2 A; bj 2 Bg ¼ �pak

, i.e., ak is the ‘‘inner’’ job in terms of relations (26) and (27).As in Case 1, one of the conditions (26) or (27) holds for each pair of jobs ai 2 A and bj 2 B. As above,

we can split sets A and B into subsets A = A1 [ A2 [ � � � [ Al, B = B1[B2 [ � � � [ Bl in such a way that thefollowing ‘‘embeddings’’ hold:

� for any job j 2 B1 and any job i 2 A condition (26) is satisfied;

� for any job i 2 A1 and any job j 2 B n B1 condition (27) is satisfied

� for any job j 2 B2 and any job i 2 A n A1 condition (26) is satisfied;

� for any job i 2 A2 and any job j 2 B n ðB1 [ B2Þ condition (27) is satisfied; etc.

Denoting the remaining jobs by X [ Y we can represent the structure of schedules s�g and s�gþ1

as follows:

s�g ¼ ðpðY 1Þ; pðX 1 [ A1Þ; pðY 2Þ; pðX 2 [ A2Þ j pðX 3Þ; pðY 3 [ B2Þ; pðX 4Þ; pðY 4 [ B1ÞÞ;s�gþ1 ¼ ðpðY 1 [ B1Þ;pðX 1Þ; pðY 2 [ B2Þ; pðX 2Þ j pðX 3 [ A2Þ; pðY 3Þ; pðX 4 [ A1Þ; pðY 4ÞÞ.

Schedule rg+1 is constructed from schedule s�g in a similar way as in Case 1:

Schedule rg is constructed from schedule s�gþ1 also as in Case 1:


If e and d denote the positions of job bu in schedules rg+1 and s�g, respectively, then positions of jobsY 002 [ X 2 [ A2 [ X 3 [ Y 03 ¼ fpðdÞ; . . . ; pðe� 1Þg increase by one and positions of other jobs do not change,i.e., F ðrgþ1Þ � F ðs�gÞ is calculated according to formula (32).

Consider transition s�gþ1 ! rg. We denote the position of job bk+1 in schedules s�gþ1 and rg by d + d ande + d, respectively, where d ¼ jB1j þ jB002j � jA1j. Observe that d > 0 because jB1j þ jB002j ¼ k and jA1j < k.The positions of jobs Y 002 [ X 2 [ A2 [ X 3 [ Y 03 ¼ fpðdÞ; . . . ; pðe� 1Þg decrease by one:

F ðrgÞ � F ðs�gþ1Þ ¼ �kdþd�p �Xe�1

m¼d

ðkmþdþ1 � kmþdÞppðmÞ þ keþdp þ bð�p � pÞ.

Summing up the last equation with (32) we obtain:

½F ðrgþ1Þ � F ðs�gÞ� þ ½F ðrgÞ � F ðs�gþ1Þ�

¼ ðkd � kdþdÞð�p � ppðdÞÞ þXe�1

m¼d

ðkmþ1 � kmþdþ1ÞðppðmÞ � ppðmþ1ÞÞ þ ðke � keþdÞðppðe�1Þ � pÞ. ð33Þ

Since the jobs are sequenced in non-increasing order of their actual processing times, the following inequal-ities hold:

�p P ppðdÞ;

ppðe�1Þ P p;

ppðmÞ P ppðmþ1Þ; m ¼ d; . . . ; e� 1.

Taking into account that ki are numbered in accordance with k1 6 k2 6 � � � 6 kn we conclude that expres-sion (33) in non-positive and inequality (29) is proved.

Finally, as in Case 1, if we allow job bu to be decompressed further in schedule rg+1 to �pbuP �p and job

bk+1 to be compressed further in schedule rg to pbkþ16 p, then we will have smaller values of F(rg+1) and

F(rg), i.e. (29) again holds.Observe that the proof is valid if an arbitrary l is considered instead of l = 2. h

Consider now the special case of problem 1j�r � xi; �pi � yijCmax þ K when the jobs have agreeable process-ing times (4). It is easy to see that Algorithm A can be performed without invoking steps 3 and 4. Each timethe job i to be uncrashed in Step 5 is uniquely defined by Lemma 1: it is the crashed job with the largestprocessing time. Thus the complexity of finding an optimal schedule reduces to O(n log n) in this case.

5. Bicriteria problem with equal bi and agreeable pi

In this section we study the bicriteria problem 1j�r � xi; �pi � yijðCmax;KÞ under an assumption that the jobprocessing times are agreeable and numbered according to (4). We formulate an algorithm that constructsthe piecewise linear efficient frontier in the (Cmax, K)-space determined by the breakpoints (Cg, Kg),g = 0, 1, . . ., G, where G 6 2n. The breakpoints are numbered so that

K0 < K1 < � � � < Kg;

C0max > C1

max > � � � > Cgmax.

We start with the initial schedule s0 with the minimum compression cost value K0 = 0. In this scheduleall jobs are uncrashed and sequenced from time �r in the order of their numbering (4). Every subsequentschedule differs from the previous one only by compression of processing times and/or release dates of some


jobs. The shortest jobs are being crashed first so that the job order is the same for all schedules. Observethat since the jobs are sequenced in accordance with their numbering, any job i is processed in position i inevery schedule.

Having obtained a new breakpoint (Cg, Kg) and the corresponding schedule sg with h early jobs,0 6 h 6 n, the algorithm performs one of the transformations ‘‘left shift’’ or ‘‘crash and left shift’’.

Transformation Left Shift consists in shifting the whole schedule sg by x = ph+1 time units to the left sothat the job h + 1 becomes early, where ph+1 is an actual processing time of this job. The resulting schedulesg+1 has the makespan Cg+1 = Cg � x and the total compression cost Kg+1 = Kg + a(h + 1)x.

Transformation Crash and Left Shift consists in crashing job i by an amount y = pi � pi, where pi is anactual processing time of job i, and left shifting the subsequent jobs i + 1, . . ., n. For this transformation,Cg+1 = Cg � y. Depending on whether job i is early or not in schedule sg, the value Kg+1 is defined differently.

• If job i is processed at or after �r in schedule sg, then the total compression cost increases by by, i.e.,Kg+1 = Kg + by.

• If job i is early in schedule sg, then the release date compression cost increases by y for every jobi + 1, . . ., min{h + 1, n}, and hence Kg+1 = Kg + a(min{h + 1, n} � i)y + by.

We are now ready to describe the algorithm.

Algorithm B

1. Construct schedule s0 by sequencing the uncrashed jobs from time �r in the order of their numbering (4).Set C0 = Cmax(s0) and K0 = 0.

2. Construct schedules s1, . . ., sl, l = bb/ac, and the corresponding breakpoints (Cg, Kg). Each schedule sg+1

is obtained by Left Shifting the preceding schedule sg by �pg time units so that job g becomes early. In thelast schedule sl, l jobs are early and all jobs are uncrashed.

3. Each next schedule sg+1 is obtained from the preceding schedule sg by transformation Crash and LeftShift performed on the jobs n, n � 1, . . .,l + 1. In the last schedule sn, there are l early uncrashed jobsand the others are crashed.

4. Each next schedule sg+1 is obtained by Left Shifting the previous schedule sg so that one new jobbecomes early. In the last schedule s2n�l all jobs are early.

5. Construct the next schedule s2n�l+1 by shifting the whole schedule s2n�l to the left to be started at theminimum release date r.

6. Each next schedule sg+1 is obtained from the preceding schedule sg by transformation Crash and LeftShift performed on the jobs l,l�1, . . ., 1. In the last schedule s2n+1, all jobs are early and crashed.

Theorem 3. Algorithm B constructs the efficient frontier for the problem 1j�r � xi; �pi � yij (Cmax, K) by enumer-

ating all its breakpoints in O(n2) time.

Proof. Consider an arbitrary schedule s 0 = (x 0, y 0,p 0), 0 6 x0i 6 �xi; 0 6 y0i 6 �yi, i 2 N. This schedule uniquelydefines a point (C 0, K 0) in the (Cmax, K)-space. We prove that either s 0 can be modified to a schedule s00 suchthat Cmax(s00) = C 0, K(s00) = K 0 and (Cmax(s00), K(s00)) lies on the curve constructed by Algorithm B, or s 0 isnot efficient. In the latter case, we construct a schedule s00 with the same Cmax-value but with a smaller com-pression cost: Cmax(s00) = C 0, K(s00) < K 0.

We have one of the following cases.Schedule s 0 violates the conditions of Step 2: it has less than l early jobs and there is at least one crashed

job, say job i. In this case we construct s00 by uncrashing the processing time of job i by an amount t and


‘‘left shifting’’ the preceding jobs by the same amount: K(s00) = K 0 + (�b + am)t, where m < l = bb/ac isthe number of early jobs whose release dates increase, and hence K(s00) 6 K 0.

Schedule s 0 satisfies the conditions of Step 2 but violates the conditions of Step 3: it has more than l earlyjobs and there is at least one job i in position i > l which can be crashed. Construct s00 by crashing theprocessing time of job i by an amount t and ‘‘right shifting’’ preceding jobs by the same amount. For themodified schedule s00, K(s00) = K 0 + (b � am)t, where m > l = bb/ac is the number of early jobs whoserelease dates decrease, and hence K(s00) 6 K 0.

Schedule s 0 satisfies the conditions of Steps 2 and 3 but violates the conditions of Step 4 or 5: it startsafter r and there is at least one early job i in position i 6 l, which can be uncrashed. Then construct s00 byuncrashing the processing time of job i by an amount t and ‘‘left shifting’’ the preceding jobs by the sameamount so that the value of the makespan does not change. For the modified schedule s00,K(s00) = K 0 + (�b + ai)t 6 K 0.

Suppose schedule s 0 satisfies the conditions of Steps 2–5 but violates the conditions of Step 6: it has job icrashed and job j uncrashed, i < j 6 l. We construct s00 by uncrashing the processing time of job i by anamount t and crashing the processing time of job j by the same amount so that the value of the makespandoes not change. The increase bt in processing time compression cost for job j is compensated by thedecrease in processing time compression cost for job i. The release date compression cost decreases by t forthe jobs i + 1, . . ., j, and hence K(s00) = K 0 � a(j � i)t 6 K 0.

Finally, the total number of breakpoints is equal to 2n + 2 since each time (except for Steps 1 and 5)either one job is being crashed or the schedule is left-shifted so that exactly one new job becomes early.Modules Left Shift and Crash and Left Shift take O(n) time. Hence the overall time complexity ofAlgorithm B is O(n2). h

It is easy to verify that Algorithm B constructs the breakpoints of the efficient frontier starting from therightmost breakpoint in such a way that the slopes of the line segments Kgþ1�Kg

Cg�Cgþ1 increase:

a < 2a < � � � < la 6 b < ðlþ 1Þa < ðlþ 2Þa < � � � < na

6 ðn� lÞaþ b < ðn� lþ 1Þaþ b < � � � < ðn� 1Þaþ b.

This implies that the efficient frontier is convex.

6. Parallel machines

As we shown in [3], Algorithm A is quite a powerful technique that can be applied to a range of sched-uling problems with other objective functions and processing environments. However, for the objectivefunction Cmax + K studied in this paper Algorithm A cannot be generalized to solve more complicatedproblems. In particular, if we have more than one machine, the problem with controllable release dates be-comes NP-hard even if all processing times are fixed (non-controllable).

Consider the parallel-machine problem P j�r � xijCmax þ K for which each job can be processed by anymachine, the processing times are fixed and the release dates can be compressed. Suppose K ¼ a

Pni¼1xi,

i.e., release date compression costs are the same for all jobs. It is easy to verify that there exists an optimalschedule with all machines finishing the jobs at the same time and with no early jobs.

Indeed, if there exists a machine that is freed earlier than Cmax, then the jobs assigned to that machinecan be right-shifted without increasing neither the makespan nor the release date compression costs. On theother hand, if a machine starts processing the jobs at time �r � t, then all jobs can be right-shifted by t andthe objective function changes by DF 6 t � ant < 0, where the first component estimates the makespan in-crease and the second one estimates the decrease in the release date compression cost.

Table 1Summary of the results

Problem Arbitrary bi bi = b

1j�r � xi; �pi � yijCmax þPðaixi þ biyiÞ NP-hard [19] NP-hard [19]

1j�r � xi; �pi � yijCmax þPðaxi þ biyiÞ O(n3) Section 3 O(n2) Section 4

O(n log n) if pi are agreeableP j�r � xi; �pi � yijCmax þ

Pðaxi þ biyiÞ Strongly NP-hard, Section 6 Strongly NP-hard, Section 6


The existence of an optimal schedule with no early jobs implies that the special case of problemP j�r � xi; �pi � yijCmax þ K with fixed processing times and a > 1/n is equivalent to the classical stronglyNP-hard problem PkCmax and thus problem P j�r � xi; �pi � yijCmax þ K is strongly NP-hard as well.

7. Conclusions

We have studied the problem of optimal scheduling the jobs on a single-machine when job processingtimes and release dates are controllable parameters and the objective is to minimize the makespan togetherwith the linear compression cost function. The results obtained for a single criterion problem1j�r � xi; �pi � yijCmax þ K are summarized in Table 1. For the bicriteria problem 1j�r � xi; �pi � yijðCmax;KÞwith ai = a, bi = b, i = 1, . . ., n, and agreeable processing times we have developed an O(n2) algorithm thatconstructs the efficient frontier in the (Cmax, K)-space.

The main result of the paper is the O(n2) algorithm to solve problem 1j�r � xi; �pi � yijCmax þPðaxi þ byiÞ

that is based on decompressing the jobs in a greedy fashion. The idea of greedy decompression can be effec-tively applied to solve a range of problems with different objective functions, in particular to the problem ofminimizing the sum of the total completion time

PCi and the compression cost K. Such a generalization of

Algorithm A is suggested in [3] where we continue the current research. Among the problems solvable bythe generalized algorithm are the parallel-machine problem with the objective

PCi þ K and a number of

single-machine problems with a common due date and controllable processing times.

Acknowledgements

The authors are grateful to three anonymous referees for their suggestions and additional references.

References

[1] T.C.E. Cheng, A. Janiak, Resource optimal control in some single-machine scheduling problems, IEEE Transactions onAutomatic Control 39 (1994) 1243–1246.

[2] T.C.E. Cheng, A. Janiak, M.Y. Kovalyov, Bicriterion single-machine scheduling with resource dependent processing times, SIAMJournal on Optimization 8 (1998) 617–630.

[3] T.C.E. Cheng, M.Y. Kovalyov, N.V. Shakhlevich, Scheduling with controllable release dates and processing times: Totalcompletion time minimization, European Journal of Operational Research, submitted for publication.

[4] W.-C. Feng, J.W.-S. Liu, Algorithms for scheduling real-time tasks with input error and end-to-end deadlines, IEEE Transactionson Software Engineering 23 (1997) 93–106.

[5] R.L. Graham, E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, Optimization and approximation in deterministic sequencing andscheduling: A survey, Annals of Discrete Mathematics 5 (1979) 287–326.

[6] A. Janiak, Time-optimal control in a single machine problem with resource constraints, Automatica 22 (1986) 745–747.[7] A. Janiak, Scheduling independent one-processor tasks with linear models of release dates under a given maximum schedule length

to minimize resource consumption, Journal of System Analysis—Modelling—Simulation 7 (1990) 885–890.


[8] A. Janiak, Single machine scheduling problem with a common deadline and resource dependent release dates, European Journalof Operational Research 53 (1991) 317–325.

[9] A. Janiak, Single machine sequencing with linear models of release dates, Naval Research Logistics 45 (1998) 99–113.[10] A. Janiak, Minimization of the makespan in a two-machine problem under given resource constraints, European Journal of

Operational Research 107 (1998) 325–357.[11] A. Janiak, M.Y. Kovalyov, Single machine scheduling subject to deadlines and resource dependent processing times, European

Journal of Operational Research 94 (1996) 284–291.[12] A. Janiak, C.L. Li, Scheduling to minimize the total weighted completion time with a constraint on the release time resource

consumption, Mathematical and Computer Modelling 20 (1994) 53–58.[13] N.G. Hall, Supply chain scheduling, in: Book of Abstracts of the International Symposium on Combinatorial Optimization, Paris,

2002, pp. 10–11.[14] C.L. Li, Scheduling with resource-dependent release dates—a comparison of two different resource consumption functions, Naval

Research Logistics 41 (1994) 807–819.[15] C.L. Li, Scheduling to minimize the total resource consumption with a constraint on the sum of completion times, European

Journal of Operational Research 80 (1995) 381–388.[16] C.L. Li, E.C. Sewell, T.C.E. Cheng, Scheduling to minimize release-time resource consumption and tardiness penalties, Naval

Research Logistics 42 (1995) 949–966.[17] E. Nowicki, S. Zdrzalka, A survey of results for sequencing problems with controllable processing times, Discrete Applied

Mathematics 26 (1990) 271–287.[18] F.M. Ruiz Diaz, S. French, A note on SPT scheduling of a single machine with controllable processing time, Note 154,

Department of Decision Theory, University of Manchester, UK, 1984.[19] N.V. Shakhlevich, V.A. Strusevich, Single machine scheduling with controllable release and processing parameters, Discrete

Applied Mathematics, in press.[20] L. Tang, J. Liu, A. Rong, Z. Yang, A review of planning and scheduling systems and methods for integrated steel production,

European Journal of Operational Research 133 (2001) 1–20.

Documents

Scheduling with controllable release dates and processing times: Makespan minimization