Content uploaded by Rodrigo A. Carrasco
Author content
All content in this area was uploaded by Rodrigo A. Carrasco on Mar 13, 2018
Content may be subject to copyright.
Single Machine Scheduling with JobDependent Convex Cost and Arbitrary
Precedence Constraints
Rodrigo A. Carrasco∗, Garud Iyengar, Cliﬀ Stein
Department of Industrial Engineering & Operations Research, Columbia University, New York, NY
Abstract
In this work we combine resource augmentation and alphapoint scheduling techniques, which have
resulted in very good performance scheduling algorithms, to compute approximate solutions for a
general family of scheduling problems: each job has a convex nondecreasing cost function and the
goal is to compute a schedule that minimizes the total cost subject to precedence constraints.
We show that our algorithm is a
O
(1)speed 1approximation algorithm and our numerical
experiments show that the speedscaling ratio required is close to 1.
Keywords: scheduling, approximation algorithms, speed scaling, alphapoints, jobdependent
convex cost, weighted tardiness
1. Introduction
We consider the following oﬄine scheduling problem: we are given a collection of
n
jobs, where
job
i
has a requirement of
ρi
machine cycles, and the cost of completing job
i
at time
Ci
is given by
a nondecreasing convex function
fi
:
R+→R+
. Additionally, we are given arbitrary precedence
constraints and the objective is to compute a schedule that minimizes the total cost
Pifi(Ci)
.
Because jobs have no release dates we can assume, without loss of generality, that the schedule is
nonpreemptive. For simplicity we will use the threeﬁeld notation [
11
], and denote this problem as
1precPfi(Ci).
Special cases of this problem have been studied since the early 1960s. Schild and Fredman
considered
PiC2
i
as the scheduling metric [
27
], whereas later Townsend studied a more general
cost functions of the form
f(Ci)
=
wiC2
i
+
viCi
, where
wi
and
vi
are arbitrary weights [
30
]. More
recently H¨ohn and Jacobs [
16
] presented a 1
.
75approximation algorithm for the
PiwiC2
i
problem.
Some additional examples can be found in [
1
,
2
,
3
,
8
,
12
,
20
,
21
]. The ﬁrst major breakthrough
with general, possible nonconvex, cost functions was due to Bansal and Pruhs [
5
], who developed a
O
(
log log nP
)approximation algorithm for the 1
ri, pmtnPfi(Ci)
problem. For the special case
with no release dates (i.e.
ri≡
0) this algorithm is a 16approximation algorithm. Later, Cheung
and Shmoys [
7
] presented a pseudopolynomial (2 +
)approximation algorithm for the case without
preemption. Note that, to the best of our knowledge, there has been no results for problems with
arbitrary precedence constraints.
∗Corresponding author
Email addresses: rax@ieor.columbia.edu (Rodrigo A. Carrasco), garud@ieor.columbia.edu (Garud Iyengar),
cliff@ieor.columbia.edu (Cliﬀ Stein)
Final version available at https://doi.org/10.1016/j.orl.2013.05.008
2013. This manuscript version is made available under the CCBYNCND 4.0 license
http://creativecommons.
org/licenses/byncnd/4.0/
Preprint submitted to Operations Research Letters, v.2.5(180313092331) Tuesday 13th March, 2018
Due date related metrics are another set of interesting and widely used scheduling metrics that
satisfy the convexity requirement [
24
]. In these problems each job
i
has an associated deadline
di
and the objective function of the problem is a function of the completion times
Ci
and the deadline
di
. Some typical examples of convex due date related scheduling metrics are lateness (deﬁned as
Li
=
Ci−di
) and tardiness (deﬁned as
Ti
=
max{
0
, Ci−di}
). The total tardiness problem is
NPHard even in the case without release dates or precedence constraints [
18
,
19
], and thus the total
weighted tardiness is also NPHard. Since it is commonly used as industrial performance metric,
the total weighted tardiness has received much attention in the scheduling literature [
24
], but not
in the resource augmentation or
α
points approximation algorithms literature. To the best of our
knowledge, only the paper by Bansal, et al. [
4
] has addressed the total weighted tardiness from
a resource augmentation point of view. In their work they present, among others, an algorithm
that is 2machine, 24speed, 4approximation ratio for the 1
riPwiTi
problem. Another important
metric that has received a lot of attention lately is the tardiness square
T2
, because it penalizes
more jobs with larger tardiness and thus it is a natural metric for justintime type processes. In
this setting only branchandbound algorithms have been proposed to solve it [26].
In this paper we propose an algorithm for the setting with jobdependent convex cost func
tions with arbitrary precedence constraints that uses techniques from the
α
point and resource
augmentation literatures.
The
α
point algorithms were introduced by Phillips, Stein, and Wein [
23
], and Hall, Schulz,
Shmoys, and Wein [
14
,
15
], and have resulted in small constant factor approximation algorithms
for many scheduling problems [
28
]. In this approach, the scheduling problem is formulated as a
0
−
1 integer program (IP) in terms of decision variables
xit
that are 1 if job
i
completes at time
t
. The
α
point of each job is deﬁned as the earliest time at which an
α
fraction of the job has
been completed in linear relaxation of the IP. The jobs are then ordered in some fashion according
to these
α
points. Currently there are many variants and extensions of these technique including
choosing
α
randomly [
6
,
9
] or choosing a diﬀerent
α
for each job [
10
]. A detailed survey of many of
the current
α
point algorithms and the approximation ratios achieved by them can be found in [
28
].
Resource augmentation was developed to circumvent the shortcomings of the worstcase approxi
mation ratio criterion, and has helped explain why some algorithms perform much better in practice
than their worstcase theoretical guarantees. The main idea of this analysis is that one compares the
optimal solution of the original problem with the solution computed by an algorithm that has access
to an augmented set of resources: more machines, more space, faster speed, etc. Although the ﬁrst
examples of resource augmentation analysis are almost three decades old [
29
], this technique has
become popular only recently. Kalyanasundaram and Pruhs [
17
] introduced the idea, by showing that
running the algorithm at a faster speed was equivalent to having clairvoyance in the total ﬂow time
scheduling problem. Although it is known that there are no constant factor nonclairvoyant online
algorithm for this scheduling problem, they showed that one can achieve a constant competitive
ratio by speed scaling. The term resource augmentation analysis was introduced by Philips, Stein,
Trong, and Wein [
22
]. They deﬁned an
s
speed
ρ
approximation algorithm, as an algorithm that
achieves a
ρ
worstcase approximation ratio when jobs run at
s
times the nominal speed of the
machine. In [
22
] they also deﬁned an
m
machine
s
speed
ρ
approximation algorithm, in which the
algorithm achieves the worstcase approximation ratio
ρ
when jobs are run at
s
times the nominal
speed and the algorithm has
m
times more machines at its disposal. A survey with some of the
online resource augmentation results can be found in [25].
1.1. Our Results
We make several contributions to the problem of scheduling jobs with convex cost functions:
(a)
We introduce a model that extends the previous models by allowing a more general nonlinear
2
jobdependent cost function as the scheduling metric.
(b)
We propose a new approximation algorithm for minimizing the total nonlinear schedule cost
that uses both the αpoint and resource augmentation techniques.
(c)
We show that this algorithm has a small constant approximation ratio and a small speedscaling
ratio for two important scheduling metrics, the total weighted tardiness and the total completion
time squared. Our numerical results show that the practical performance is signiﬁcantly superior
to the theoretical bounds.
Main Result. Our main result is the following
Theorem 1.1. Given njobs with arbitrary precedence constraints and convex nondecreasing cost
functions
fi(Ci)
, there is a
O
(1)speed 1approximation algorithm for the problem of nonpreemptively
minimizing the total nonlinear cost Pfi(Ci).
The speed scaling constant is relatively small. Given
>
0 our algorithm is a (4 +
)speed
1approximation algorithm. Moreover, we are not aware of any other algorithm that achieves this
nor that combines both resource augmentation and αpoint techniques.
1.2. Our Methodology
Timeindexed IP formulations for scheduling problems are not typically of polynomial size,
therefore, we extend the polynomial size intervalindexed IP formulation introduced in [
14
], to
handle the nonlinear cost functions. The basic idea is to divide time into geometrically increasing
intervals and assign the completion time of each job to one of these intervals instead of a speciﬁc
time. In this formulation, variables
xit
are 1 if job
i
is completed in interval
t
and 0 otherwise. This
allows a polynomially sized problem, but since completion times only belong to an interval and not
exactly known, the approximation ratio suﬀers a small degradation. In Section 2we describe this
intervalindexed formulation in further detail.
After presenting our algorithm in Section 3, we analyse its approximation ratio. In doing so we
combine techniques from the
α
points literature as well as the resource augmentation literature.
The key insight is that through resource augmentation, speciﬁcally speed scaling, we ensure that
the completion times given by the algorithm and the optimal completion times are comparable.
Finally, in section 4we report the results of our numerical experiments. These results clearly
show that our algorithm performs very well and that the actual speedscaling required is less than
2% in the worst case scenarios.
2. Problem Formulation
2.1. Problem Setting
The problem setting is as follows. We are given
n
jobs, where job
i
has a processing requirement
of
ρi∈N+
machine cycles, and thus requires
pi
=
ρi
σ
time units on a machine that runs at speed
of
σ
cycles per time unit. Without loss of generality, we assume that
ρi>
0, for all
i
=
{
1
, . . . , n}
and
σ
= 1. Let
Ci
denote the completion time of job
i
and
fi(Ci)
, with
fi
:
R+→R+
, denote a
jobdependent nondecreasing convex cost function. Let Π =
{π
(1)
, . . . , π
(
n
)
}
denote the order in
which the jobs are processed, i.e.
π
(
i
) =
k
implies that the
i
th job to be processed is job
k
. Then
Cπ(i)
=
Cπ(i−1)
+
pπ(i)
is the completion time of the
i
th job, where
π
(0) = 0 and
Cπ(0)
= 0, and is
completely determined by the order Π when all jobs are processed at the same speed.
The objective is to compute a feasible schedule, consisting of an order Π that respects
precedence constraints and minimizes the total cost of all jobs, i.e. minimizes the function,
F(Π) = Pn
i=1 fπ(i)Cπ(i).
3
2.2. IntervalIndexed Formulation
We now modify and extend the intervalindexed formulation proposed by Hall et al. [
14
] for
the total nonlinear cost setting. The intervalindexed formulation divides the time horizon into
geometrically increasing intervals, and the completion time of each job is assigned to one of these
intervals. The problem formulation is as follows. We divide the time horizon into the following
geometrically increasing intervals: [
κ, κ
], (
κ,
(1 +
)
κ
], ((1 +
)
κ,
(1 +
)
2κ
],
. . .
, where
>
0 is an
arbitrary small constant, and
κ
=
minj{pj}
denotes the smallest interval size that will hold at least
one whole job. We deﬁne interval
It
= (
τt−1, τt
], with
τ0
=
κ
and
τt
=
κ
(1+
)
t−1
. The interval index
ranges over
{
1
, . . . , T }
, with
T
=
min dte:κ(1 + )t−1≥Pn
i=1 pi
; and thus, we have a polynomial
number of indices t.
Let
xit
be 1 if job
i
completes in the time interval
It
= (
τt−1, τt
] and 0 otherwise. We consider
the following IP, which is a lower bound on
F
(Π) since we consider the initial time of each time
interval It:
min
xPn
i=1 PT
t=1 fi(τt−1)xit (1)
s.t.: PT
t=1 xit = 1, i ={1, . . . , n},(2)
Pn
i=1 Pt
u=1 pixiu ≤τt, t ={1, . . . , T },(3)
xit = 0,if τt< pi, i ={1, . . . , n}, t ={1, . . . , T },(4)
Pt
u=1 xi1u≥Pt
u=1 xi2u,if i1≺i2, t ={1, . . . , T },(5)
xit ∈ {0,1}, i ={1, . . . , n}, t ={1, . . . , T }.(6)
We have constraint (2) because each job
i
must ﬁnish in a unique time interval; constraint (3)
because since only one job can be processed at any given time, the total processing time of jobs up
to time interval
It
must be at most
τt
units; constraint (4) because each job
i
requires
pi
time units
to be processed; and constraint (5) because the precedence constraint
i1≺i2
implies that job
i2
cannot ﬁnish in an interval earlier than
i1
. Note that, although the function
fi(Ci)
is nonlinear,
the objective in the interval approximation (1) is linear and also note that the error associated with
the interval relaxation is controlled through .
It is important to note that this integer program only provides a lower bound for
F
(Π) but
it might not be feasible. This is because the precedence constraints (5) do not ensure that two
sequential jobs that ﬁnish in the same interval have the right order.
3. Approximation Algorithm for Total Jobdependent Nonlinear Cost
We now describe the speed scaling and
α
point based algorithm for the total jobdependent
nonlinear cost metric, called Schedule by
α
intervals and Resource Augmentation (SAIRA)
which is shown in Figure 1.
Let
¯xit
denote the optimal solution of the linear relaxation of the integer program (1) when
replacing the constraints (6) by
xit ≥
0. In steps 1and 2of the algorithm we model and compute
the optimal solution
¯x
and in step 3, given 0
≤α≤
1, we compute the
α
interval of job
i
, which
is deﬁned as,
Iα
i
=
min t:Pt
u=1 ¯xiu ≥α
. Since several jobs may ﬁnish in the same interval, let
Jt
=
{i
:
Iα
i
=
t}
denote the set of jobs that ﬁnish in interval
It
. In step 4we describe the order Π
α
that we use to schedule jobs.
Next, in step 5, we speed up each job by
γ
and ﬁnally in steps 6and 7we compute the completion
times given the calculated speeds and return the schedule Π
α
and completion times
Cα
. Note that
since γis constant for all jobs, the SAIRA algorithm is a γspeed approximation algorithm.
We now analyse this algorithm’s performance. We will assume w.l.o.g. that Iα
1≤Iα
2≤. . . Iα
n.
4
Schedule by αintervals and Resource Augmentation (SAIRA)
Inputs: set of jobs, functions fi(Ci), α∈(0,1), > 0, γ > 1.
1 Divide time into increasing time intervals It= (τt−1, τt], with τt=κ(1 + )t−1.
2 Compute an optimal solution ¯x to the linear relaxation of problem (1).
3 Compute the αintervals ταand the sets Jt.
4 Compute an order Παthat has the sets Jtordered in nondecreasing values of tand the
jobs within each set in a manner consistent with the precedence constraints.
5 Run each job iat speed γ.
6 Set the ith job to start at time Cα
π(i−1), which is the completion time of the previous
job using speeds γ, and Cα
π(0) = 0.
7return schedule Παand completion times Cα.
Figure 1: Schedule by αintervals and Resource Augmentation Algorithm
First, the following lemma shows that the output of the SAIRA algorithm is indeed feasible.
Lemma 3.1. If i1≺i2, then constraint (5) implies that Iα
i1≤Iα
i2.
Proof.
Evaluating constraint (5) corresponding to
i1≺i2
, for
t
=
Iα
i2
, we have that,
PIα
i2
u=1 xi1u≥
PIα
i2
u=1 xi2u≥α
, where the last inequality follows from the deﬁnition of
Iα
i2
. The chain of inequalities
implies that PIα
i2
u=1 xi1u≥α, so Iα
i1≤Iα
i2.
Since the SAIRA algorithm schedules jobs by ﬁrst ordering the sets
Jt
in increasing order of
t
,
and then orders the jobs within each set in a way that is consistent with the precedence constraints,
by Lemma 3.1 it follows that the SAIRA algorithm preserves the precedence constraints, and,
therefore, the output of the algorithm is feasible.
Theorem 3.1.
The SAIRA algorithm with
α
=
1
2
and
γ
= (4+
)is a (4+
)speed, 1approximation
algorithm for the total weighted nonlinear cost problem with convex nondecreasing cost and arbitrary
precedence constraints, 1precPfi(Ci).
Proof.
Let
C∗
i
be the completion time of job
i
in the optimal solution,
fi(C∗
i)
denote its cost,
ˆxit
denote an optimal solution of the integer problem (1), and
¯xit
the fractional optimal solution of its
linear relaxation. Because we consider
τt−1
as the completion time for all jobs that ﬁnish in time
interval
t
, and since
¯xit
is the optimal solution of the linear relaxation and
fi(C)
is nondecreasing
we have that
n
X
i=1
T
X
t=1
fi(τt−1) ¯xit ≤
n
X
i=1
T
X
t=1
fi(τt−1) ˆxit ≤
n
X
i=1
fi(C∗
i).(7)
Let
¯
Ci
=
PT
t=1 τt−1¯xit
denote the optimal fractional completion time of job
i
, given by the
optimal solution of the relaxed linear program. Because
fi(C)
is convex and
Pt¯xit
= 1 from
constraint (2) then
fi¯
Ci=fi T
X
t=1
τt−1¯xit!≤
T
X
t=1
fi(τt−1) ¯xit.(8)
5
and thus, from (7) and (8),
n
X
i=1
fi¯
Ci≤
n
X
i=1
fi(C∗
i).(9)
Because there are no release date constraints there is no idle time between jobs and we can
bound the completion time determined by the algorithm, Cα
i, by
Cα
i=1
γ
i
X
j=1
pj≤1
γα
i
X
j=1
Iα
j
X
u=1
pj¯xju ≤1
γα
n
X
j=1
Iα
i
X
u=1
pj¯xju,(10)
and from constraint (3) for t=Iα
iwe get that,
Cα
i≤1
γα τIα
i.(11)
Since it is possible that
PIα
i
t=1 ¯xit > α
; we deﬁne
X(1)
i
=
α−PIα
i−1
t=1 ¯xit
and
X(2)
i
=
PIα
i
t=1 ¯xit −α
,
thus X(1)
i+X(2)
i= ¯xiIα
i, and we can rewrite
¯
Ci=
Iα
i−1
X
t=1
τt−1¯xit +τIα
i−1X(1)
i+τIα
i−1X(2)
i+
T
X
t=Iα
i+1
τt−1¯xit,(12)
and eliminating the lower terms of the previous sum we get that,
¯
Ci≥τIα
i−1X(2)
i+
T
X
t=Iα
i+1
τt−1¯xit ≥τIα
i−1X(2)
i+
T
X
t=Iα
i+1
τIα
i−1¯xit =τIα
i−1(1 −α).(13)
Because
τIα
i
= (1 +
)
τIα
i−1
, from (11) and (13) we get that
Cα
i≤(1+)
γα(1−α)¯
Ci
. The key step is
that by setting
γ
=
(1+)
α(1−α)
, which implies that we have a
(1+)
α(1−α)
speed approximation algorithm, we
make the algorithm’s completion time and the fractional completion time comparable, and thus,
n
X
i=1
fi(Cα
i)≤
n
X
i=1
fi(1 + )
γα(1 −α)¯
Ci=
n
X
i=1
fi¯
Ci.(14)
Finally, from (9) and (14) it follows that
n
X
i=1
fi(Cα
i)≤
n
X
i=1
fi(C∗
i),(15)
and by setting
α
=
arg min0≤α≤1n1
α(1−α)o
=
1
2
, which minimizes the resource augmentation
requirement, we get the desired speed and approximation ratios.
Regretfully, we are not able to extend this algorithm to the setting where release dates are
present, since we use speed scaling as a method to make sure that jobs are ﬁnished in a certain
interval.
Since the tardiness metric
Td
i
, with
d≥
1, is convex and nondecreasing, we have the following
6
Problem Instances Size (n) Average Ratio 99.5% Worst Ratio
1precPwiTi
20,720 10 0.139 0.189 0.205
20,000 10, bimodal 0.150 0.220 0.222
20,010 50 0.151∗0.179 0.192
20,010 100 0.148∗0.168 0.176
20,002 500 0.145∗0.155 0.159
1precPwiC2
i
20,010 10 0.052 0.053 0.055
20,010 100 0.059∗0.059 0.059
1precPwiT2
i
20,000 10 0.023 0.036 0.041
20,000 500 0.028∗0.031 0.032
Figure 2: Experimental Approximation Ratios Summary
corollary.
Corollary 3.1.
For any
d≥
1, the SAIRA algorithm with
α
=
1
2
and
γ
= (4 +
)is a (4 +
)speed,
1approximation algorithm for the total weighted tardiness with arbitrary precedence constraints,
1precPwiTd
i.
For the speciﬁc setting where
fi(Ci)
=
Cd
i
, with
d≥
1, if no resource augmentation is allowed,
we have the following corollary.
Corollary 3.2.
For any
d≥
1, the SAIRA algorithm with
α
=
1
2
and
γ
= 1 is a (4 +
)
d

approximation algorithm for the 1precPwiCd
iproblem.
4. Experimental Results
In this section we present a simulation based performance analysis of the SAIRA algorithm. In
our simulations we considered two common scheduling metrics: total weighted tardiness, where
fi(Ci)
=
wi
(
Ci−di
)
+
, with
di
denoting job
i
’s due date; and total weighted completion time
squared, where fi(Ci) = wiC2
i.
For each setting we simulated a large number of randomly generated instances with
= 0
.
1
and the following distributions:
wi∼unif{
0
,...,
20
}
,
ρi∼unif{
1
,...,
10
}
, and for the tardiness
setting
di∼unif{
0
,...,
0
.
1
Pρi}
. We also analysed instances with much larger ones (such as
ρi∼unif{
1
,...,
100
}
), as well as
ρi
drawn from bimodal distributions, which are generally hard for
scheduling algorithms, without observing any signiﬁcant degradation in the performance.
We compared the output of our algorithm with the integer solution of the intervalandspeed
indexed formulation (IPi), its linear relaxation (LPi), and when possible to the integer and relaxed
solutions of a timeindexed formulation for this problem (IPt and LPt respectively). Although we
do not explicitly give these two last formulations, we use them to help us understand whether the
optimality gap is a consequence of the rounding in the algorithm or due to the gap in the interval
relaxation of the LP. Because the IPt formulation is nonpolynomial in size, it becomes impractical
to solve it for large instances, and thus, we have to use the LPi solution as a proxy to estimate
our empirical approximation ratio, and thus the real approximation ratio is likely to be better. All
simulations were done in Matlab, using Gurobi [
13
] and Gurobi MEX [
31
] to solve the IP and LP
relaxations of each instance. Figure 2shows a summary of simulation results for all the diﬀerent
cases and instance sizes. For large instances (
n≥
50) the ratios were computed comparing the
algorithm’s output with the LPi and not the IPt solution∗.
Figure 3a shows further details for the total weighted tardiness case with instances of
n
= 500
jobs. In this ﬁgure we display the full histogram of the approximation ratios. We believe that the
full histogram gives a better understanding of how the algorithm performs as compared to just
7
(a) SAIRA/LPi Ratio for n= 500, 20,002 instances. (b) LPi/IPt Ratio for n= 10, 20,720 instances.
Figure 3: SAIRA Experimental Approximation Ratio for 1precPwiTi.
reporting an average value or a worst case value. In the histogram we highlight the average value for
all simulations and the 99
.
5% quantile and for both measures we also display the 99
.
99% conﬁdence
intervals, shown as doted lines around the corresponding value.
Although the performance shown in ﬁgure 3a is very good, the real approximation ratio is likely
to be even better since, as shown in ﬁgure 3b, the average gap between the IPt and LPI solutions
is 0
.
8. Additionally, we computed the minimum speedup required in each instance so that the
schedule determined by the SAIRA algorithm would have the same cost as the optimal schedule.
Figure 4shows that only a small speedup is required, being 1
.
053 the maximum speedup required
among all the instances.
We repeated the same analysis for the 1
precPwiC2
i
problem. Figures 5a and 5b show details
of some of the simulated settings. Since the cost function is quadratic in
Ci
the performance is even
better than the total weighted tardiness case and the required speedup is smaller, with a maximum
speedup of 1
.
035. As expected, when the
T2
i
metric was used the performance was also better than
when using the Timetric.
5. Conclusions
We suspect that this methodology could be further extended to other
α
point based algorithms
to obtain smaller speed scaling ratios for the scheduling problems presented here, or even construct
new algorithms for other settings such as multiple machines or other scheduling metrics.
Acknowledgements
This research was partially supported by NSF grants CCF0728733 and CCF0915681; NSF
grant DMS1016571, ONR grant N000140310514, and DOE grants DEFG0208ER25856 and DE
AR0000235; and Fulbright/Conicyt Chile.
Figure 4: Minimum SpeedUp Required for 1precPwiTi, for n= 10.
8
(a) SAIRA/LPi Ratio for n= 100, 20,010 instances. (b) Minimum SpeedUp Required for n= 10.
Figure 5: SAIRA Experimental Approximation Ratio for 1precPwiC2
i
References
[1]
Alidaee, B. Single machine scheduling with nonlinear cost functions. Computers & operations
research 18, 3 (1991), 317–322.
[2]
Alidaee, B. Numerical Methods for Single Machine Scheduling with NonLinear Cost Functions
to Minimize Total Cost. The Journal of the Operational Research Society 44, 2 (Feb. 1993),
125.
[3]
Bagga, P., and Kalra, K. NoteA Node Elimination Procedure for Townsend’s Algorithm
for Solving the Single Machine Quadratic Penalty Function Scheduling Problem. Management
Science 26, 6 (1980), 633–637.
[4]
Bansal, N., Chan, H.L., Khandekar, R., Pruhs, K., Stein, C., and Schieber, B.
NonPreemptive MinSum Scheduling with Resource Augmentation. In 48th Annual IEEE
Symposium on Foundations of Computer Science (FOCS’07) (Oct. 2007), IEEE, pp. 614–624.
[5]
Bansal, N., and Pruhs, K. The Geometry of Scheduling. In 2010 IEEE 51st Annual
Symposium on Foundations of Computer Science (Oct. 2010), IEEE, pp. 407–414.
[6]
Chekuri, C., Motwani, R., Natarajan, B., and Stein, C. Approximation Techniques
for Average Completion Time Scheduling. SIAM Journal on Computing 31, 1 (2001), 146.
[7]
Cheung, M., and Shmoys, D. A PrimalDual Approximation Algorithm for MinSum
SingleMachine Scheduling Problems. Approximation, Randomization, and Combinatorial
Optimization. Algorithms and Techniques (2011), 135–146.
[8]
Croce, F. D., Szwarc, W., Tadei, R., Baracco, P., and di Tullio, R. Minimizing the
weighted sum of quadratic completion times on a single machine. Naval Research Logistics 42,
8 (Dec. 1995), 1263–1270.
[9]
Goemans, M. X. Improved approximation algorthims for scheduling with release dates.
ACMSIAM symposium on Discrete algorithms (1997), 591–598.
[10]
Goemans, M. X., Queyranne, M., Schulz, A. S., Skutella, M., and Wang, Y. Single
Machine Scheduling with Release Dates. SIAM Journal on Discrete Mathematics 15, 2 (2002),
165.
9
[11]
Graham, R., Lawler, E. L., Lenstra, J. K., and Rinnooy Kan, A. H. G. Optimization
and approximation in deterministic sequencing and scheduling: a survey. Discrete optimization
5(1979), 287–326.
[12]
Gupta, S. K., and Sen, T. On the Single Machine Scheduling Problem with Quadratic
Penalty Function of Completion Times: An Improved Branching Procedure. Management
Science 30, 5 (1984), 644–647.
[13] Gurobi Optimization, I. Gurobi Optimizer Reference Manual, 2012.
[14]
Hall, L. A., Schulz, A. S., Shmoys, D. B., and Wein, J. Scheduling to Minimize
Average Completion Time: OﬀLine and OnLine Approximation Algorithms. Mathematics of
Operations Research 22, 3 (Aug. 1997), 513–544.
[15]
Hall, L. A., Shmoys, D. B., and Wein, J. Scheduling to minimize average completion time:
oﬀline and online algorithms. In Proceedings of the seventh annual ACMSIAM symposium
on Discrete algorithms (Philadelphia, PA, USA, Aug. 1996), SODA ’96, Society for Industrial
and Applied Mathematics, pp. 142–151.
[16]
H
¨
ohn, W., and Jacobs, T. An experimental and analytical study of order constraints
for single machine scheduling with quadratic cost. Proc. of the 14th Workshop on Algorithm
Engineering and Experiments (ALENEX) (2012), 103–117.
[17]
Kalyanasundaram, B., and Pruhs, K. R. Speed is as powerful as clairvoyance. Journal of
the ACM 47, 4 (July 2000), 617–643.
[18]
Lawler, E. L. A “pseudopolynomial” algorithm for sequencing jobs to minimize total
tardiness. In Studies in integer programming (Proc. Workshop, Bonn, 1975) (Bonn, 1977),
vol. 1, pp. 331–342.
[19]
Lawler, E. L., and Moore, J. M. A Functional Equation and its Application to Resource
Allocation and Sequencing Problems. Management Science 16, 1 (Sept. 1969), 77–84.
[20]
Mondal, S. A., and Sen, A. K. An improved precedence rule for single machine sequencing
problems with quadratic penalty. European Journal of Operational Research 125, 2 (Sept.
2000), 425–428.
[21]
Moore, J. M. An n job, one machine sequencing algorithm for minimizing the number of late
jobs. Management Science 15, 1 (1968), 102–109.
[22]
Phillips, C. A., Stein, C., Torng, E., and Wein, J. Optimal timecritical scheduling via
resource augmentation. Algorithmica 32, 2 (2002), 163–200.
[23]
Phillips, C. A., Stein, C., and Wein, J. Minimizing average completion time in the
presence of release dates. Mathematical Programming 82, 12 (June 1998), 199–223.
[24]
Pinedo, M. Scheduling: Theory, Algorithms, and Systems, 3rd ed. Springer New York, New
York, NY, 2008.
[25]
Pruhs, K. R., Sgall, J., and Torng, E. 15. Online Scheduling. In Handbook of Scheduling:
Algorithms, Models, and Performance Analysis. 2004.
[26]
Schaller, J., and Valente, J. M. Minimizing the weighted sum of squared tardiness on a
single machine. Computers & Operations Research 39, 5 (May 2012), 919–928.
10
[27]
Schild, A., and Fredman, I. J. Scheduling tasks with deadlines and nonlinear loss functions.
Management Science 9, 1 (1962), 73–81.
[28]
Skutella, M. List Scheduling in Order of
α
Points on a Single Machine. vol. 3484 of Lecture
Notes in Computer Science. Springer, 2006, pp. 250–291.
[29]
Sleator, D. D., and Tarjan, R. E. Amortized eﬃciency of list update and paging rules.
Communications of the ACM 28, 2 (Feb. 1985), 202–208.
[30]
Townsend, W. The single machine problem with quadratic penalty function of completion
times: a branchandbound solution. Management Science 24, 5 (1978), 530–534.
[31]
Yin, W. Gurobi Mex: A MATLAB interface for Gurobi. Online at
http://convexoptimization.com/wikimization/index.php/gurobi mex.
11