On Preemptive Resource Constrained Scheduling:
Polynomial-time Approximation Schemes


Klaus Jansen

Institut fur Informatik
und praktische Mathematik,
Universitat zu Kiel, Germany

kj@informatik.uni-kiel.de

Lorant Porkolab

Applied Decision Analysis
PricewaterhouseCoopers
London, United Kingdom

lorant.porkolab@uk.pwcglobal.com
Abstract

We study resource constrained scheduling problems where the objective is to compute feasible
preemptive schedules minimizing the makespan and using no more resources than what are available.
We present approximation schemes along with some inapproximibility results showing how the approximability
of the problem changes in terms of the number of resources. The results are based on
linear programming formulations (though with exponentially many variables) and some interesting
connections between resource constrained scheduling and (multi-dimensional, multiple-choice, and
cardinality constrained) variants of the classical knapsack problem. In order to prove the results
we generalize a method by Grigoriadis et al. for the max-min resource sharing problem to the case
with weak approximate block solvers (i.e. with only constant, logarithmic, or even worse approximation
ratios). Finally we present applications of the above results in fractional graph coloring and
multiprocessor task scheduling.
1 Introduction

In this paper we consider the general preemptive resource constrained scheduling problem denoted by

P jres:::; pmtnjC max : There are given n tasks T = fT 1 ; : : : ; T n g, m identical machines and s resources
such that each task T j 2 T , is processed by one machine requiring p j units of time and r ij units of
resource i, i = 1; : : : ; s, from which only c i units are available at each time. One may assume w.l.o.g.
that r ij 2 [0; 1] and c i  1. The objective is to compute a preemptive schedule of the tasks minimizing the
maximum completion time C max . The three dots in the notation indicate that there are no restrictions on
the number of resources s, the largest possible capacity o and resource requirement r values, respectively.
If any of these is limited, the corresponding xed limit replaces the corresponding dot in the notation
(e.g. if s  1, then P jres1::; pmtnjC max is used, or if r ij  r, then P jres ::r; pmtnjC max ). We will study
dierent variants of the problem and their applications in multiprocessor task scheduling and fractional
graph coloring.
1.1 Related Results

Resource constrained scheduling is one of the classical scheduling problems. Garey and Graham [20]
proposed approximation algorithms for the non-preemptive variant P jres:::jC max with approximation
ratios s + 1 (when the number of machines is unbounded, m  n) and min(

m+1

2

; s + 2

2s+1

m

) (when

m  2). Further results are known for some special cases: Garey et al. [21] proved that when m  n



Supported by EU - Project APPOL, Approximation and Online Algorithms, IST-1999-14084.
1

and each task T j has unit-execution time, i.e. p j = 1, the problem (denoted by P jres:::; p j = 1jC max )
can be solved by First Fit and First Fit Decreasing heuristics providing asymptotic approximation ratio

s +

7
10

and a ratio between s + ((s 1)=s(s + 1)) and s +

1
3

, respectively. De la Vega and Lueker [12] gave
a linear-time algorithm with asymptotic approximation ratio s +  for each xed  > 0. Further results
and improvements for non-preemptive variant are given in [10, 50, 51].
For the preemptive variant substantially less results are known: Blazewicz et al. [6] proved that
when m is xed, the problem Pmjpmtn; res:::jC max (with identical machines) and even the variant

Rmjpmtn; res:::jC max (with unrelated machines) can be solved in polynomial time. Krause et al. [36]
studied P jpmtn; res1::jC max , i.e. where there is only one resource (s = 1) and proved that both First
Fit and First Fit Decreasing heuristics can guarantee 3 3=n asymptotic approximation ratio.
A related problem is multiprocessor task scheduling, where a set T of n tasks has to be executed by

m processors such that each processor can execute at most one task at a time and each task must be
processed by several processors in parallel. In the parallel (non-malleable) model P jsize j jC max , there is
a value size j 2 M = f1; : : : ; mg given for each task T j indicating that T j can be processed on any subset
of processors of cardinality size j [4, 14, 15, 28, 33, 52]. In the malleable variant P jfctnjC max , each
task can be executed on an arbitrary subset of processors, and the execution time p j (`) depends on the
number ` of processors assigned to it [38, 42, 53]. Regarding the complexity, it is known [14, 15] that the
preemptive variant P jsize j ; pmtnjC max is NP-hard. In [30], focusing on computing optimal solutions,
we presented an algorithm for solving the problem P jsize j ; pmtnjC max and showed that this algorithm
runs in O(n) + poly(m) time, where poly(:) is a univariate polynomial. Furthermore, we extended this
algorithm also to malleable tasks with running time polynomial in m and n. These results are based on
methods by Grotschel et al. [26] and use the ellipsoid method.
Another related problem is fractional graph coloring, see e.g. [18, 25, 39, 41, 43, 47, 48]. Grotschel et
al. [25] proved that the weighted fractional coloring problem is NP-hard for general graphs, but can be
solved in polynomial time for perfect graphs. They have proved the following interesting result: For any
graph class G, if the problem of computing (G; w) (the weight of the largest weighted independent set
in G) for graphs G 2 G is NP-hard, then the problem of determining the weighted fractional chromatic
number  f (G; w) is also NP-hard. This gives a negative result of the weighted fractional coloring
problem even for planar cubic graphs. Furthermore, if the weighted independent set problem for graphs
in G is polynomial-time solvable, then the weighted fractional coloring problem for G can also be solved
in polynomial time. The rst inapproximability result for the unweighted version of the problem (i.e.
where w v = 1 for each vertex v 2 V ) was obtained by Lund and Yannakakis [39] who proved that
there exists a  > 0 such that there is no polynomial-time approximation algorithm for the problem
with approximation ratio n



, unless P=NP. Feige and Kilian [18] showed that the fractional chromatic
number  f (G) cannot be approximated
within


jV j

1 

) for any  > 0, unless ZPP=NP. Recently, the
authors [29] proved that fractional coloring is NP-hard even for graphs with  f (G) = 3 and constant
degree 4. Similarly, as it was shown by Gerke and McDiarmid [22], the problem remains NP-hard even
for triangle-free graphs. Regarding the approximability of the fractional chromatic number, Matsui [41]
gave a polynomial-time 2-approximation algorithm for unit disk graphs.
1.2 New Results

The results presented in this paper are based on linear programming formulations. They are typically
of the following form:
Min

P

h2H x h

s.t.

P

h2H:s2h x h  w s ; 8s 2 S;
x h  0; 8h 2 H;

(1)
2

where S is a nite set (usually the set of all tasks), and H  2

S

is a set consisting of subsets of S

satisfying some combinatorial property (usually each contains tasks that can be scheduled together at
the same time). These linear programs will have - in general - exponentially many variables, but special
underlying structures allowing ecient approximations. A linear program of form (1) can be solved
(approximately) by using binary search on its optimum and computing at each stage an approximate
solution of a special max-min resource sharing problem of the following type:





= Max 

s.t. f i (x 1 ; : : : ; xN )  ; i = 1; : : : ; M;

(x 1 ; : : : ; xN ) 2 P;

(2)
where f i : P ! IR

+

, i = 1; : : : ; M , are - in general - nonnegative concave functions dened on a nonempty
convex set P  IR

N

. Furthermore, approximate solutions for problem (2) can be computed by an
iterative procedure that requires in each iteration for a given M-vector (p 1 ; : : : ; p M ) the approximate
maximization of

P M
i=1 p i f i (x) over all x = (x 1 ; : : : ; xN ) 2 P . Interestingly, these subproblems for dierent
variants of resource constrained scheduling turn out to be knapsack type problems (multiple-choice,
multi-dimensional, and cardinality constrained knapsack) with ecient approximation algorithms. For
fractional graph coloring the subproblem is the well-known maximum weighted independent set problem.
In Section 2 we describe the methodology used for solving the max-min resource sharing problem. Let

f(x) = (f 1 (x); : : : ; f M (x)) and (p) = max x2P p

T

f(x). Based on the paper of Grigoriadis et al. [24], we
derive the following result extending some of the previous works on computing approximate solutions for
fractional covering problems [24, 44, 54]: If there exists a polynomial-time approximation algorithm with
approximation ratio c for the subproblem, i.e. for nding a vector ^ x(p) 2 P such that p

T

f(^x) 

1

c

(p)),
then there is also a polynomial time approximation algorithm for the max-min resource sharing problem
that computes a feasible solution with objective function value

1 
c





. Interestingly, the number of
iterations (hence also the number of calls to the solver for the subproblem) is bounded by O(M(lnM +
ln c

3

+ 

2

)), independently of the width [44] of P and the number of variables. If - in particular -
there is a (fully) polynomial time approximation scheme ((F)PTAS) for the subproblem, one also gets a
(F)PTAS for the original problem and the number of iterations is at most O(M(lnM + 

2

)) [24]. This
fact can be particularly useful for models with exponentially many variables.
In Section 3 we describe a linear programming approach for the preemptive resource constrained
scheduling problem, where there are no assumptions on s or m  n, they are arbitrary numbers and
parts of the input. We show by using the linear programming formulation that there is an approximation
algorithm for our scheduling problem with approximation ratio O(s

1

c min

), where the minimum resource
capacity c min = min i c i  1. Furthermore, we argue that if for each resource i, capacity c i 

12



2 log(2s),
then there is a polynomial time (1 + ) approximation algorithm.
Then with the aim of obtaining stronger approximation results we study restricted variants, where

s is xed. In particular, we show that for any constant s  2, there exists a PTAS computing an

-approximate preemptive schedule satisfying the s resource constraints. In fact this is the best one
can expect regarding approximation, since as we show it, this variant even with s = 2 cannot have
a FPTAS unless P=NP. However, if we assume that s = 1 (i.e. the number of resources is pushed
to its lower extreme), the problem posses a FPTAS. Next, we apply our approach to the case where
there are only a limited number of processors. We give a FPTAS for the variant of the problem with one
resource improving the previously known best (3

1

n

)-approximation algorithm by Krause et al. [36]. The
method can be used to obtain a PTAS for a more general variant with xed number of resources, where
the input also contains release and delivery times for each task. In Section 5 we study the preemptive
multiprocessor task scheduling problem P jsize j ; pmtnjC max and its generalization P jfctn j ; pmtnjC max

to malleable tasks. We show the existence of FPTASs for both problems.
3

Finally, we apply our linear programming based approach - that was initially introduced for preemptive
resource constrained scheduling - to the problem of computing the fractional weighted chromatic
number. We prove an approximation analoge of the above mentioned classical result of Grotschel,
Lovasz and Schrijver [25] on the equivalence between polynomial-time (exact) computations of (G; w)

and  f (G; w): If for a graph class G there exists a polynomial-time

1

c

-approximation algorithm for computing
 (G; w), then there is also a polynomial-time c(1 + )-approximation algorithm for computing

 f (G; w) for graphs in G. By applying this general result for intersection graphs of disks in the plane, we
also obtain a PTAS for the fractional coloring problem providing a substantial improvement on Matsui's
result [41].

2 Approximate Max-Min Resource Sharing

In this section we will follow the presentation of [24] and use the notation introduced there. Let f : B !

IR

M

+ be a vector with M non-negative, continuous, concave functions f m , block B a non-empty, convex,
compact set and e

T

= (1; : : : ; 1) 2 IR

M

+ . Consider the optimization problem
(P ) 



= max f  : f(x)  e; x 2 B g;

and assume without loss of generality that 



> 0. Let (f) = min 1mM f m for any given function

f . Here we are interested in computing a (c; )-approximate solution for (P ), i.e. for an approximation
guarantee c = c(M) > 1 and an additional error tolerance  2 (0; 1) we want to solve the following
problem:
(P c; ) compute x 2 B such that f(x)  [

1

c

(1 )



]e:
In order to solve this resource sharing problem we study the subproblem
(p) = max f p

T

f(x) : x 2 B g

for p 2 P = fp 2 IR

M

:

P M
i=1 p i = 1; p i  0g. Here we use an approximate block solver (ABS) that
solves the following subproblem:

ABS(p; c) compute ^ x = x(p) 2 B such that p

T

f(^x) 

1

c

(p):
By duality we have 



= max x2B min p2P p

T

f(x) = min p2P max x2B p

T

f(x). This implies that 



=
minf(p) : p 2 Pg. Based on this equality, one can naturally dene the problem of nding a (c; )-

approximate dual solution:
(D c; ) compute p 2 P such that (p)  c(1 + )



:

Then the following result holds:

Theorem 2.1 If there exists a polynomial time block solver ABS(p; c) for some c  1 and any p 2 P ,
then there is an approximation algorithm for the resource sharing problem that computes a solution whose
objective function value is at least

1

c

(1 )



.

The running time of the approximation algorithm depends only on c, M and

1



. In particular, if there is
a (F)PTAS for the block problem computing an ^ x 2 B such that p

T

f(^x)  (1 )(p) for any constant

 > 0, then there is a (F)PTAS for the resource sharing problem [24].
The algorithm uses the logarithmic potential function
 t (; f) = ln  +

t
M

M

X

m=1

ln(f m );
4

where  2 IR, f = (f 1 ; : : : ; f M ) are variables associated with the coupling constraints f m  , 1  m  M

and t > 0 is a tolerance (that depends on ). For  2 (0; (f )), the function  t is well dened. The
maximizer (f) of function  t (; f) is given by the rst order optimality condition

t
M

M

X

m=1

1

f m 

= 1: (3)
This has a unique root since g() =

t
M

P M
m=1

1

fm 

is a strictly increasing function of . The logarithmic
dual vector p = p(f) for a xed f is dened by
p m (f) =

t
M
(f)
f m (f)
: (4)
By (3), we have p(f) 2 P . We will also use the following properties [24]:

Proposition 2.1

(a) p(f)

T

f = (1 + t)(f):

(b)

(f)

1+t  (f) 

(f)

1+t=M

:

Now dene parameter v = v(x; ^ x) by
v(x; ^ x) =

p

T ^

f p

T

f
p

T ^ f + p

T

f
; (5)
where p 2 P , f = f(x), ^ f = f(^x) and ^ x 2 B is an approximate block solution produced by ABS(p; c).

The following lemma provides a generalization of a useful result in [24]:

Lemma 2.1 Suppose  2 (0; 1) and t = =5. For a given x 2 B, let p 2 P computed from (4) and ^ x

computed by ABS(p; c). If v(x; ^ x)  t, then the pair (x; p) solves (P c; ) and (D c; ), respectively.

Proof: First rewrite condition v  t by using (5): p

T ^ f(1 t)  p

T

f(1+ t). Then use that p

T ^ f 

1

c (p),

p

T

f = (1 + t) and (f)  (f) by Proposition 2.1. This gives
(p)  cp

T

^ f  c

(1 + t)

(1 t)
p

T

f = c

(1 + t)

2

(1 t)
(f) 

(1 + t)

2

(1 t)
(f)  c(1 + )(f):
Using 



 (p)  c(1 + )(f ), one has (f) 

1

c

1
1+





>

1

c

(1 )



for any  > 0, which gives (P c; ).
Using (f)  



, one gets (p)  c(1 + )(f)  c(1 + )



which is (D c; ).
The main algorithm works as follows:

Algorithm Improve(f; B; ; x)

(1) set t := =5; v := t + 1;

(2) while v > t do
(2.1) compute (f) and p 2 P ;

(2.2) set ^ x := ABS(p; c);

(2.3) compute v(x; ^ x);
5

(2.4) if v > t then set x = (1 )x +  ^ x, where  2 (0; 1) is an appropiate step length

end
(3) return(x; p).

The step length can be dened by  =

tv

2M(p T ^ f+p T f)

. Notice that  

T ^

f + p

T

f (by Proposition 2.1),
and therefore  2 (0; 1). Furthermore, v > t > 0 implies that  > 0. For the initial solution, let

x

0

=

1

M

P M
m=1 ^ x

(m)

, where ^ x

(m)

is the solution given by ABS(em ; c) obtained for unit vector e m with all
zero coordinates except for its m-th component which is 1. The next lemma provides a bound on f(x

0

).

Lemma 2.2 For each p 2 P , 



 (p)  cMp

T

f(x

0

). Furthermore, f m (x

0

) 

1

M

1

c





for each

m = 1; : : : ; M .

Proof: The rst inequality follows from duality. For the second inequality,
(p) = maxfp

T

f(x) : x 2 Bg = maxf

P M
m=1 p m f m (x) : x 2 Bg



P M
m=1 p m maxffm (x) : x 2 Bg;

where maxffm (x) : x 2 Bg = (e m ). Since ^ x

(m)

is the solution computed by ABS(em ; c), f m (^x

(m)

) 

1

c

(e m ) implying that (e m )  cf m (x

(m)

). Therefore, (p)  c

P M
m=1 p m f m (^x

(m)

). Using the concavity
of f m we get

f m (^x

(m)

) 

M

X

`=1

f m (^x

(`)

)  Mfm (1=M

M

X

`=1

^ x

(`)

) = Mfm (x

0

):
Combining the two inequalities, we obtain
(p)  c

M

X

m=1

p m f m (^x

(m)

)  cM

M

X

m=1

p m f m (x

0

) = cMp

T

f(x

0

):
Finally, f m (x

0

) 

1

M

f m (^x

(m)

) 

1

M

1

c

(e m ) 

1

M

1

c





.
Let  t (f) =  t ((f); f ), which is called the reduced potential function. The following two lemmas
proved in [24] are used here to bound the number of iterations.

Lemma 2.3 For any two consecutive iterates x and x

0

of Algorithm Improve, it holds that  t (f

0

)

 t (f)  tv

2

=4M .
Lemma 2.4 For any two points x

0

2 B and x 2 B with (f) > 0,  t (f

0

)  t (f)  (1 + t) ln

(p)

p

T

f

,
where p is the vector dened by (4).

Theorem 2.2 Algorithm Improve solves (P c; ) and (D c; ) in O(

M ln M


+

M


2 +

M ln c


3 ) iterations.

Proof: Let N 0 be the number of iterations to reach an iterate x

1

with corresponding error v  1=2
starting from our initial solution x

0

. For all iterations with v  1=2, each iteration increases the
potential by at least tv

2

=4M  t=16M (see Lemma 2.3). By Lemma 2.4, the total increase is bounded
by  t (f

1

)  t (f

0

)  (1 + t) ln

(p

0

)

p

0T

f

0 . Since t = =5 and (p

0

)  cMp

0T

f

0

(by Lemma 2.2), we obtain
that

N 0 

(1 + =5)16M ln(cM)

=5

= O(
M ln(cM)



):
6

Now suppose that the error v `  1=2

`

for iterate x

`

2 B, and let N ` be the number of iterations to halve
this error. We get  t (f

`+1

)  t (f

`

) 

N ` tv

2

`+1

4M =

N ` tv

2

`

16M . On the other hand, the denition of v ` implies

p

`T ^

f

`

(1 v ` ) = p

`T

f

`

(1 + v ` ). Using ABS(p

`

; c), we get a solution ^ x

`

with p

`T ^

f

`



1

c

(p

`

). Combining
the two inequalities,
(p

`

)

p

`T

f

`



c(1 + v ` )
(1 v ` )

 c(1 + 4v ` ):
The last inequality holds since v `  1=2. Since d  0, Lemma 2.4 implies that

 t (f

`+1

)  t (f

`

)  (1 + t)(ln c + ln(1 + 4v ` ))  (1 + t)(ln c + 4v ` ):
This gives now an upper bound

N ` 

16M(1 + t)(ln c + 4v ` )

tv

2

`

= O(
M(ln c + v ` )

v

2

`

):
One gets the total number of iterations by summing N ` over all ` = 0; 1; : : : ; dln(

1

t

)e. Therefore, the
total number of iterations is bounded by
N 0 +O(

M ln c


dln(

1

t

)e

X

`=1

2

2`

+

M


dln(

1

t

)e

X

`=1

2

`

)  O(
M ln(cM)



+

M ln c


3

+

M


2

):
The total number of iterations can be improved by the scaling method used in [44, 24]. The idea is to
reduce the parameter t step by step to the desired accuracy. In the s-th scaling phase we set  s =  s 1 =2

and t s =  s =5 and use the current approximate point x

s 1

as its initial solution. For phase s = 0, use
the initial point x

0

2 B. For this point we have p

T

f(x

0

) 

1

cM

(p). We set  0 = (1 1=M ). Using
Lemma 2.1, f m (x

0

) 

1

M

1

c





. This implies f m (x

0

) 

1

cM





=

1

c

(1 1 +

1

M

)



=

1

c

(1  0 )



, for each

m = 1; : : : ; M .

Theorem 2.3 For any accuracy  > 0, the error scaling implementation computes solutions x and p of

(P c; ) and (D c; ), respectively, in

N = O(M ln M +M ln c=

3

+M=

2

)

iterations.

Proof: To reach the rst  0 2 (1=2; 1) in the primal and dual problem we need O(M(ln c + ln M))

iterations (by Theorem 2.2). Let N s be the number of iterations in phase s to reach  s for s  1. By
Lemma 2.3, each iteration of phase s increases the potential function by at least t

3

s =4M = (

3

s =M ).
Lemma 2.4 implies that for x = x

s

and x

0

= x

s+1

,
 t s (f

s+1

)  t s (f

s

)  (1 + t s ) ln
(p

s

)

p

sT

f

s

:
Note that x

s

is a  s 1 = 2 s solution of (P c; s 1 ), and therefore f(x

s

)  (1 2 s )

1

c





e. Furthermore, since
(p

s

)  c(1 + 2 s )



, (p

s

)  c

2 1+2s
1 2s

(f

s

)  c

2 1+2s
1 2s

p

sT

f

s

, implying that

(p

s

)

p

sT

f

s  c

2

(1 + 8 s ). Then
one can bound N s by O(M(ln c +  s )=

3

s ), and as before, the overall number of iterations is bounded by

N 0 +

X

s1

N s  O(M(ln c + ln M)) +O(

M ln c


3

) +O(

M


2

) = O(M ln M +

M ln c


3

+

M


2

):
7

Remark: The root (f) can often be computed only approximately, but an accuracy of O(

2

=M)

for (f) is sucient such that the iteration bounds remain valid. With this required accuracy, the
number of evaluations of the sum

P M
m=1

1

fm 

is bounded by O(ln(M=)). This gives O(M(lnM=))

arithmetic operations to determine (f) approximately. The overhead can be further improved by using
the Newton's method to O(M(ln ln(M=))) [24].

3 General Linear Programming Approach

In this section we study the preemptive resource constrained scheduling problem. First we consider the
case with unlimited number of machines m  n. In fact, if m  n, the machines can be handled as the
(s + 1)st resource with requirement r s+1;j = 1 and capacity c s+1 = m. For our scheduling problem, a

conguration is a compatible (or feasible) subset of tasks that can be scheduled simultaneously. Let F

be the set of all congurations, and for every f 2 F , let x f denote the length (in time) of conguration

f in the schedule. Clearly, f 2 F i

P

j2f r ij  c i , for i = 1; : : : ; s.

By using these variables, the problem of nding a preemptive schedule of the tasks with smallest
makespan value (subject to the resource constraints) can be formulated as the following linear program
[30]:
Min

P

f2F x f

s.t.

P

f2F :j2f x f  p j ; j = 1; : : : ; n;
x f  0; 8f 2 F:

(6)
One can solve (6) by using binary search on the optimum value and testing at each stage the feasibility
of the following linear system for a given r 2 [p max ; np max ]:

X

f2F :j2f

x f  p j ; j = 1; : : : ; n; (x f ) f2F 2 P;
where

P = f (x f ) f2F :

X

f2F

x f = r; x f  0; f 2 F g:

This can be done approximately (hence leading to an approximate decision procedure) by computing an
approximate solution for the following max-min resource sharing problem:





= Maxf  :

P

f2F :j2f
1

p j

 x f  ; j = 1; : : : ; n; (x f ) f2F 2 P g: (7)
The latter problem can also be viewed as a fractional covering problem with one block P , and n

coupling constraints. Let the coupling (covering) constraints be represented by Ax  . By using the
approach presented in Section 2, problem (7) can be solved approximately in O(n(

2

+ 

3

ln c + ln n))

iterations (coordination steps), each requiring for a given n-vector y = (y 1 ; : : : ; y n ) a

1

c

-approximate
solution of the problem,
(y) = Max f y

T

Ax : x 2 P g: (8)
Since P in (8) is just a simplex, the optimum of this linear program is also attained at a vertex ~ x of

P corresponding to a (single) conguration
~

f . A similar argument was used for the bin packing problem
by Plotkin et al. [44]. At this vertex ~ x ~

f

= r and ~ x f = 0 for f 6=

~

f . Therefore, it suces to nd a subset
~

f of tasks that can be executed in parallel and has the largest associated prot value c ~ f

in the prot
vector c

T

= y

T

A. But for given multipliers y 1 ; : : : ; y n , this problem can also be formulated as follows,
maxf

X

j2f

y j

p j

: f 2 Fg;
8

or equivalently as a general s-dimensional Knapsack Problem (sD-KP) or Packing Integer Program
(PIP),
Max

P n
j=1
y j

p j

x j

s.t.

P n
j=1 r ij x j  c i ; i = 1; : : : ; s;
x j 2 f0; 1g; j = 1; : : : ; n:

(9)
Let K(n; s; c) denote the time required (in the worst case) to compute a

1

c

-approximate solution for (9).
At each iteration, in addition to solving (9) (approximately), we also need to compute the new y vector
based on Ax for the current x. Though the dimension of x is exponential, the computation requires only
updating the previous Ax value, since the current x is (1 )x +  ^ x (for an appropriate step length

 2 (0; 1]), where ^ x is the vertex of P corresponding to the solution of (9) at the current iteration. Thus
the number of non-zero components of x can increase by at most one at each iteration, and each update
of Ax takes O(n) operations.
Initially, x

0

has at most n non-zero components obtained from solving n subproblems (one for each n-

dimensional unit vector as y) requiring O(nK(n; s; c)) time, and computing the initial y

0

in O(n

2

) time.
Approximating the root and determining the next price vector p can be done in O(n ln ln

n


) = O(n

2

)
time (for e.g.   1=n). Later each update of Ax

k

can be done in O(n) time. For any xed r, the
algorithm requires O(n(

2

+ 

3

ln c + ln n)(K(n; s; c) + n ln ln(n

1

)) time.
By binary search on r one can obtain a solution (x f ) f2F with

P

f2F x f = (1+=4)r



and

P

f2F :j2f x f 

1

c

(1 )p j , where r



is the length of an optimal schedule. Now one can dene ~ x f = x f c(1 + 4) and
obtain

P

f2F :j2f ~ x f  (1 )(1 + 4)p j = (1 + 3 4

2

)p j  p j for   3=4. In this case the length of
the generated schedule is at most cr



(1 + 4)(1 + =4) = cr



(1 + 4 + =4 + )  cr



(1 + ) by choosing

  1 and   3=20. Since the optimum of (6) lies within interval [p max ; np max ], the overall complexity
of the algorithm can be bounded by O(n ln

n


(

2

+ 

3

ln c + ln n)(K(n; s; c) + n ln ln(n

1

))) time. For

K(n; s; c)  O(n ln ln

n


) we obtain O(n ln(n

1

)(

2

+ 

3

ln c + ln n)K(n; s; c)) time.
The number of iterations can be improved by computing an approximate non-preemptive schedule
with a greedy algorithm. The main idea is to use a modied list scheduling algorithm. The classical list
scheduling algorithm is dened as follows. First consider the tasks in any xed order L = (T i 1 ; : : : ; T i n ).
At any time if there are positive quantities available from all resources, the algorithm scans L from
the beginning and selects the rst task T k (if there is any) which may validly be executed and which
has not been already (or is not currently) executed. If a task is nished, it will be removed from the
list. Garey and Graham [20] showed that this list scheduling algorithm for non-preemptive tasks gives
a (s + 1)-approximation ratio (comparing the length of the produced schedule and the optimum nonpreemptive
schedule). To compare with the optimal preemptive makespan C



max , we allow to overpack
the resources with one task at each time. Let C max (H) be the length of this (infeasible) pseudo-schedule
and consider a task T k that is nished at time C max (H). Then for each time t 2 [0; C max (H) p k ) at
least one resource is completly used by the tasks. Let l(i) be the total length of intervals where resource

i is overpacked. Clearly, we have l(i)  C



max and p k  p max  C



max . The length of the pseudo schedule
is at most

P s
i=1 l(i) + p k  (s + 1)C



max . By replacing the overpacked tasks to the end we obtain a
feasible schedule of length C

(MLS)

max  (2s + 1)C



max . This implies that C



max  C

(MLS)

max  (2s + 1)C



max ,
i.e. 1=(2s + 1)C

(MLS)

max  C



max  C

(MLS)

max . Hence the binary search for the optimum of (6) requires only

O(ln

s


) steps (instead of O(ln

n


)) improving the previous running time to

O(n(K(n; s; c) + n ln ln

n


) min(ln(s

1

); ln(n

1

))(

2

+ 

3

ln c + ln n)):

If the block problem posses an approximation scheme, then the factor 

3

ln c can be removed. As main
result we obtain:
9

Theorem 3.1 Let I be a set of instances of the preemptive resource constrained scheduling problem.
If there is a polynomial time approximation algorithm for the corresponding s - dimensional knapsack
instance with ratio c, then for any  > 0 there is a polynomial time algorithm for preemptive resource
constrained scheduling restricted to I with approximation ratio c(1 + ).

The number of congurations in the nal solution can be reduced from O(n(

2

+ 

3

ln c + ln n)) to

O(n) within O(n(

2

+ 

3

ln c + ln n)M(n)) time where M(n) is the time to invert a (n  n) matrix.
The maximum number of tasks per conguration is bounded by t = min(n; min

s
i=1
c i

min j r ij

)). Therefore,
the number of preemptions can be bounded by O(nt).
4 Approximability as a Function of the Number of Resources

As we have seen in the previous section, the s-dimensional Knapsack Problem is a key subproblem in our
approach whose solution (for various inputs) is required repeatedly. It is well known that the approximability
of this problem varies with the dimension s. Therefore in this section we will specialize the above
general result by making dierent assumptions on s and using dierent approximation algorithms for
the sD-KP. In particular, we will obtain a sequence of approximation results for our scheduling problem
where the approximation will improve (constant, PTAS, then FPTAS) as move from arbitrary to xed
number of resources and eventually to the case with a single resource. To contrast these approximation
algorithms, we will also present some inapproximability results for the rst two variants.
4.1 Arbitrary Number of Resources

In this section we consider the case when s is arbitrary, i.e. it is part of the input. First we give the
presentation of our approximation algorithms, then we brie
y discuss some simple inapproximability
results.
4.1.1 Approximation Algorithms

It is known [45, 49] that for general s, sD-KP or equivalently PIP has a
4 =s

1=c min

) approximation
algorithm when all r ij 2 [0; 1], c min = min i c i  1 and

y j

p j

 0. This implies the following result:

Theorem 4.1 For any number s of resources, there is a polynomial-time approximation algorithm with
performance ratio O(s

1

c min ) for the preemptive resource constrained scheduling problem.

This result can be further improved by using the algorithm by Srinivasan [49]. Furthermore, Srivastav and
Stangier [50, 51] showed that if c min 

16



2 log(2s) and OPT  12=

2

(where OPT is the optimum value of
the linear relaxation of (9)), an -approximate solution for sD-KP can be computed in polynomial-time.
The running time of the algorithm is bounded by O(K r (n; s; 1) + sn

2

ln(sn)), where K r (n; s; 1) is the
time required to solve (exactly) the linear programming relaxation of (9). Combining these with our
approach presented in the previous section and extending the algorithm to arbitrary OPT , we obtain
the following.

Theorem 4.2 For any number s of resources, if c i 

12



2 log(2s) and r ij 2 [0; 1], for each i and j,

there is a polynomial time approximation algorithm that computes a (1 + )-approximate solution for the
preemptive resource constrained scheduling problem.
10

The last two results can also be generalized to P jres:::; pmtnjC max with limited number of machines,
i.e. when m  n. Note that Theorems 4.1 and 4.2 hold only under some special conditions on resource
capacities and requirements. Therefore it is natural to ask whether they can be eliminated at least when

s is xed. After presenting some inapproximability results, we will show in Section 4.2 that if s is xed,
though the problem remains NP-hard, approximating its optimum becomes much easier. In particular
we prove that for any xed s the general problem has a PTAS.

4.1.2 Inapproximability

For any graph G = (V; E) one can construct a resource constrained scheduling problem with n = jV j tasks
and s = jEj resources, where vertices correspond to tasks and edges to resources in the following way:
The resource capacities are all 1, i.e. c e = 1 for each e 2 E, while resource requirement r ev = 1, if v 2 e,

and 0 otherwise. Independent sets of vertices correspond to sets of tasks that can be executed together
at the same time, therefore the (fractional) coloring problem for graphs can be viewed as a special case
of (preemptive) resource constrained scheduling. Hence the inapproximability results in [39, 18] imply
the following:

Theorem 4.3 For any  > 0, the preemptive resource constrained scheduling problem with n tasks and

s resources has no polynomial-time approximation algorithm with approximation ratio n

1 

, neither for
some  > 0, unless P = NP ; nor for any  > 0, unless ZPP = NP .

Note that this negative result holds even for the restricted case when each processing time is of unit
length, and all capacities and resource requirements are either 0 or 1. This shows that for arbitrary s

the problem is not only hard, but even approximating its optimum is dicult. Using that s  n

2

in the
special case above we get:

Corollary 4.1 The preemptive resource constrained scheduling problem with n tasks and s resources has
no polynomial-time approximation algorithm with approximation ratio s

1=2 

, neither for some  > 0,

unless P = NP ; nor for any  > 0, unless ZPP = NP .
4.2 Fixed Number of Resources - PTAS

In this section we study how the approximability of the problem changes under a restricting assumption
on the number of resources. We consider here the case, when s  1 is a xed constant larger than one.
As we argue below this restriction allows us to prove substantially better approximation result than the
one above. Namely, we will show that under the discussed assumption, the problem posses a PTAS, and
then we will also prove that - in fact - this is the best one can expect (unless P=NP).
4.2.1 Approximation Algorithms

It is known [40, 19] that for any xed s, sD-KP has a PTAS. Let K(n; s; ) denote the time required (in
the worst case) to compute a -approximate solution for the sD-KP. Using that s is constant, the running
time of our scheduling algorithm is bounded by O((K(n; s; c) +n ln ln(n

1

))n ln(

1

)(

2

+ ln n)). The
currently known best bound [7] for K(n; s; ()) is O(n

b

s


cs

) = n

O(

s
 )

. By using this bound and the
above argument, we obtain the following result.

Theorem 4.4 For any xed number s of resources, there is a PTAS for the preemptive resource constrained
scheduling problem with running time n

O(

s


)

.
11

Notice that for xed s, there is also a O(n) time (s + 1)-appproximation algorithm for the sD-KP [7],
which implies the following:

Corollary 4.2 There is a (s+1)(1+)-approximation algorithm for the preemptive resource constrained
scheduling problem with running time O((n

2

ln ln(n

1

)) ln(

1

)(

2

+ ln n)).
4.2.2 Inapproximability

The running time of the previously described algorithm depends exponentially on the accuracy, and as
the next result shows this dependence cannot be improved to polynomial, unless P=NP.

Theorem 4.5 For any s  2, there is no FPTAS for the preemptive resource constrained scheduling
problem with s resources, unless P = NP .

Proof: We use a reduction from the NP-complete problem Partition: Given a set A and a size s(a) 2 IN
for each a 2 A, where n = jAj is assumed to be even, decide whether there is a subset I of A such that

jIj = n=2 and

P

a2I s(a) =

1
2

P

a2A s(a).

Let s max = max a2A s(a). Now construct n tasks and two resources with capacities

1
2

P

a2A s(a)

and

1
2

P

a2A (s max s(a)), where each task a 2 A requires (s(a); s max s(a)) of the two resources
and has processing time p a = 1. If there is a solution I of the partition problem, then jIj = n=2,

P

a2I s(a) =

1
2

P

a2A s(a) and

P

a2I (s max s(a)) =

1
2

P

a2A (s max s(a)). This means that set I can be
executed in parallel on both resources. Furthermore, the set A n I is also a solution for the partition
problem and can be executed also parallel on both resources. Therefore, one can schedule all tasks in
two phases in a non-preemptive way: in one phase all tasks in I (of length 1), and in the other phase
all tasks in A n I (also of length 1). This gives a schedule with makespan C max = 2 and the minimum
makespan is C



max = 2 (by using an argument based on the required minimum area for all tasks). If
there is no solution of the partition problem, then we can still split the set in three parts I 1 ; : : : ; I 3

according to resource 1 such that

P

a2I j

s(a) 

1
2

P

a2A s(a). Now only one of these parts can have

P

a2I j (s max s(a)) >

1
2

P

a2A (s max s(a)). By splitting this set (according to resource 2) in three parts,
we obtain a feasible non-preemptive schedule of length C max  5. This implies that C



max  5.
Assume now that there is a FPTAS for the preemptive 2-resource constrained scheduling problem
and then show that this leads to a contradiction. The FPTAS gives for each  > 0 a poly(n; 1=) time
algorithm to obtain a schedule with length  C



max (1 + )  C



max + 5. If we choose  = 1=5n then we
obtain in poly(n) time a preemptive schedule with length  C



max + 1=n. The length of the preemptive
schedule (given by the FPTAS with  = 1=5n) is larger than 2 + 1=n if and only if the partition problem
has no solution. If the length of the schedule is larger than 2 + 1=n, then C



max > 2 implying that
we have a no-instance of the partition problem. Consider the other direction: For each time step t

there are at least n=2 + 1 tasks which are not executed at step t; otherwise we had a solution of the
partition problem. To see this consider a set I of n=2 tasks executed at one time step. This implies that

P

a2I s(a)  1=2

P

a2A s(a) and

P

a2I (s max s(a)) 

1
2

P

a2A (s max s(a)). Both of these inequalities
can be transformed into:
(n=2)s max

X

a2I

s(a) 

X

a2I

(s max s(a)) 

1
2

X

a2A

(s max s(a)) = (n=2)s max

X

a2I

s(a):
Then,

P

a2I s(a) =

1
2

P

a2A s(a) and

P

a2I (s max s(a)) =

1
2

P

a2A (s max s(a)). Therefore, I is a solution
of the partition problem.
Let ne(i) be the total length in interval [0; 2] where task T i is not executed. Using the property
above,

P n
j=1 ne(i)  2(n=2 + 1) = n + 2. This implies that at least one task T k has ne(k)  1 + 2=n.
12

Therefore, this task is executed at most 1 2=n in interval [0; 2] and the schedule length is at least
2 + 2=n. This argument implies that we can test (using the FPTAS) the existence of a solution for the
partition problem in polynomial time, which is impossible, unless P=NP.
In the proof above we have used an idea of Korte and Schrader [35]. They proved that there is no
FPTAS for the sD-KP with s = 2, unless P = NP . Since it was essential in the proof of Theorem 4.5
that s is (at least) two, it is natural to ask again, what happens when s = 1. In this case - as it will be
demonstrated in the next section - there is a FPTAS for the problem, and hence the negative result of
Theorem 4.5 does not hold any longer.
4.3 Single Resource - FPTAS

Clearly, the general approach presented in Section 4.2 can also be used for the special case when there
is only one resource. Note that the number of iterations in computing an approximate solution for (6) is
independent of s, so it remains O(n(

2

+lnn)), as above. The only dierence is that the subproblem one
has to solve (approximately) at each iteration becomes the classical (1-dimensional) Knapsack Problem
(instead of the s-dimensional variant). This can be solved approximately with any () accuracy in

O(nmin(ln n; ln(1=)) + 1=

2

min(n; 1= ln(1=))) = O(n

2

) time [32]. In addition, we have to count
the overhead of O(n ln ln(n

1

)) operations in each iteration (i.e. the computation of the root and the
new price vector). Hence the previous bound can be substituted for K(n; s; ()) in the analysis above in
Section 4.2, and therefore for any xed r the procedure requires O(n

2

max(

2

; ln ln(n

1

))(

2

+ ln n))

time (including also the overheads arising from computing the initial solution).
Similarly to the discussion in Section 4.2, one can use binary search on r to nd a good approximation
for the optimum of (6). The initial interval for r can be determined by a strip packing algorithm (called
longest task rst) [8, 53] that computes a non-preemptive schedule of length at most three times the
length of the an optimal preemptive schedule. These all imply the following:

Theorem 4.6 If there is only one resource, the resource constrained scheduling problem has a FPTAS
which runs in O(n

2

ln(

1

) max(

2

; ln ln(n

1

))(

2

+ ln n)) time.

So far we have assumed that m is suciently large (e.g. m  n), or otherwise processors can be
treated as an extra resource. But having seen above the the dividing line (regarding approximability)
between instances with 1 and 2 resources, one may naturally ask how easy or dicult it is to compute
approximate solutions for the problem when there is one resource and a limited number of machines.
Krause, Shen and Schwetman [36] gave a polynomial-time (3

1

n

)-approximation algorithm for the
problem. This can be substantially improved by following our approach and extending Theorem 4.6 to
this variant. First formulate it as a restricted preemptive 2-resource constrained scheduling problem,
where the m identical machines correspond to the 2nd resource with r 2j = 1 for each task j and capacity

c 2 = m. It is easy to check, that the subproblem in this case is the cardinality constrained (

P n
j=1

x j  m)

knapsack problem, which has a FPTAS with running time O(nm

2



1

) [7]. In addition, the initial interval
for the binary search on r can be bounded as for s = 2 resources. Hence the following holds:

Theorem 4.7 There is a FPTAS of running time O(n

2

ln(

1

) max(m

2



1

; ln ln(n

1

)(

2

+ ln n))) for

P jres1::; pmtnjC max .
This result can also be extended to the variant P jres s::; r j ; pmtnjL max , where the input contains
release r j and delivery q j dates for each task T j , and the objective is to nd a schedule minimizing the
maximum delivery completion time L max = max j C j + q j .

Theorem 4.8 There is a FPTAS for P jres 1::; r j ; pmtnjL max that runs in poly(n; 1=) time.
13

5 Multiprocessor Task Scheduling

In this section we address preemptive multiprocessor task scheduling problems, where a set T =

fT 1 ; : : : ; T n g of n tasks has to be executed by m processors such that each processor can execute at
most one task at a time and a task must be processed simultaneously by several processors.
Since we consider here the preemptive model, each task can be interrupted any time at no cost and
restarted later possibly on a dierent set of processors. We will focus on those preemptive schedules where
migration is allowed, that is where each task may be assigned to dierent processor sets during dierent
execution phases [4, 14, 15]. The malleable variant of multiprocessor task scheduling, P jfctn j ; pmtnjC max

can be formulated as the following linear program [30], where M j denotes the set of dierent cardinalities
that processor sets executing task T j can have.
Min

P

f2F x f

s.t.

P

`2M j

1

p j (`)

P

f2F :jf

1

(j)j=` x f  1; j = 1; : : : ; n;
x f  0; 8f 2 F:

(10)
Here the goal is to nd for a given r a vector x 2 P = f(x f ) :

P

f2F x f = r; x f  0; f 2 Fg that
satises all the other constraints in (10). This corresponds to a vector x 2 P such that Ax  1 .

Again, we get a subroutine to nd a vertex ~ x in P such that c

T

~ x  c

T

x for all x 2 P , where c = y

T

A.

For each task T j we have now dierent values in M j and hence in the corresponding Knapsack Problem
the prot y j =p j (`) depends on the cardinality ` 2 M j , while the capacity of the knapsack remains m, as
before. The subroutine corresponds now to a generalized Knapsack Problem with dierent choices for
tasks (items). The problem we have to solve (approximately) for a given n-vector (y 1 ; : : : ; y n ) can be
formulated as follows:
Max

P n
j=1

P

`2M j

y j

p j (`)  x j`

s.t.

P n
j=1

P

`2M j `  x j`  m;

P

`2M j

x j`  1; j = 1; : : : ; n;
x j` 2 f0; 1g; ` 2 M j ; j = 1; : : : ; n:

(11)
In fact, this is the Multiple-choice Knapsack Problem. For this problem, Lawler [37] showed that an

-approximate solution can be computed in O(

P

j jM j j ln jM j j +

P

j jM j jn=) = O(nm ln m + n

2

m=)

time. In order to obtain a lower bound, one can compute d j = min 1`m p j (`) and d max = max j d j .
Then d max  OPT  nd max . In this case, the overhead O(n ln ln(n=)) = O(n ln ln n + n ln ln(1=)) =

O(n

2

+ n

1

) is less than the running time required by the knapsack subroutine. Hence by using an
argument similar to the one in the previous section, one can obtain the following result.

Theorem 5.1 There exists a FPTAS for P jfctn j ; pmtnjC max whose running time is bounded by O(n(

2

+
ln n) ln(n

1

)(nm ln m+ n

2

m

1

)).
Other variants of P jfctn j ; pmtnjC max concern preemptive scheduling on parallel processors, where
the underlying interconnection network is not completely disregarded. (Note that in the original formulation,
we assumed nothing about the network architecture.) Based on the above results the following
can be shown:

Theorem 5.2 If the processors are arranged in a line or hypercube network, P jfctn j ; pmtnjC max has a
FPTAS that runs in O(n(

2

+ ln n) ln(n

1

)(nm ln m+ n

2

m

1

)) time.
14

6 Weighted Fractional Coloring

Let G = (V; E) be a graph with a positive weight w v for each vertex v 2 V . Let I be the set of all
independent sets of G. The weighted fractional coloring problem consists of assigning a non-negative real
value x I to each independent set I of G such that each vertex v 2 V is completely covered by independent
sets containing v (i.e. the sum of their values is at least w v ) and the total value

P

I x I is minimized. This
problem can also be formulated as a linear program of form (6). Similarly to Section 3, this linear program
can be solved approximately by using binary search on the optimum value r



and computing at each
stage for the current r an approximate solution for a fractional covering problem of form (7). Let w max =
max v2V w v be the maximum weight of a vertex. By binary search, one can obtain a solution (x I ) I2I

with

P

I2I x I = (1 + =4)r



and

P

I2I:v2I x I  1=c(1 )w v . Now one can dene ~ x I = x I c(1 + 4) and
obtain

P

I2I:v2I ~ x I  (1 )(1+4)w v = (1+3 4

2

)p j  p j for   3=4. In this case, the length of the
generated fractional coloring is at most cr



(1+4)(1+=4) = cr



(1+4+=4+)  cr



(1+) by choosing

  1 and   3=20. Since the optimum lies within the interval [w max ; nw max ], the overall complexity of
the algorithm can be bounded by O((n ln n + n ln c=

3

+ n=

2

)(W IS(G; n; c; d) + n ln ln(n=)) ln(n

1

)),
where W IS(n; c; d) is the time required to compute an approximate weighted independent set for a
weighted graph (G; w). The above arguments imply the following result.

Theorem 6.1 Let G be a graph class. If there is a polynomial time algorithm for the weighted independent
set problem restricted to graphs G 2 G with approximation ratio 1=c for c  1, then for any  > 0

there is a polynomial time algorithm for the fractional weighted coloring problem restricted to G with
approximation ratio c(1 + ).

Corollary 6.1 Let G be a graph class. If there is a (F)PTAS for the computation of the weighted
independent set in a graph G 2 G and weights w, then we obtain a (F)PTAS for the fractional weighted
coloring problem for graphs G 2 G.

Using a recent result [17] for computing the maximum weighted independent set in intersection graphs
of disks in the plane, we obtain the following:

Corollary 6.2 There is a PTAS for the computation of the fractional weighted chromatic number for
intersection graphs of disks in the plane.
Since this graph class contains planar graphs and unit disk graphs, Corollary 6.1 implies the following
result which also provides a substantial improvement on Matsui's polynomial-time 2-approximation
algorithm [41] for unit disk graphs:

Corollary 6.3 There is a PTAS for the computation of the fractional weighted chromatic number for
planar and unit disk graphs.
7 Conclusion

In this paper we have studied preemptive variants of resource constrained scheduling and the closely
related fractional coloring problem. The approach we presented is based on linear programming formulations
with exponentially many variables but with special structures allowing ecient approximations.
The linear programs are solved (approximately) in an iterative way as covering problems, where at each
iteration subproblems of the same type have to be solved. Interestingly, for resource constrained scheduling
these subproblems turned out to be knapsack type problems (multiple-choice, multi-dimensional, and
15

cardinality constrained knapsack) with ecient approximation algorithms. For fractional coloring, it is
the well known maximum weighted independent set problem.
For some of the subproblems we have encountered, there are only relatively weak polynomial-time
approximation results (i.e. with constant, logarithmic, or with even worse approximation ratios). To
handle these cases too, we have extended some of the methods in [24, 44, 54] to the case where the
subproblem can be solved only approximatively. The underlying algorithm is independent from the
width [44] and the number of variables. We note that by using other techniques [31] (via the ellipsoid
method and approximate separation) with higher running time the ratio c(1 + ) in Theorems 3.1 and
6.1 can be improved to ratio c.

We mention in closing, that by using the same approach, similar approximation results can be
expected for various other preemptive scheduling and fractional graph problems, e.g. for fractional path
coloring, call scheduling, bandwidth allocation, scheduling multiprocessor tasks on dedicated processors,
as well as open, 
ow and job shop scheduling.

Acknowledgement: The authors thank R. Schrader and A. Srivastav for helpful comments on the
complexity of the 2-dimensional knapsack problem and the approximation of sD-KP, respectively.
References

[1] A.K. Amoura, E. Bampis, C. Kenyon and Y. Manoussakis, Scheduling independent multiprocessor tasks,

Proceedings of the 5th European Symposium on Algorithms (1997), LNCS 1284, 1-12.
[2] B. Baker, E. Coman and R. Rivest, Orthogonal packings in two dimensions, SIAM Journal on Computing,

9 (1980), 846-855.
[3] J. Blazewicz, W. Cellary, R. Slowinski and J. Weglarz, Scheduling under resource constraints - deterministic
models, Annals of Operations Research, 7 (1986).
[4] J. Blazewicz, M. Drabowski and J. Weglarz, Scheduling multiprocessor tasks to minimize schedule length,

IEEE Transactions on Computers, C-35-5 (1986), 389-393.
[5] J. Blazewicz, K.H. Ecker, E. Pesch, G. Schmidt and J. Weglarz, Scheduling in Computer and Manufacturing
Systems, Springer Verlag, Berlin (1996).
[6] J. Blazewicz, J.K. Lenstra and A.H.G. Rinnooy Kan, Scheduling subject to resource constraints: Classication
and Complexity, Discrete Applied Mathematics 5 (1983), 11-24.
[7] A. Caprara, H. Kellerer, U. Pferschy and D. Pisinger, Approximation algorithms for knapsack problems with
cardinaliy constraints, European Journal of Operational Research 123 (2000), 333-345.
[8] E. Coman, M. Garey, D. Johnson and R. Tarjan, Performance bounds for level-oriented two dimensional
packing algorithms, SIAM Journal on Computing, 9 (1980), 808-826.
[9] A.K. Chandra, D.S. Hirschberg and C.K. Wong, Approximate algorithms for some generalized knapsack
problems, Theoretical Computer Science, 3 (1976), 293-304.
[10] C. Chekuri and S. Khanna, On multi-dimensional packing problems, Proceedings 10th ACM-SIAM Symposium
on Discrete Algorithms (1999), 185-194.
[11] G.I. Chen and T.H. Lai, Scheduling independent jobs on hypercubes, Proceedings 5th Symposium on Theoretical
Aspects of Computer Science (1988), LNCS 294, 273-280.
[12] W.F. de la Vega and C.S. Lueker, Bin packing can be solved within 1 +  in linear time, Combinatorica, 1
(1981), 349-355.
[13] M. Drozdowski, On the complexity of multiprocessor task scheduling, Bulletin of the Polish Academy of
Sciences, 43 (1995), 381-392.
16

[14] M. Drozdowski, Scheduling multiprocessor tasks - an overview, European Journal on Operations Research,

94 (1996), 215-230.
[15] J. Du and J. Leung, Complexity of scheduling parallel task systems, SIAM Journal on Discrete Mathematics,

2 (1989), 473-487.
[16] T. Erlebach and K. Jansen, Conversion of coloring algorithms into maximum weight independent set algorithms,
 Workshop on Approximation and Randomization Algorithms in Communication Networks (2000),
Carleton Scientic, 135-146.
[17] T. Erlebach, K. Jansen and E. Seidel, Polynomial-time approximation schemes for geometric graphs, Proceedings
of the 12th ACM-SIAM Symposium on Discrete Algorithms (2001), 671-679.
[18] U. Feige and J. Kilian, Zero knowledge and the chromatic number, Journal of Computer and System Sciences,

57 (1998), 187-199.
[19] A.M. Frieze and M.R.B. Clarke, Approximation algorithms for the m-dimensional 0 1 knapsack problem,

European Journal of Operational Research, 15 (1984), 100-109.
[20] M.R. Garey and R.L. Graham, Bounds for multiprocessor scheduling with resource constraints, SIAM Journal
on Computing, 4 (1975), 187-200.
[21] M.R. Garey, R.L. Graham, D.S. Johnson and A.C.-C. Yao, Resource constrained scheduling as generalized
bin packing, Journal Combinatorial Theory A, 21 (1976), 251-298.
[22] S. Gerke and C. McDiarmid, Graph imperfection, unpublished manuscript, 2000.
[23] M.D. Grigoriadis and L.G. Khachiyan, Coordination complexity of parallel price-directive decomposition,

Mathematics of Operations Research, 21 (1996), pp. 321-340.
[24] M.D. Grigoriadis, L.G. Khachiyan, L. Porkolab and J. Villavicencio, Approximate max-min resource sharing
for structured concave optimization, to appear in SIAM Journal on Optimization, available as Technical
Report LCSR-TR-374, Rutgers University, 1999.
[25] M. Grotschel, L. Lovasz and A. Schrijver, The ellipsoid method and its consequences in combinatorial
optimization, Combinatorica, 1 (1981), 169-197.
[26] M. Grotschel, L. Lovasz and A. Schrijver, Geometric Algorithms and Combinatorial Optimization, Springer
Verlag, Berlin, 1988.
[27] O.H. Ibarra and C.E. Kim, Fast approximation algorithms for the knapsack and sum of subset problem,

Journal of the ACM, 22 (1975), 463-468.
[28] K. Jansen and L. Porkolab, Linear-time approximation schemes for scheduling malleable parallel tasks,

Proceedings 10th ACM-SIAM Symposium on Discrete Algorithms (1999), 490-498.
[29] K. Jansen and L. Porkolab, Preemptive scheduling on dedicated processors: applications of fractional
graph coloring Proceedings 25th International Symposium on Mathematical Foundations of Computer Science

(2000), LNCS 1893, Springer Verlag, 446-455.
[30] K. Jansen and L. Porkolab, Computing optimal preemptive schedules for parallel tasks: Linear Programming
Approaches, Proceedings 11th Annual International Symposium on Algorithms and Computation (2000),
LNCS 1969, Springer Verlag, 398-409.
[31] K. Jansen, Approximate separation with application in fractional coloring and preemptive scheduling, unpublished
manuscript (2001).
[32] H. Kellerer and U. Pferschy, A new fully polynomial approximation scheme for the knapsack problem, Proceedings
1st International Workshop on Approximation Algorithms for Combinatorial Optimization (1998),
123-134.
[33] C. Kenyon and E. Remila, Approximate strip packing, Proceedings 37th IEEE Symposium on Foundations
of Computer Science (1996), 31-36.
17

[34] K. Kilakos and O. Marcotte, Fractional and integral colourings, Mathematical Programming, 76 (1997),
333-347.
[35] B. Korte and R. Schrader, On the existence of fast approximation schemes, Nonlinear Programming, 4
(1981), 415-437.
[36] K.L. Krause, V.Y. Shen and H.D. Schwetman, Analysis of several task scheduling algorithms for a model of
multiprogramming computer systems, Journal of the ACM, 22 (1975), 522-550 and Errata, Journal of the
ACM, 24 (1977), 527.
[37] E. Lawler, Fast approximation algorithms for knapsack problems, Mathematics of Operations Research, 4
(1979), 339-356.
[38] W. Ludwig and P. Tiwari, Scheduling malleable and nonmalleable parallel tasks, Proceedings 5th ACM-SIAM
Symposium on Discrete Algorithms (1994), 167-176.
[39] C. Lund and M. Yannakakis, On the hardness of approximating minimization problems, Journal of the ACM,

41 (1994), 960-981.
[40] O. Oguz and M.J. Magazine, A polynomial time approximation algorithm for the multidimensional 0 1
knapsack problem, working paper, University of Waterloo, 1980.
[41] T. Matsui, Approximation algorithms for maximum independent set problems and fractional coloring problems
on unit disk graphs, Proceedings Symposium on Discrete and Compuational Geometry, LNCS 1763
(2000), 194-200.
[42] G. Mounie, C. Rapine and D. Trystram, Ecient approximation algorithms for scheduling malleable tasks,

Proceedings ACM Symposium on Parallel Algorithms (1999), 23-32.
[43] T. Niessen and J. Kind, The round-up property of the fractional chromatic number for proper circular arc
graphs, Journal of Graph Theory, 33 (2000), 256-267.
[44] S.A. Plotkin, D.B. Shmoys, and E. Tardos, Fast approximation algorithms for fractional packing and covering
problems, Mathematics of Operations Research, 20 (1995), 257-301.
[45] P. Raghavan, C.D. Thompson, Randomized rounding: a technique for provably good algorithms and algorithmic
proofs, Combinatorica 7 (1987), 365-374.
[46] I. Schiermeyer, Reverse-Fit: A 2-optimal algorithm for packing rectangles, Proceedings 2nd European Symposium
of Algorithms (1994), LNCS 855, 290-299.
[47] E.R. Schreinerman and D.H. Ullman, Fractional graph theory: A rational approach to the theory of graphs,
Wiley Interscience Series in Discrete Mathematics, 1997.
[48] P.D. Seymour, Colouring series-parallel graphs, Combinatorica, 10 (1990), 379-392.
[49] A. Srinivasan, Improved approximation guarantees for packing and covering integer programs, Proceedings
27th ACM Symposium on the Theory of Computing (1995), 268-276.
[50] A. Srivastav and P. Stangier, Algorithmic Cherno-Hoeding inequalities in integer programming, Random
Structures and Algorithms, 8(1) (1996), 27-58.
[51] A. Srivastav and P. Stangier, Tight approximations for resource constrained scheduling and bin packing,

Discrete Applied Mathematics, 79 (1997), 223-245.
[52] A. Steinberg, A strip-packing algorithm with absolute performance bound two, SIAM Journal on Computing,

26 (1997), 401-409.
[53] J. Turek, J. Wolf and P. Yu, Approximate algorithms for scheduling parallelizable tasks, Proceedings 4th
ACM Symposium on Parallel Algorithms and Architectures (1992), 323-332.
[54] N.E. Young, Randomized rounding without solving the linear program, Proceedings 6th ACM-SIAM Symposium
on Discrete Algorithms (1995), 170-178.
[55] Y. Zhu and M. Ahuja, On job scheduling on a hypercube, IEEE Transactions on Parallel Distributed Systems,

4 (1993), 62-69.
18

