Approximation Algorithms for Shop Scheduling Problems with
Minsum Objective ∗†
Maurice Queyranne‡
Maxim Sviridenko§
April 29, 1999
This paper is dedicated to Elisabeth Inger L. on the day of her birth.
Abstract
We consider a general class of multiprocessor shop scheduling problems, preemptive or nonpreemptive, with precedence constraints between operations, with job or operation release dates,
and with a class of objective functions including weighted sums of job, operations and stage completion times. We present a general approximation method combining a linear programming
relaxation in the operation completion times, with any algorithm for the makespan version of
these problems without release dates. If the latter produces a schedule with makespan no larger
than ρ times the “trivial lower bound” consisting of the largest of all stage average loads (or
“congestion”) and job lengths (or “dilation”), then our method produces a feasible schedule with
minsum objective no larger than 2eρ times the optimum where 2e ≈ 5.44. This leads in particular to a polynomial time algorithm with polylogarithmic
performance
P guarantee for the minsum
P
multiprocessor dag-shop problem J(P )|rij , dagj | S wS CS where S wS CS is a general minsum objective including weighted sum of operation and job completion times, stages makespans
and others, whereas the best known earlierP
performance guarantees were O(m) (where m
P is the
number of stages) for the
special
cases
J||
C
(Gonzalez
and
Sahni,
1978),
F
(P
)|r
|
wj Cj
j
j
P
(Schulz, 1996) and O|| Cj (Achugbue and Chin, 1982). We also obtain
a
O(1)
performance
P
guarantee for the acyclic job shop problem J|pij = 1, acyclic − dagj | S wS CS with unit processing times and weighted sum of operation (or job) completion time objective. Our results
extend to a broad class of minsum objective functions including some convex objectives related
to load balancing. We
P then present an improved 5.83-approximation algorithm for the open
shop problem O|rj | wj Cj with total weighted job completion time objective. We conclude
with a very simple method which yields O(m)-approximation algorithms for various job shop
problems (preemptive, nonpreemptive, and no-wait) with m single-processor stages and total
weighted job completion time objective.
1
Introduction
Approximation algorithms have been developed during the past three decades for many scheduling
problems with minmax objective—primarily the makespan. In contrast, scheduling problems with
minsum objective—typically, a weighted sum of completion times—have only recently received
∗
Research supported by a research grant from NSERC (the Natural Sciences and Research Council of Canada) to
the first author.
†
An extended abstract of this work has been published in Proceedings of SODA00 [28]
‡
Faculty of Commerce and Business Administration, University of British Columbia, Vancouver, B.C., Canada
V6T 1Z2; Email: Maurice.Queyranne@commerce.ubc.ca
§
IBM T. J. Watson Research Center, P.O. Box 218, Yorktown Heights, NY 10598, USA; Email: sviri@us.ibm.com
1
extensive attention. Many results for the makespan shop scheduling problems use a trivial lower
bound which is the largest of (i) the maximum stage average load, also known as “congestion”
[21], and (ii) the maximum job length, or “dilation” (ibid.). On the other hand, two of the most
successful tools for the minsum problems have been the use of time intervals with geometrically
increasing lengths (as in in Hall et all. [15, 16] and Chakrabarti et al. [6]) and linear programming
relaxations (see Queyranne and Schulz [26], Skutella [37] and Shmoys [35] for extensive reviews and
references). In this paper, we combine these three techniques—makespan approximation algorithms
relative to the trivial lower bound, geometric time intervals, and linear programming relaxations—
to obtain a general approximation method for large classe of scheduling problems with minsum (and
related) objective. All scheduling problems studied in the paper are denoted using the standard
three-field notations; see [18] for definitions.
Our main result is the following: if there exists a polytime algorithm for a class of multiprocessor
job shop problems which guarantees a makespan no larger than ρ times the trivial lower bound, then
we obtain a polytime algorithm for the minsum version of the problem, with release dates, which
guarantees an objective value no larger than 2eρ times the optimum where e ≈ 2.718 is the base
of the natural logarithms. This yields algorithms with the best known performance guarantees for
various classes of job shop, flow shop and open shop problems with minsum and related objectives.
We also present an improved version of this algorithm, with performance guarantees 5.83, for the
P
open shop problem with release dates O|rj | wj Cj with weighted sum of job completion times
objective. This approximation factor is slightly weaker than the (5.78 + ε)-approximation factor
P
obtained by Chakrabarti et al. [6] for the open shop problem Om|rj | wj Cj with fixed number m
of machines. On the other hand, our algorithm, which uses a novel idea of ”LP-based job precedence
constraints” derived from LP-solution, is polynomial for any number of machines. We also present
P
a simple 3-approximation algorithm for the preemptive problem O|rj , pmtn| wj Cj . In contrast
with the other algorithms in this paper, it is a simple job-based greedy algorithm using directly
the LP-solution without recourse to geometrically increasing time intervals. Its approximation
P
factor is also slightly weaker than the (2.89 + ε)-approximation factor for Om|rj , pmtn| wj Cj in
Chakrabarti et al. [6], but again our algorithm is polynomial for any number of machines. Notice
also that recently (2+ε)-approximation algorithms for generalized preemptive open shop scheduling
problems with minsum objective were obtained in [28]. On the other hand, Hoogeveen et al. [17]
P
P
have shown that the problems F || Cj and O|| Cj are MAX-SNP-hard, hence there is no hope
for obtaining approximation guarantees arbitrarily close to 1 for these problems, unless P = N P.
Our approach applies to a broad class of shop scheduling problems defined as follows. The
shop consists of m stages, where stage Pi consists of mi identical parallel machines (or processors).
Each machine can process at most one operation at a time. A set of n jobs must be processed
in this shop, where job Jj consists of µj operations Ohj (h = 1, . . . , µj ), each of which must be
processed on one machine in a specified stage for phj time units. There are three types of constraints
on the operations Ohj of each job Jj : (i) no two operations of a same job Jj may be performed
simultaneously; (ii) each operation Ohj may have a specified release date rhj ; and (iii) there may be
precedence constraints between operations (of a same job, or of different jobs) forming a directed
acyclic graph.
We consider both nonpreemptive and preemptive scheduling; in the former, every operation
must be processed without interruption, while it may be interrupted at any point in time and
resumed later at no penalty or delay in the latter. We seek a feasible schedule which minimizes the
P
minsum objective S wS CS where CS = maxOhj ∈S Chj and Chj is the completion time of operation
Ohj in the schedule. This objective function includes few interesting special cases: operation
completion times (S = {Ohj }), job completion times (S = {O1j , . . . , Oµj j }), stage completion
times and makespan. Our general objective function also includes all variants of weighted sums of
2
above special cases. This composite objective may represent total costs, including deferral costs for
operations and entire jobs, such as holding costs, delay penalties and opportunity costs; and rental
costs for the individual stages and for the whole shop. In this paper we will consider instances with
polynomial number of different sets S and wS > 0 for all sets S.
We present a linear programming (LP) relaxation for the multiprocessor job shop problem
presented above, where the variables are the operation completion times Chj and the set completion
times CS . This LP relaxation includes five types of linear inequality constraints: (i) a release date
constraint Chj ≥ rhj + phj for each operation Ohj ; (ii) a precedence constraint Chk ≥ Cgj + phk for
each intransitive precedence relation “Ogj precedes Ohk ”; (iii) a set of “stage capacity constraints”
for each stage, see equation (5) below; (iv) a set of “job capacity constraints” for each job; and (v) a
set of constraints defining the set completion times CS ≥ Chj for all Ohj ∈ S. Relaxations including
the first three types of constraints have been proposed earlier, by Wolsey [39] and Queyranne [24, 25]
for single machine problems, and by Schulz [30] (see also [16]) for parallel machines and flow shop
problems. They were also used (with limited computational success) by Applegate and Cook [4] in
their computational study of the classical job shop problem with makespan objective. The fourth
set of constraints is a novel feature of this relaxation; it allows us to take into account the job lengths
in our analysis of the relaxation and approximation algorithm. In spite of its exponential number
of constraints, this LP relaxation is solvable in polynomial time since the separation problem for
these constraints is itself solvable in polynomial time [25].
We use an optimal solution C LP to this LP relaxation as the basis for our approximation
algorithm. We first partition all operations into the subsets O(k) (k = 0, 1, 2, . . . ,) of operations
LP < βek+1 where β ∈ [e−1 , 1] is some random
with LP completion times satisfying βek ≤ Chj
variable. We note that we have a polynomial number of nonempty subsets O(k) . Ignoring for now
the release dates, each of the nonempty subsets O(k) defines an instance I (k) of the makespan job
shop problem J(P )|prec|Cmax restricted to O(k) . Applying a ρ-approximation algorithm (relative
to the trivial lower bound) to each of these instances I (k) produces a partial schedule C (k) (starting
at time 0) for all operations in O(k) . We then concatenate these partial schedules C (k) . We show
P
that approximate schedule is feasible for the original problem J(P )|rj , prec| wS CS . We prove
that expected value of this schedule is at most 2eρ of the LP lower bound.
Using known makespan approximation algorithms, we obtain the following approximation bounds
for weighted sum of operations (or job) completion times objectives. For the first three results,
we use the reduction from the multiprocessor makespan problem J(P )|dagj |Cmax to the singleprocessor makespan problem J|dagj |Cmax due to Shmoys et al. [36].
P
• O((log(mµ)/ log log(mµ))2 ) for the job shop problem J(P )|rj , dagj | wS CS (where m is the
number of stages; µ = maxj µj is the largest number of operations per job; and we use the
notation dagj to indicate that the only precedence constraints are between operations of a
same job), using the approximation algorithm of Goldberg et al. [12] for the single-processor
makespan problem. This polylogarithmic performance guarantee dominates1 earlier O(m)
results for:
– the classical job-shop problem J||
Sahni [13]);
P
Cj with mean flow time objective (Gonzalez and
– the multiprocessor flow-shop problem F (P )|rj |
pletion times objective (Schulz [30]); and
– the open shop problem O||
1
P
P
wj Cj with weighted sum of job com-
Cj with mean flow time objective (Achugbue and Chin [1]).
Except for the case of “very long jobs”, discussed in Section 6.
3
• O(log(mµ)/ log log(mµ)) for the unit-processing-time job shop problem J(P )|rj , phj = 1, dagj |
using a unit-processing-time version of the Goldberg et al. algorithm (ibid.).
P
wS CS
P
• O log m · log1+ε log m for the acyclic job shop problem J(P )|rj , acyclic-dagj | wS CS (in an
acyclic job shop each job visits each stage at most once) using algorithms for J|acyclic-dagj |Cmax
from [10, 9]
P
• O(1) for the acyclic unit-processing-time job shop problem J(P )|rj , phj = 1, acyclic-dagj | wS CS
using the makespan algorithm of Leighton et al. [21, 22] for the corresponding single-processor
makespan problem J|phj = 1, acyclic-dagj |Cmax .
P
• 10.88 for the multiprocessor minsum open shop problem O(P )|rj | wS CS with release dates,
using the 2-approximation algorithm of Schuurman and Woeginger [33] for O(P )||Cmax .
P
• 5.44 for the preemptive version O(P )|rj , pmtn| wS CS of the preceding open shop problem,
using a result of Lawler et al. [20] that the trivial lower bound is achievable for O(P )|pmtn|Cmax
and a corresponding polytime algorithm.
All these new approximation bounds, which are summarized in Table 1, strictly improve upon
known results. Furthermore, any new makespan result (relative to the trivial lower bound) for
problems of this type will lead to a corresponding approximation result for the minsum version
of the same problem, with release date constraints added. Note that these results also imply
bounds on the performance of our LP relaxation. Since the LP lower bound is valid for preemptive
schedules, the approximation results above also apply to the preemptive problems (though our
approximation bound of 5.44 for preemptive multi-processor open shop problems is already better
than our nonpreemptive bound of 10.88), and they also bound the gap between optimum preemptive
and nonpreemptive schedules. Since the bounds we obtain are operation-by-operation bounds (see
(11)), they imply similar approximation results for a large class of objective functions, including
some convex objectives related to load balancing, which we discuss briefly at the end of Section 4
below.
We also present two related results for weighted sum of job completion times objectives. First,
P
we consider the open shop problem O|rj | j wj Cj . We propose a simplified and strengthened LP
relaxation, and a more effective approximation algorithm, resulting in a 5.83 performance guarantee.
P
Using the same LP relaxation we obtain a 3-approximation for O|rj , pmtn| j wj Cj . Next, we
present a very simple approach to (single processor) shop scheduling problems with very long jobs,
that is, where m = o((log(mµ)/ log log(mµ))2 )) (for example, if µ = 2m ), for which the preceding
performance guarantee may be worse than O(m). For these problems, we propose a single machine
relaxation, using a speed-m machine. Whenever the resulting preemptive single-machine minsum
scheduling problem is approximable in polynomial time within a constant factor α, we obtain
a heuristic for the original preemptive problem with performance guarantee α m. Furthermore,
if we can construct in polynomial time a nonpreemptive single-machine schedule with objective
value within a constant factor β of the preemptive single-machine optimum, then we obtain a
nonpreemptive and no-wait schedule with objective value within a factor β m of the optimum for
the original minsum job shop problem. These observations yield very simple O(m)-approximations,
summarized in Table 2, for the (very long job version of) the shop scheduling problems mentioned
above.
It may be interesting to note, in reference to the discussion of types of list scheduling algorithms
in Munier et al. [23], that our open shop algorithm uses a variant of “machine-based” (or “nonidling”) scheduling (Section 5), that our job shop algorithm for very long jobs uses “job-based” list
4
scheduling (Section 6), and that our main job shop algorithm in Section 4 combines a makespan approximation algorithm, which in most cases is a machine-based list scheduling one, for constructing
the partial schedules, with a simple method similar to job-based list scheduling for concatenating
the resulting partial schedules.
The contents of this paper are as follows. In Section 2, we present the notations and assumptions used for our general result. We introduce and discuss our LP relaxation in Section 3, and
our approximation algorithm in Section 4. The improved open shop approximation algorithm is
presented in Section 5 and the simple O(m) method for job shop problems with very long jobs in
Section 6. Results from Sections 4 and 5 are summarized in Table 1, and those from Section 6 in
Table 2.
2
Notations and assumptions
An instance I of the minsum job shop problem J(P )|rj , prec|
P = (P1 , . . . , Pm ) is the set of stages;
P
wS CS is defined as follows:
stage Pi consists of mi identical parallel machines (or processors) (mi ≥ 1).
J = (J1 , . . . , Jn ) is the set of jobs;
job Jj consists of a set of µj operations O1j , . . . , Oµj j , where Ohj must be processed without interruption on one machine in stage m(h, j) for phj time units, where phj is the given processing
time of operation Ohj . No two operations on a same job may be performed simultaneously.
Let Oi be the set of all operations Ohj which must be processed on stage Pi , i.e., such that
m(h, j) = i, and let O = ∪i Oi denote the set of all operations.
There are two additional types of constraints on the operations:
≺ denotes the precedence constraints between operations: Ogj ≺ Ohk means that operation Ogj
must be completed before operation Ohk can start; operation Ogj is a predecessor of Ohk and
Ohk is a successor of Ogj ; we assume that ≺ defines a (strict) partial order, i.e., an acyclic
digraph or dag;
rhj ≥ 0 is the release date of operation Ohj ; w.l.o.g., we may assume that the release dates are
compatible with the precedence constraints, that is, rgj + pgj ≤ rhk whenever Ogj ≺ Ohk .
Finally, let U ∈ 2O be a set of operations sets. We assume that all sets are given explicitly in
the input and therefore |U | is bounded by a polynomial of the input length. Let wS > 0 denote
the weight of set S ∈ U .
The problem is to schedule all operations on machines in the prescribed stages, and in the sequence prescribed by the precedence constraints between operations, so as to minimize the weighted
P
sum S∈U wS CS of set completion times CS = maxOij ∈S Cij . We are interested in both the preemptive and nonpreemptive versions of this job shop problem.
P
As was noted in the Introduction the function S∈U wS CS includes few natural objective functions as special cases: the operation completion times (S = {Ohj }); the job completion times
(S = {O1j , . . . , Oµj j }); the stage makespans S = Oi ; the overall makespan S = O.
We assume that all phj and rhj are nonnegative integers. Zero processing times (phj = 0) and
release dates (rhj = 0) are allowed, but we assume w.l.o.g. that rhj + phj ≥ 1 for all Ohj , since
5
all operations with zero processing time and release date may be performed at time zero without
increasing the objective value or affecting the rest of the schedule.
P
We define the average load of stage Pi as Li = (1/mi ) (h,j)∈Oi phj and the length of job Jj as
P
ℓj = h phj . The trivial lower bound for the corresponding makespan problem is max{maxi Li , maxj ℓj }.
3
A linear programming relaxation
As mentioned in the Introduction, the following LP relaxation extends to job shop problems earlier
relaxations introduced by Wolsey [39] and Queyranne [24, 25], and recently used by several authors
for a variety of minsum scheduling problems; see [26] and [37] for extensive reviews and references.
minimize
X
wS CS
(1)
S∈U
s.t. CS ≥ Chj ,
Chj ≥ rhj + phj ,
X
Chk ≥ Cgj + phk ,
Ohj ∈A
X
h∈B
where
phj Chj ≥ fi (A),
phj Chj ≥ gj (B),
Ohj ∈ S, S ∈ U ;
(2)
Ogj ≺ Ohk ;
(4)
Ohj ∈ O;
(3)
A ⊆ Oi , i = 1, . . . , m;
(5)
B ⊆ {1, . . . , µj }, Jj ∈ J ;
(6)
2

1  X
1 X 2
fi (A) =
p
phj  +
2mi O ∈A
2 O ∈A hj
hj
hj
and
2

1 X
1 X 2
gj (B) = 
p .
phj  +
2 h∈B
2 h∈B hj
The objective is the weighted sum of sets completion times, and constraints (3) and (4) are the
release date and precedence constraints, respectively. Constraints (5) form (a relaxation of) the
stage capacity constraints. They prevent too much work from being completed too early on each
stage, and are valid for both preemptive and nonpreemptive schedules. They are parallel machine
extensions, introduced by Schulz [29], of the single machine inequalities of Wolsey and Queyranne;
see [30] or [16] for a proof of their validity. Constraints (6) are a new feature of this work. They
may be interpreted as “job capacity constraints”, and their validity follows from the requirement
that no two operations of the same job may be processed simultaneously. They have the same
mathematical structure as the single-machine capacity constraints (5), except that they correspond
to subsets of operations on a same job. A physical interpretation is that every job may be considered
as a “resource” with unit capacity. Note that these job capacity constraints are implied by the
release date and precedence constraints (3) and (4) when a job consists of a chain (totally ordered
set) of operations, such as in flow shop and “classical” job shop problems.
The LP-relaxation (1)–(6) has one variable per operation, but an exponential number of constraints (5) and (6). Since the separation problem for these constraints can be solved in polynomial
time (Queyranne [25]), it follows that the LP (1)–(6) can itself be solved in polynomial time [14].
6
In the sequel, we let C LP denote an optimum solution to the LP (1)–(6). By the release date
LP ≥ 1 for all operations O . Let
constraints (3) and a preceding observation, we have Chj
hj
T = max rhj +
h,j
X
ph,j .
(7)
h,j
LP ≤ T for all operations O . Indeed, it is easy to verify that (i) a
We may assume that Chj
hj
LP
(componentwise) minimal optimal solution C
(i.e., such that C ′ ≤ C LP for an optimal C ′
′
LP
implies C = C ) satisfies these upper bound constraints and (ii) for any instance where whj > 0
for all operations Ohj without successor, an optimal LP solution must be minimal. (Alternately,
we might directly add the constraints Chj ≤ T to the above LP; indeed, note that any schedule in
which an operation completes later than date T must include some time interval between 0 and T
when all machines are idle, and may therefore be shortened; thus attention may be restricted to
schedules in which all operations complete no later than date T .) We use the vector inequalities
LP ≤ T for all O
1 ≤ C LP ≤ T to represent the inequalities 1 ≤ Chj
hj ∈ O.
Summarizing the preceding observations, we have:
Proposition 3.1 Consider the shop scheduling problem defined in Section 2. Then one can find
in polynomial time an optimal solution C LP to the LP-relaxation (1)–(6) such that 1 ≤ C LP ≤ T
P
P
LP ≤ OPT, where OPT denotes the optimal objective
and S∈U wS CSLP = S∈U wS maxOhj ∈S Chj
value of the preemptive scheduling problem and T is defined in (7) above.
As in earlier work using this type of LP relaxations for defining approximation algorithms, we
use the LP relaxation in three ways. First, it provides a lower bound on the optimum objective value
OPT, against which the objective value of a heuristic schedule may be compared. Next, we use the
optimal LP solution C LP as a guide in the construction of a heuristic nonpreemptive schedule C H ;
in particular, we exploit the release date and precedence constraints (3) and (4) to ensure that the
heuristic schedule C H is feasible. Third, we use the stage and job capacity constraints (5) and (6)
H ≤ 2eβρ C LP for all operations O
to derive operation-by-operation bounds Chj
hj and fixed parameter
e−1 hj
β ∈ [e−1 , 1]. These operation-by-operation bounds imply the 2eρ performance guarantee for our
randomized algorithm.
A key result in deriving these operation-by-operation bounds is the following lemma, due to
Schulz [30]:
Lemma 3.2 (Schulz’s Lemma for stage Pi ) If C satisfies the stage capacity constraints (5) for
stage Pi then for all dates θ > 0,
X
1
pgk ≤ 2 θ
mi (g,k)∈S[i,θ]
where S[i, θ] = {Ogk : m(g, k) = i and Cgk ≤ θ} is the set of operations on stage Pi with “LP
completion time” Cgk no later than θ.
Proof.
have
From the definition of S[i, θ] and the stage capacity constraint (5) for set A = S[i, θ], we


X
(g,k)∈S[i,θ]
and the lemma follows.

pgk  θ ≥
X
(g,k)∈S[i,θ]
pgk Cgk

2
1  X
pgk 
≥ fi (S[i, θ]) ≥
2mi (g,k)∈S[i,θ]
A similar result follows from the job capacity constraints (6):
7
2
Corollary 3.3 (Schulz’s Lemma for job Jj ) If C satisfies the job capacity constraints (6) for
job Jj then for all dates θ > 0,
X
pgj ≤ 2 θ
g∈S ′ [j,θ]
where S ′ [j, θ] = {g : Cgj ≤ θ} is the set of operations on job Jj with LP completion time Cgj no
later than θ.
4
A minsum job shop approximation algorithm
In the first step of our algorithm we find an optimal solution C LP to the linear program (1)–
(6). As discussed above, this can be done in polynomial time and we have 1 ≤ C LP ≤ T , where
P
T = maxh,j rhj + h,j ph,j . Define lg T = ⌈ln T ⌉+1. Let e denote the base of the natural logarithms.
We use a uniform random variable X on [0, 1] to determine a random base point β = e−X . Thus,
at the end of the first step, β is a fixed number satisfying e−1 ≤ β ≤ 1.
.
LP < βek+1 }, i.e.,
In the second step, we define operation subsets O(k) = {Ohj : βek ≤ Chj
LP in interval I = [βek , βek+1 ), for
O(k) is the set of all operations with LP completion times Chj
k
(k)
k = 0, . . . , lg T . Note that the nonempty subsets O form a partition of the set O of all operations,
and that their number 1 + lg T is polynomially bounded. For each nonempty O(k) , we define an
instance I (k) of the makespan job shop problem restricted to the operations in O(k) and ignoring
the release date constraints (but not the precedence constraints between operations). Let
(k)
Li
. 1 X
{phj : Ohj ∈ O(k) and m(h, j) = i}
=
mi
denote the average load of stage Pi in instance I (k) , and let
(k)
ℓj
. X
=
{phj : Ohj ∈ O(k) }
(k) .
(k)
(k) .
(k)
denote the length of job Jj in I (k) . Let Lmax = maxi Li and ℓmax = maxj ℓj denote the maximum
stage load and maximum job length, respectively, in instance I (k). Applying Schulz’s Lemma 3.2
to stage Pi with θ = βek+1 we have
(k)
Li
≤
o
1 Xn
LP
phj : Chj
≤ θ and m(h, j) = i ≤ 2θ ≤ 2βek+1 .
mi
(8)
Similarly, applying Corollary 3.3 to job Jj with θ = βek+1 we have
(k)
ℓi
≤
Xn
o
LP
phv : Chv
≤ θ ≤ 2θ ≤ 2βek+1 .
(9)
Let C (k) denote the completion time vector of the schedule, starting at time 0 and obtained by
applying to I (k) a makespan approximation algorithm with the property that
n
o
n
o
(k)
(k) .
(k)
Cmax
= max Chj : Ohj ∈ O(k) ≤ ρ |I (k) | max L(k)
max , ℓmax
where |I (k) | is the size of instance I (k) and ρ is a nondecreasing function such that ρ |I (k) | ≥ 1.
From inequalities (8) and (9) and ρ(·) nondecreasing, it follows that
(k)
Cmax
≤ 2βek+1 ρ |I (k) | ≤ 2βek+1 ρ (|I|) = 2βek+1 ρ
8
(10)
and we use “ρ” as an abbreviation for “ρ (|I|)” hereafter.
In the third step of our algorithm, we concatenate these partial schedules C (k) into the heuristic
(k) , and keeping
H = 2βek+1 ρ/(e − 1) + C (k) for all operations O
schedule C H by letting Chj
hj ∈ O
hj
the same assignment of operations to the parallel machines at every stage. So, in schedule C H , all
operations in a subset O(k) are completed before the start time of any operation in any later subset
O(q) (q > k), since
(k)
2βek+1 ρ/(e − 1) + Chj ≤ 2βek+1 ρ/(e − 1) + 2βek+1 ρ = 2βek+2 ρ/(e − 1).
Therefore C H is a schedule in which no machine at any stage processes more than one operation
at a time, no job has more than one operation processed at any time, and all operation precedence
LP < βek+1 for O
(k) and ρ ≥ 1, we have
constraints are satisfied. Since rhj + phj ≤ Chj
hj ∈ O
H
k+1
k+1
H
Chj > 2βe ρ/(e − 1) > βe
> rhj + phj , so C also satisfies all release date constraints. This
H
shows that C is a feasible schedule for the original instance I. Using inequality (10) and definition
of O(k) , we have for all Ohj ∈ O(k) ,
H
≤
Chj
2βek+1 ρ
2βek+1 ρ
(k)
LP
+ Cmax
≤
+ 2βek+1 ρ ≤ 2βe2 ρChj
/(e − 1)
e−1
e−1
(11)
H ≤ T . It is
Remark: The heuristic schedule C H may violate the upper bound constraints Chj
possible to rectify this by processing operations as early as possible in the same order as in C H .
It may also be possible to improve on the objective value of the schedule by further modifications,
such as operation interchanges. However, such changes, which may be very useful in practice, are
not needed in our analysis.
The inequality (11) implies the 2eρ performance guarantee of above randomized algorithm
E(
X
S∈U
wS CSH ) =
X
S∈U
2e2 ρ
e−1
H
)≤
wS max E(Chj
Ohj ∈S
Z
0
1
e−X dX
X
S∈U
X
S∈U
LP
/(e − 1)) =
wS max E(2βe2 ρChj
Ohj ∈S
LP
wS max Chj
≤ 2eρOPT.
Ohj ∈S
In fact, a similar performance guarantee applies to a much broader class of objective functions.
.
Let Γ = [1, T ]O denote the set of all vectors C ∈ ℜO such that 1 ≤ C ≤ T . Let W : Γ 7→ ℜ+ be a
nonnegative real-valued function defined on the operation completion time vector C ∈ Γ. Assume
that W satisfies the following properties:
(W1) W is nondecreasing, i.e., W (C) ≤ W (C ′ ) whenever C ≤ C ′ .
(W2) There exists a function F : ℜ+ 7→ ℜ+ such that W (λ C) ≤ F (λ)W (C) for all C ∈ Γ and
scalar λ ≥ 0.
(W3) There exists a nonnegative constant ǫ ≥ 0 such that one can find in polynomial time a
feasible solution C W to the relaxation
W ∗ = min{W (C) : C ∈ Γ and (3)–(6)}
with objective value W (C W ) ≤ (1 + ǫ)W ∗ .
(W4) The value of the following integral is well-defined for all ρ ≥ 1
IN T (ρ) =
Z
1
F
0
9
!
2e2 ρ
dX.
eX (e − 1)
(12)
Property (W3) is satisfied, for instance, if W is convex, can be evaluated in polynomial time for
any C ∈ Γ, and satisfies some additional technical assumptions, so that one can apply the ellipsoid
method to the convex programming problem (12); see [14] for details.
Let C H be the feasible schedule obtained as above, using C W in place of C LP . Properties
(W1)–(W4) of W and the operation-by-operation bound (11) imply that
H
E W (C ) ≤ E W
2βe2 ρ W
C
e−1
!!
≤ IN T (ρ)W (C W ) ≤ IN T (ρ)(1 + ǫ)OPT
where OPT denotes the minimum of W (C) over all feasible schedules C. We have shown:
Theorem 4.1 Consider a class of instances of the makespan job shop problem J(P )|prec|Cmax
for which there exists a polynomial time algorithm producing a feasible schedule with makespan no
larger than ρ times the trivial lower bound (largest of all stage average loads and job lengths), where
ρ may be a nondecreasing function of the size of the instance. Let W be an objective function
satisfying properties (W1)–(W4). Then there exists a polynomial time approximation algorithm
for the scheduling problem J(P )|rhj , prec|W (C) with performance guarantee (1 + ǫ) IN T (ρ).
P
A simple example is the function S wS CS studied in this paper. This function is convex and
satisfies properties (W1)–(W4) with F (λ) = λ, ǫ = 0 and IN T (ρ) = 2eρ.
For another example, consider the job shop problem with an objective to minimize the sum
P
of squared stage makespans i Mi2 where Mi = maxOhj ∈Oi Chj . This objective function is common in load balancing and related problems, see, e.g., Chandra and Wong [7] and Alon et al. [2].
The corresponding function W is convex (since each function C 7→ Mi2 is the composition of a
nondecreasing univariate convex function Mi 7→ Mi2 and a convex function C 7→ maxhj∈Oi Chj )
2 (e+1)
ρ2 . We thus obtain a
and satisfies properties (W1)–(W4) with F (λ) = λ2 and IN T (ρ) = 2e e−1
O(ρ2 ) approximation algorithm for this job shop load balancing problem.
Our randomized algorithm can be simply derandomized by discretizing the probability space.
The simplest way to do it is to consider parameters β ∈ [e−1 , 1] which are powers of 1 + δ for some
small constant δ > 0. Since our performance guarantee is based on operation-by-operation bounds
(11), we can loose only a factor of 1 + δ by such discretizing. It is also possible to show using
more complex argument that by considering polynomially many different values of β we can find a
solution of value at most 2eρ times of optimal value.
5
Improved approximation algorithms for open shop problems
In this section we present a 5.83-approximation algorithm for the single-processor nonpreemptive
P
open shop problem O|rj | wj Cj with weighted sum of job completion times objective and a 3P
approximation algorithm for the preemptive open shop problem O|rj , pmtn| wj Cj . Note that the
method of the preceding sections yields a 10.88-approximation and 5.44-approximation, respectively.
To achieve the improved performance, we modify each of the three steps of our general approach.
The open shop problem we consider here is slightly more general than usual, in that we allow
each job to include any number of operations on every machine. We let pij denote the total
processing time of all operations of job Jj on machine Pi (with pij = 0 if there is no such operation).
We first consider a modified linear programming relaxation, which only includes one variable
Cj per job:
min
X
wj Cj
(13)
10
X
j∈A
pij Cj ≥ fi (A),
Cj ≥ rj + lj ,
A ⊆ {1, . . . , n}, i = 1, . . . , m;
(14)
Jj ∈ J ;
(15)
P
where function fi is as defined in Section 3 with mi = 1, and lj = m
i=1 pij is the length of the job
Jj . Note that the machine capacity constraints (14) follow from the corresponding stage capacity
constraints (5) with mi = 1, using the inequalities Cj ≥ Chj for all operations Ohj ∈ Oi . On the
other hand, the job length inequality constraints (15) replace the job capacity and release dates
constraints but are not implied by the latter. Let C LP denote an optimal solution to (13)–(15).
Notice that the optimal value of this LP is a lower bound both for preemptive and nonpreemptive
open shop problems.
5.1
A 5.83-approximation algorithm for O|rj |
P
w j Cj
In the second step of the algorithm for the nonpreemptive problem, instead of partitioning the
set of all operations, we define a partial order “≺
√LP ” among the jobs as follows: let Jj ≺LP Jk
if and only if γ CjLP < CkLP , where γ = 1 + 12 2 ≈ 1.707. We will use these job precedences
Jj ≺LP Jk in our approximation algorithm to prevent starting job Jk on machine Pi before every
job Jj with “sufficiently early LP completion time” (as defined by the condition γ CjLP < CkLP ) has
been completed on this machine.
In our third step we schedule the operations using “machine-based scheduling” consistent with
these job precedences. Namely, we start at time t = 0 with all jobs without predecessor in ≺LP
and rj = 0 being available for each machine; the availability date of each machine Pi is Ai = 0. We
repeat the following until all job completion times have been determined. Let Pi be a machine with
.
the earliest availability date t = Ai = minh Ah . If there is a job Jj available for machine Pi and not
in process on some other machine at date t then: process Jj on Pi in the time interval [t, t + pij ];
update Ai = t + pij ; declare job Jj not available any more for machine Pi ; and declare available for
machine Pi every job Jk such that Jj ≺LP Jk , rk ≤ t + pij and of which every other predecessor
Jℓ ≺LP Jk has been processed on Pi . (Remark that job Jj may be available for machine Pi even if
some operations of some of its predecessors are not complete on some other machines.) Otherwise
(that is, if there is no job which, at date t, is available for machine Pi and is not in process on some
other machine) update Ai to the minimum between the next smallest machine availability date and
the next smallest release date Ai = min {min{rj : rj > t}, min{Ah : Ah > t}}: machine Pi will be
idle during the time interval [t, Ai ]. Declare job Jj available for machine Pi if rk ≤ Ai and every
other predecessor Jℓ ≺LP Jk has been processed on Pi .
We obtain the following job-by-job bound:
Lemma 5.1 Let C LP be an optimal solution to (13)–(15). Then the algorithm described in the
preceding paragraph defines a feasible schedule with job completion times CjH satisfying, for every
job Jj ,
√ γ
H
CjLP = 3 + 2 2 CjLP ≈ 5.83 CjLP .
Cj ≤ 2γ +
γ−1
Proof. We first observe that the date t is nondecreasing during the execution of the algorithm,
and that the following invariant is maintained: no job starts on any machine at a date later than t.
Therefore, at any time, no machine processes more than one job, and no job is being processed on
more than one machine. The algorithm thus constructs a feasible nonpreemptive schedule, which
we call the heuristic schedule in the rest of this proof. Consider a job Jj and its completion time
CjH in the heuristic schedule and let Pi denote the last machine on which Jj is processed. We let
11
CjH = B + I where B ≥ 0 is the total busy time of machine Pi in interval [0, CjH ], and I is its total
idle time in this interval. Because of the job precedences, machine Pi cannot process before job Jj
P
any job Jk such that γ CjLP < CkLP . Therefore, B ≤ {pik : CkLP ≤ γ CjLP } and, by constraints
(14) and Schulz’s Lemma 3.2 with θ = γ CjLP , we obtain B ≤ 2γ CjLP .
We now bound the total idle time I of machine Pi during the time interval [0, CjH ]. We construct
.
a finite sequence (v(0), v(1), . . . , v(q)) of job indices such that v(0) = j and for k ≥ 1, v(k) is the
last job processed on machine Pi in the heuristic schedule, if any, such that Jv(k) ≺LP Jv(k−1) .
LP < γ −1 C LP
Thus, for all k = 2, . . . , q, we have Cv(k)
v(k−1) and, by induction,
LP
Cv(k)
< γ −k CjLP .
(16)
H denote the completion time of (the last operation of) job J on machine P in the
Let Ci,j
j
i
heuristic schedule. Note that, for 0 ≤ k ≤ q − 1, job Jv(k) becomes available for processing
H
H
on machine Pi at date max{Ci,v(k+1)
, rv(k) } and remains available until its start date Ci,v(k)
−
pi,v(k) . Therefore, job Jv(k) must be in process on some other machine at any time during interH
H
val [max{Ci,v(k+1)
, rv(k) }, Ci,v(k)
] when machine Pi is idle. This implies that the total idle time Ik
H
H
on machine Pi during the time interval [Ci,v(k+1)
, Ci,v(k)
] cannot exceed the total length ℓv(k) of
job Jv(k) plus its release date rv(k) . Similarly, job Jv(q) is available at time rv(q) so the total idle
H
time Iq on machine Pi during the time interval [0, Ci,v(q)
] cannot exceed ℓv(q) + rv(q) . We obtain
I=
q
X
k=0
Ik ≤
q
X
k=0
ℓv(k) + rv(k) ≤
q
X
LP
Cv(k)
k=0
≤
q
X
γ −k CjLP <
k=0
γ
C LP
γ−1 j
where the second inequality follows from constraint (15) and the third one from (16). It follows
that
√ γ
CjH = B + I < 2γ +
CjLP = 3 + 2 2 CjLP
γ−1
and the proof is complete.
2
From this job-by-job bound, we obtain a 5.83-approximation for the open shop problem with
weighted sum of job completion times objective:
√ Theorem 5.2 There exists a polynomial time 3 + 2 2 -approximation algorithm for the minsum
P
open shop problem O|rj | wj Cj .
5.2
A 3-approximation algorithm for O|rj , pmtn|
P
w j Cj
In contrast with the nonpreemptive open shop algorithm above, we use a job-based greedy algorithm
to preemptively schedule the jobs in order of their LP completion times C LP . Namely, assume
w.l.o.g. that the jobs are indexed in nondecreasing order of their LP completion times, that is, that
C1LP ≤ C2LP ≤ . . . ≤ CnLP . We consider the jobs Jj one by one, in this order j = 1, 2, . . . , n, and all
operations of job Jj are scheduled as follows, without modifying the schedule of jobs J1 , . . . , Jj−1 .
Given the partial schedule of these jobs J1 , . . . , Jj−1 , job Jj is preemptively assigned to the earliest
available time slots after job release date rj , so long as its corresponding operations are not complete.
Ties between machines and/or operations available at the same time are broken arbitrarily. When
all work for job Jj has been scheduled, defining its completion time CjH , we turn to job Jj+1 . The
schedule is complete when the last job Jn is scheduled.
We obtain the following job-by-job bound:
12
Lemma 5.3 Let C LP be an optimal solution to (13)–(15). Then the algorithm described in this
section defines a feasible preemptive schedule with job completion times CjH satisfying, for every
job Jj ,
CjH ≤ 3 CjLP .
Proof. As in the proof of the Lemma 5.1, let Pi denote the last machine on which Jj is processed
and let CjH = B + I where B ≥ 0 is the amount of time on machine Pi in interval [0, CjH ] when
jobs J1 , . . . , Jj are proccesed, and I is the total length of remaining time slots in this interval, i.e.
B is the total busy time in interval [0, CjH ] and I is the idle time in this interval just after the job
P
Jj was scheduled. Because of the job order, B ≤ {pik : CkLP ≤ CjLP } and, by constraints (14)
and Schulz’s Lemma 3.2 with θ = CjLP , we obtain B ≤ 2CjLP .
If job Jj was not scheduled into some idle time slots on machine Pi during the time interval
[rj , CjH ] then it must be in process on some other machine at the same time. Therefore, I ≤ rj + lj
and lemma follows.
2
From this job-by-job bound, we obtain a 3-approximation for the preemptive open shop problem
with a weighted sum of job completion times objective:
Theorem 5.4 There exists a polynomial time 3-approximation algorithm for the preemptive open
P
shop problem O|rj , pmtn| wj Cj .
6
Jobs shops with very long jobs
The job shop approximation results in Section 4 may be worse than O(m) if the maximum number
µ of operations per job is very large, for example if µ = 2m . We say that a job shop instance has
very long jobs if m = o((log(mµ)/ log log(mµ))2 )). In this Section, we consider job shop problems
P
J|job prec. delays djk | wj Cj with job precedence delays and a weighted sum of job completion
time objective, for which we derive a very simple O(m) approximation algorithm. Note that this
result is not directly comparable to our earlier results due to the more general setting of precedence
delays. It improves upon our earlier results, when they apply, for the case of very long jobs.
P
In the job shop problem J|job prec. delays djk | wj Cj each job consists, as before, of operations,
each with a specified stage, and (ordinary) precedence constraints between operations of a same
job. In addition we have a set A of precedence constraints between jobs. We associate with each
precedence-constrained job pair (j, k) ∈ A a nonnegative precedence delay djk , with the following
meaning: in every feasible schedule, job k cannot start until djk time units after job j is completed:
Sk ≥ Cj + djk , where Sℓ and Cℓ denote the start time and completion time of job Jℓ , respectively.
Special cases include ordinary precedence constraints between jobs (djk = 0), and job release dates
rj ≥ 0 (which may be modeled by adding a dummy job 0 with zero processing time, and precedence
delays d0j = rj for all other jobs). Precedence delays were considered for one-machine “pipeline”
scheduling problems and for parallel machine scheduling, see [19] and [23] for discussion and further
references. We consider both nonpreemptive and preemptive schedules; for the latter, we restrict
attention to schedules with a finite number of preemptions.
To every instance of this precedence-delay job shop problem, we associate an instance of a
P
single machine preemptive problem 1|s1 = m, pmtn, prec. delays djk | wj Cj with the same set of
jobs J1 , . . . , Jn and with job processing times lj for each job Jj and the original job precedence
delays djk , and where the machine has speed s1 = m. The detailed composition of each job (that
is, its operations, their individual processing times, and any precedence constraints between them)
is ignored in this transformation.
13
Several special cases of the following two lemmata belong to scheduling folklore; their application
to the precedence-delay job shop problem is, to our knowledge, new.
Lemma 6.1 To every feasible (preemptive or nonpreemptive) schedule for the original precedencedelay job shop problem corresponds a feasible preemptive schedule on the speed-m machine with
completion times Cej ≤ Cj for all jobs Jj , where Cj is the completion time of job Jj in the given
job shop schedule.
Proof. Let Shj and Chj denote the start time and completion time, respectively, of operation
Ohj in the given job shop schedule. Partition the time interval [minhj Shj , maxhj Chj ] into intervals
[at−1 , at ] (t = 1, . . . , τ ) such that exactly the same operations are being processed during each
interval. Thus {at : t = 0, . . . , τ } is the set of all operation start and completion times, and
all times at which some operation is preempted. Partition each job Jj into τ pieces (j, t) with
lengths qjt = at − at−1 if one operation of Jj is being processed during interval [at−1 , at ], and zero
P
otherwise. Since each job Jj is performed in the given schedule, we have τt=1 qjt = ℓj . Since each
P
of the m machines Pi has unit capacity, we have j qjt ≤ m(at − at−1 ) for all t. Now, construct a
preemptive schedule on the speed-m machine by processing, for each t = 1, . . . , τ , all pieces (j, t)
with qjt = at − at−1 , in arbitrary order, during the interval [at−1 , at ]. In this preemptive singlemachine schedule, the speed-m machine processes no more than one job at any time. Furthermore,
each operation Ohj (and therefore each job Jj ) is started no earlier than the beginning at−1 = Shj
of the first interval [at−1 , at ] during which it is processed in the given job shop schedule, and is
completed no later than the end au = Chj of the last interval [at−1 , at ] during which it is processed
in the job shop schedule. This implies that the single-machine schedule satisfies all precedence
delays, and that its job completion times Ce satisfy Cej ≤ Cj for all jobs Jj .
2
A feasible job shop schedule is a no-wait schedule if every job Jj is being processed at every
instant between its start time Sj and its completion time Cj ; that is, if Cj = Sj + ℓj for all jobs Jj .
Lemma 6.2 Given a feasible preemptive schedule on the speed-m machine, we can construct in
polynomial time a feasible preemptive schedule for the original precedence-delay job shop problem with completion times CjH ≤ m Cbj , where Cbj is the completion time of job Jj in the given
single-machine schedule. If the latter is nonpreemptive, then the job shop schedule C H is also
nonpreemptive and is a no-wait schedule.
Proof.
Let Sbj and Cbj denote the start time and completion time, respectively, of job Jj in
the given single-machine schedule. Let [αjt , βjt ] (t = 1, . . . , τj ) denote the time intervals during
which job Jj is being processed in this given schedule. Thus, αj1 = Sbj , the start time of Jj ;
P
b
t (βjt − αjt ) = ℓj /m; and βjτj = Cj . For every job Jj , order all its operations in any sequence
consistent with the precedence constraints within Jj and preemptively assign them, in this order,
to the “expanded” time intervals [mαjt , mβjt ] for t = 1, . . . , τj . In the resulting schedule no more
than one operation altogether is being processed at any time; the start time of every job Jj is
SjH = m αj1 = m Sbj and its completion time CjH = m βjτj = m Cbj . Thus, for any precedence
constrained job pair (j, k) ∈ A we have SkH ≥ CjH + m djk ≥ CjH + djk . This shows that C H is
a feasible preemptive schedule for the job shop problem and CjH ≤ m Cbj for every job Jj . Note
also that if Cb is nonpreemptive then so is C H ; since there is no positive precedence delay between
operations of job Jj all these operations are processed consecutively in C H , so C H is a feasible
no-wait schedule.
2
These two lemmata then imply:
14
Theorem 6.3 Consider a class of instances of the (preemptive or nonpreemptive) minsum singleP
processor job shop problem J|job prec. delays djk | wj Cj .
(i) If there exist a polynomial time α-approximation algorithm for the preemptive single-machine
version of the problem for this class, then there exists a polynomial time α m-approximation algorithm for the preemptive minsum job shop problem for this class.
(ii) Assume that there exist a polynomial time approximation algorithm for the nonpreemptive
single-machine version of the problem for this class, producing a schedule with objective value no
larger than β times a lower bound on the minimum objective value of the preemptive single-machine
problem. Then there exists a polynomial time β m-approximation algorithm for the nonpreemptive
(and no-wait) minsum job shop problem for this class.
Remark: The algorithm in Lemma 6.2 is polynomial in the input size for the scheduling problem
and in the number of preemptions in the given preemptive single-machine schedule. The singlemachine algorithms invoked in Theorem 6.3, being polynomial in the (scheduling problem) input
size, lead to a polynomial number of preemptions. The resulting job shop algorithms then indeed
run in time polynomial in the (scheduling problem) input size, as stated.
Consequences of Theorem 6.3 are listed in Table 2, giving performance guarantees that match
or improve upon known results in [1], [13] and [30]. Extension of Theorem 6.3 to a more general
class of objective functions, similar to those in Theorem 4.1, is left to the interested reader.
7
Conclusion
In this paper we designed approximation algorithms for variety of shop scheduling problems with
minsum objective. Since our algorithms are very general we could expect better approximation
algorithms for specific problems. Indeed, we designed few algorithms with better performance
guarantees in Section 5 and [28]. We believe that there exists an approximation algorithm for
P
O|| wj Cj with performance guarantee better then 5.83. It is also possible that there exist
approximation schemes for shop scheduling problems on fixed number of machines, for example
P
P
Jm|op ≤ µ| wj Cj and Om|| wj Cj . It would be interesting to prove or disprove the existence
of such algorithms.
References
[1] J.O. Achugbue and F.Y. Chin, “Scheduling the open shop to minimize mean flow time.” SIAM Journal
on Computing 11 (1982) 709–720.
[2] N. Alon, Y. Azar, G.J. Woeginger, and T. Yadid, “Approximation schemes for scheduling on parallel
machines.” Journal of Scheduling 1 (1998) 55–66.
[3] E. Anderson, T. S. Jayram and T. Kimbrel, Tighter bounds on preemptive job shop scheduling with two
machines, to appear in Computing.
[4] D. Applegate and W. Cook, “A Computational Study of the Job–Shop Scheduling Problem.” ORSA
Journal on Computing 3 (1991) 149–156.
[5] K.R. Baker, Introduction to Sequencing and Scheduling. Wiley, 1974.
[6] S. Chakrabarti, C. Phillips, A. Schulz, D. Shmoys, C. Stein and J. Wein, Improved Scheduling Algorithms
for Minsum Criteria, In Proceedings of the 23rd International Colloquium on Automata, Languages, and
Programming (ICALP’96), 646–657.
[7] A.K. Chandra and C.K. Wong, “Worst-case analysis of a placement algorithm related to storage allocation.” SIAM Journal on Computing 4 (1975) 249–263.
15
[8] C. Chekuri, R. Motwani, B. Natarajan, and C. Stein, “Approximation Techniques for Average Completion
Time Scheduling.” Proceedings of the 8th Symposium on Discrete Algorithms (1997) 609–618.
[9] A. Czumaj and C. Scheideler, A New Algorithmic Approach to the General Lovasz Local Lemma with
Applications to Schedulung and Satisfiability Problems, Proc. 32 ACM Symposium on Theory of Computing (STOC) , 2000.
[10] U. Feige and C. Scheideler, “Improved bounds for acyclic job shop scheduling.” In: Proceedings of the
30th Annual ACM Symposium on Theory of Computing (STOC’98, 1998), ACM Press, New York, NY,
624-633.
[11] M. Goemans, M. Queyranne, A.S. Schulz, M. Skutella, and Y. Wang, Single Machine
Scheduling with Release Dates,submitted for publication, available at http://www.math.tuberlin.de/ skutella/publications.html.
[12] L. A. Goldberg, M. Paterson, A. Srinivasan, and E. Sweedyk, Better approximation guarantees for jobshop scheduling, to appear in SIAM Journal on Discrete Mathematics, Preliminary version in: Proceedings
of the 8th Symposium on Discrete Algorithms (1997) 599–608.
[13] T. Gonzalez and S. Sahni, “Flowshop and jobshop schedules: Complexity and approximation.” Operations Research 26 (1978) 36–52.
[14] M. Grötschel, L. Lovász, and A. Schrijver, Geometric Algorithms and Combinatorial Optimization.
Springer, 1988.
[15] L.A. Hall, D.B. Shmoys, and J. Wein, “Scheduling to Minimize Average Completion Time: Off–line
and On–line Algorithms”, Proceedings of the 7th Symposium on Discrete Algorithms (1996) 142–151.
[16] L.A. Hall, A.S. Schulz, D.B. Shmoys, and J. Wein, “Scheduling to Minimize Average Completion Time:
Off–Line and On–Line Approximation Algorithms”, Mathematics of Operations Research 22 (1997) 513–
544.
[17] H. Hoogeveen, P. Schuurman, and G. Woeginger, “Non-approximability results for scheduling problems
with minsum criteria.” In: R.E. Bixby, E.A. Boyd, and R.Z. Rios-Mercado, eds, Integer Programming and
Combinatorial Optimization (IPCO-VI Proceedings, 1998), Lecture Notes in Computer Science 1412,
Springer, 353–366.
[18] E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, and D.B. Shmoys, Sequencing and Scheduling: Algorithms and Complexity, In: S.C. Graves, A.H.G. Rinnooy Kan, and P.H. Zipkin, eds., Logistics of Production and Inventory, Handbooks in Operations Research and Management Science 4, North–Holland,
Amsterdam, The Netherlands (1993) 445–522.
[19] E.L. Lawler, J.K. Lenstra, C. Martel, B. Simons, and L. Stockmeyer, “Pipeline scheduling: A survey.”
Report RJ 5738 (57717), IBM Research Division, San Jose, California, 1987.
[20] E. L. Lawler, M. G. Luby, and V. V. Vazirani, “Scheduling open shops with parallel machines.” Operations Research Letters 1 (1982) 161–164.
[21] F.T. Leighton, B.M. Maggs, and S.B. Rao, “Packet routing and job-shop scheduling in O(congestion +
dilation) steps.” Combinatorica 14 (1994) 167–186.
[22] F.T. Leighton, B.M. Maggs, and A.W. Richa, “Fast algorithms for finding O(congestion + dilation)
packet routing schedules.” Combinatorica 19 (1999) 375–401.
[23] A. Munier, M. Queyranne, and A.S. Schulz, “Approximation bounds for a general class of precedence
constrained parallel machine scheduling problem.” In: R.E. Bixby, E.A. Boyd, and R.Z. Rios-Mercado,
eds, Integer Programming and Combinatorial Optimization (IPCO-VI Proceedings, 1998), Lecture Notes
in Computer Science 1412, Springer, 367-382.
[24] M. Queyranne, “Polyhedral Approaches to Scheduling Problems.” Seminar presented at RUTCOR,
Rutgers University, November 16, 1987.
16
[25] M. Queyranne, “Structure of a Simple Scheduling Polyhedron.” Mathematical Programming 58 (1993)
263–285.
[26] M. Queyranne and A.S. Schulz, “Polyhedral Approaches to Machine Scheduling.” Report 408/1994, Department of Mathematics, University of Technology, Berlin, Germany, November 1994; revised, October
1996.
[27] M. Queyranne and M. Sviridenko, New and Improved Algorithms for Minsum Shop Scheduling, Proceedings of SODA00, 871–878.
[28] M. Queyranne and M. Sviridenko, A (2 + ε)-approximation algorithm for generalized preemptive open
shop problem with minsum objective, to appear in IPCO 2001.
[29] A.S. Schulz, “Polytopes and Scheduling.” Ph.D. Thesis, Faculty of Mathematics, Technical University
of Berlin, Berlin, Germany, 1995.
[30] A.S. Schulz, “Scheduling to minimize total weigthed completion time: Performance guarantees of LPbased heuristics and lower bounds.” In: W.H. Cunningham, M. Queyranne and S.T. McCormick, eds,
Integer Programming and Combinatorial Optimization (IPCO-V Proceedings, 1996), Lecture Notes in
Computer Science 1084, Springer, 301–315.
[31] A.S. Schulz and M. Skutella, “Random-Based Scheduling: New Approximations and LP Lower Bounds.”
In: J. Rolim, ed., Randomization and Approximation Techniques in Computer Science (Random’97
Proceedings, 1997) Lecture Notes in Computer Science 1269, Springer, 119–133.
[32] A.S. Schulz and M. Skutella, “The Power of alpha-Points in Preemptive Single Machine Scheduling.”to
appear in Journal of Scheduling.
[33] P. Schuurman and G.J. Woeginger, “Approximation algorithms for the multiprocessor open shop
scheduling problem.” Operation Research Letters 24 (1999) 157–163.
[34] S. Sevastianov and G. Woeginger, Makespan minimization in preemptive two machine job shops, Computing 60 (1998) 73–79.
[35] D.B. Shmoys, “Using linear programming in the design and analysis of approximation algorithms: Two
illustrative examples.” In: K.Jansen and J.Rolim, eds, Approximation Algorithms for Combinatorial
Optimization (APPROX’98 Proceedings, 1998), Lecture Notes in Computer Science 1444, Springer,
15–32.
[36] D.B. Shmoys, C. Stein, and J. Wein, “Improved approximation algorithms for shop scheduling problems.” SIAM Journal of Computing 23 (1994), 617–632.
[37] M. Skutella, “Approximation and Randomization in Scheduling”, Ph.D. Thesis, Faculty of Mathematics,
Technical University of Berlin, Berlin, Germany, May 1998.
[38] W.E. Smith, “Various Optimizers for Single–Stage Production.” Naval Research and Logistics Quarterly
3 (1956) 59–66.
[39] L.A. Wolsey, “Mixed integer programming formulations for production planning and scheduling problems.” Invited talk at the 12th International Symposium on Mathematical Programming, MIT, Cambridge, N.J., August 1985.
17
Problem
J(P )|rhj , dagj |
P
Performance guarantee
wS CS
J(P )|rhj , dagj , pij = 1|
J(P )|rhj , acyclic-dagj |
P
P
O
wS CS
O(P )|rhj |
P
P
O(P )|rhj , pmtn|
P
P
wS CS
wS CS
wj Cj
O|rj , pmtn|
P
log mµ
log log mµ
wS CS
P
2
log mµ
log log mµ
wj Cj
[12]
O log m · log1+ε log m
wS CS
J2|rhj , pmtn|
O|rj |
O
wS CS
J(P )|rhj , acyclic-dagj , pij = 1|
Makespan algorithm used
[12]
[10, 9]
O (1)
[21, 22]
10.88
[33]
8.16(*)
[34, 3]
5.44
[20]
5.83
(**)
3
(**)
Table 1: New approximation results for minsum shop scheduling problems.
(*) An algorithm from Section 6 leads to an 8/3-approximation algorithm for the closely related problem
P
P
J2|rj , pmtn| wj Cj and to a 2-approximation for the problem J2|rj , pmtn| Cj (see also the Table 2).
(**) Does not use a makespan approximation algorithm; see Section 5 for details.
All performance guarantees in this table also apply to the preemptive versions of the problems.
18
Problem
Performance guarantee
Single-machine algorithm used
3m
[23]
2.72 m
[31]
2m
[31]
2m
[30, 16]
wj Cj
1.69 m
[11, 37]
Cj
1.59 m
[8]
4
3m
[32, 37]
m
[38]
m
[5]
J|job prec. delays, dagj |
P
J|rj , prec, dagj |
P
J|rj , dagj |
P
J|rj , dagj |
P
J|dagj |
P
P
wj Cj
J|rj , dagj , pmtn|
P
wj Cj
wj Cj
J|rj , dagj , pmtn|
wj Cj
wj Cj
J|rj , prec, dagj , pmtn|
J|prec, dagj |
P
P
Cj
wj Cj
Table 2: Approximation results for minsum job shop problems with very long jobs.
All nonpreemptive results in this table also apply to the no-wait versions of the problems.
19