Single machine scheduling with job-dependent convex cost and arbitrary precedence constraints

Abstract

In this work we combine resource augmentation and alpha-point 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 non-decreasing 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)O(1)-speed 11-approximation algorithm and our numerical experiments show that the speed-scaling ratio required is close to 11.

Full text

Single Machine Scheduling with Job-Dependent Convex Cost and Arbitrary
Precedence Constraints
Rodrigo A. Carrasco∗, Garud Iyengar, Cliff Stein
Department of Industrial Engineering & Operations Research, Columbia University, New York, NY
Abstract
In this work we combine resource augmentation and alpha-point 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 non-decreasing 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 1-approximation algorithm and our numerical
experiments show that the speed-scaling ratio required is close to 1.
Keywords: scheduling, approximation algorithms, speed scaling, alpha-points, job-dependent
convex cost, weighted tardiness
1. Introduction
We consider the following offline 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 non-decreasing 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
non-preemptive. For simplicity we will use the three-field notation [
11
], and denote this problem as
1|prec|Pfi(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
.
75-approximation algorithm for the
PiwiC2
i
problem.
Some additional examples can be found in [
1
,
2
,
3
,
8
,
12
,
20
,
21
]. The first major breakthrough
with general, possible non-convex, cost functions was due to Bansal and Pruhs [
5
], who developed a
O
(
log log nP
)-approximation algorithm for the 1
|ri, pmtn|Pfi(Ci)
problem. For the special case
with no release dates (i.e.
ri≡
0) this algorithm is a 16-approximation algorithm. Later, Cheung
and Shmoys [
7
] presented a pseudo-polynomial (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 (Cliff Stein)
Final version available at https://doi.org/10.1016/j.orl.2013.05.008
2013. This manuscript version is made available under the CC-BY-NC-ND 4.0 license
http://creativecommons.
org/licenses/by-nc-nd/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 (defined as
Li
=
Ci−di
) and tardiness (defined as
Ti
=
max{
0
, Ci−di}
). The total tardiness problem is
NP-Hard even in the case without release dates or precedence constraints [
18
,
19
], and thus the total
weighted tardiness is also NP-Hard. 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 2-machine, 24-speed, 4-approximation ratio for the 1
|ri|PwiTi
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 just-in-time type processes. In
this setting only branch-and-bound algorithms have been proposed to solve it [26].
In this paper we propose an algorithm for the setting with job-dependent 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 defined 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 different
α
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 worst-case approxi-
mation ratio criterion, and has helped explain why some algorithms perform much better in practice
than their worst-case 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 first
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 flow time
scheduling problem. Although it is known that there are no constant factor non-clairvoyant on-line
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 defined an
s
-speed
ρ
-approximation algorithm, as an algorithm that
achieves a
ρ
worst-case approximation ratio when jobs run at
s
times the nominal speed of the
machine. In [
22
] they also defined an
m
-machine
s
-speed
ρ
-approximation algorithm, in which the
algorithm achieves the worst-case 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
on-line 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

job-dependent 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 speed-scaling
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 significantly superior
to the theoretical bounds.
Main Result. Our main result is the following
Theorem 1.1. Given njobs with arbitrary precedence constraints and convex non-decreasing cost
functions
fi(Ci)
, there is a
O
(1)-speed 1-approximation algorithm for the problem of non-preemptively
minimizing the total nonlinear cost Pfi(Ci).
The speed scaling constant is relatively small. Given
 >
0 our algorithm is a (4 +

)-speed
1-approximation 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
Time-indexed IP formulations for scheduling problems are not typically of polynomial size,
therefore, we extend the polynomial size interval-indexed 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 specific
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 suffers a small degradation. In Section 2we describe this
interval-indexed 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, specifically 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 speed-scaling 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
job-dependent non-decreasing 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. Interval-Indexed Formulation
We now modify and extend the interval-indexed formulation proposed by Hall et al. [
14
] for
the total nonlinear cost setting. The interval-indexed 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 define 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 finish 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 finish in an interval earlier than
i1
. Note that, although the function
fi(Ci)
is non-linear,
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 finish in the same interval have the right order.
3. Approximation Algorithm for Total Job-dependent Nonlinear Cost
We now describe the speed scaling and
α
-point based algorithm for the total job-dependent
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 defined as,
Iα
i
=
min t:Pt
u=1 ¯xiu ≥α
. Since several jobs may finish in the same interval, let
Jt
=
{i
:
Iα
i
=
t}
denote the set of jobs that finish 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 finally 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 non-decreasing 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 i-th 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 definition 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 first 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, 1-approximation
algorithm for the total weighted non-linear cost problem with convex non-decreasing cost and arbitrary
precedence constraints, 1|prec|Pfi(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 finish in time
interval
t
, and since
¯xit
is the optimal solution of the linear relaxation and
fi(C)
is non-decreasing
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 define
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 finished in a certain
interval.
Since the tardiness metric
Td
i
, with
d≥
1, is convex and non-decreasing, we have the following
6

Problem Instances Size (n) Average Ratio 99.5% Worst Ratio
1|prec|PwiTi
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
1|prec|PwiC2
i
20,010 10 0.052 0.053 0.055
20,010 100 0.059∗0.059 0.059
1|prec|PwiT2
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,
1-approximation algorithm for the total weighted tardiness with arbitrary precedence constraints,
1|prec|PwiTd
i.
For the specific 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 1|prec|PwiCd
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 significant degradation in the performance.
We compared the output of our algorithm with the integer solution of the interval-and-speed-
indexed formulation (IPi), its linear relaxation (LPi), and when possible to the integer and relaxed
solutions of a time-indexed 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 non-polynomial 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 different
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 figure 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 1|prec|PwiTi.
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% confidence
intervals, shown as doted lines around the corresponding value.
Although the performance shown in figure 3a is very good, the real approximation ratio is likely
to be even better since, as shown in figure 3b, the average gap between the IPt and LPI solutions
is 0
.
8. Additionally, we computed the minimum speed-up 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 speed-up is required, being 1
.
053 the maximum speed-up required
among all the instances.
We repeated the same analysis for the 1
|prec|PwiC2
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 speed-up is smaller, with a maximum
speed-up 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 CCF-0728733 and CCF-0915681; NSF
grant DMS-1016571, ONR grant N000140310514, and DOE grants DEFG02-08ER25856 and DE-
AR0000235; and Fulbright/Conicyt Chile.
Figure 4: Minimum Speed-Up Required for 1|prec|PwiTi, for n= 10.
8

(a) SAIRA/LPi Ratio for n= 100, 20,010 instances. (b) Minimum Speed-Up Required for n= 10.
Figure 5: SAIRA Experimental Approximation Ratio for 1|prec|PwiC2
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 Non-Linear 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.
Non-Preemptive Min-Sum 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 Primal-Dual Approximation Algorithm for Min-Sum
Single-Machine 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.
ACM-SIAM 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: Off-Line and On-Line 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:
off-line and on-line algorithms. In Proceedings of the seventh annual ACM-SIAM 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 time-critical 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, 1-2 (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 non-linear 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 efficiency 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 branch-and-bound 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