Page 1

A PTAS for Scheduling with Tree

Assignment Restrictions

Ulrich M. Schwarz∗

Institut für Informatik

Christian-Albrechts-Universität zu Kiel

24098 Kiel, Germany

September 24, 2010

Scheduling with assignment restrictions is an important special case of

scheduling unrelated machines which has attracted much attention in the

recent past. While a lower bound on approximability of 3/2 is known

for its most general setting, subclasses of the problem admit polynomial-

time approximation schemes. This note provides a PTAS for tree-like

hierarchical structures, improving on a recent 4/3-approximation by Huo

and Leung [HL10].

1 Introduction

Scheduling on unrelated machines to minimize the makespan is one of the classical

problem in optimization; here, we are given a set of n jobs and m machines, such

that execution of a job j on machine i takes time pij∈ N. The objective is to find a

schedule, i.e. an assignment σ : {1,...,n} → {1,...,m} of the jobs to the machines

that minimizes the makespan Cmax= max{∑σ(j)=ipij: i ∈ {1,...,m}}.

Despite its formal simplicity, it is still not understood completely: no approxima-

tion result is known that is asymptotically better than the seminal 2-approximation

of Lenstra, Shmoys and Tardos [LST90], with asymptotical improvements made by

Vakhania and Shechpin [SV05]; however, the known lower bound on approximability

is only 3/2, also due to Lenstra, Shmoys and Tardos.

∗ums@informatik.uni-kiel.de

1

arXiv:1009.4529v1 [cs.DS] 23 Sep 2010

Page 2

A seemingly simpler problem is that of assignment restrictions: here, for every job

j we have a length pj∈ N and a set Mj⊂ {1,...,m} of feasible machines, i.e. we

have pij= pjfor all i ∈ Mjand pij= ∞ for all i ?∈ Mj.

Related results

bitrary assignment restrictions is also impossible to approximate better than within a

factor of 3/2, unless P = NP, and for the general case, no algorithm better than the

2-approximation for the unrelated machine case is known. However, better results are

known for special structures of the sets Mj. If we have |Mj| ≤ 2, we can think of

jobs as edges in a graph whose vertices are the machines, and orienting the edge in

one direction will increase the load of one of its endpoints. In this graph balancing

setting, Ebenlendr et al. [EKS08] give a 7/4-approximation. If the graph additionally

a tree, Lee et al. [LLP09] give an FPTAS.

Another type of restriction studied is that of the relation between the Mjsets: the

most recent results being a PTAS by Muratore et al. [MSW10] for the case of nested

restrictions, i.e. for each two Mj,Mj?, one of Mj⊆ Mj?, Mj⊇ Mj? or Mj∩Mj? = / 0

holds, and a 4/3-approximation for tree-hierarchical assignment restrictions by Huo

and Leung [HL10]. In this setting, again machines are considered vertices of a graph,

a rooted tree in particular, and we impose that the sets Mjmust correspond to the

machines on a path from a node to the root.

For older results, we refer the reader to the survey [LL08] by Leung and Li.

As shown already by Lenstra et al. [LST90], scheduling with ar-

Contribution of this note.

Huo and Leung and prove the following result:

We consider the tree-hierarchical assignment case by

Theorem 1 (label=thm:tree-ptas). Scheduling with tree-hierarchical assignment re-

strictions admits a PTAS, i.e. for every ε > 0 there is an (1+O(ε))-approximation

with running time polynomial in the input size (but exponential in 1/ε).

2 Rounding and simplifying the instance

Our algorithm combines some of the usual techniques for PTAS design such as parti-

tion into job sizes and geometric rounding with a hierarchical dynamic programming

approach bottom-up through the tree. In this section, we describe the rounding and

simplification steps we take to make the problem treatable by dynamic programming.

Throughout the following, let ε > 0. To simplify the analysis, our algorithm will

create a solution of length at most (1+4ε) times the optimal value OPT. (For sim-

plicity, we use OPT to refer to both an optimal schedule and its makespan, since the

distinction is clear from context.) Note OPT must be integral since all jobs lengths are,

2

Page 3

and it is bounded pseudopolynomially in the instance size, for example by ∑n

Hence we may, in polynomial time, perform binary search over the range of feasible

makespans and it is sufficient to give a relaxed decision procedure that for a guessed

target makespanC yields a schedule of length at most (1+4ε)C whenever a schedule

of length at mostC exists.

In the following, we call a job small if pj≤ εC, otherwise, we call it large. We will

round up every large job to be of the form εC·(1+ε)kfor integral k. The number

K = O(log1+ε1/ε) of values k that can occur only depends on ε, i.e. it is a constant

for purposes of running time. The following classical result holds for this rounding:

j=1pj.

Lemma 2. If there is a schedule of length C of the original instance, there exists a

schedule of the rounded instance with a constant number K of large job sizes which

has length at most (1+ε)C.

It is also clear that a feasible schedule of the rounded instance is feasible for the

original instance by replacing rounded large jobs with their (possibly slightly smaller)

unrounded counterparts.

We now want to approximately describe every subset of the rounded instance by a

(K +1)-element configuration tuple. For large jobs, we simply count the number of

jobs of each job size, which must be in {0,...,n}. For small jobs, we count the total

space taken up by them, in integral multiples of εC, rounding up. Since every small

job has size ≤ εC, the total size of all small jobs is at most n·εC, so this size indicator

for small jobs is also from the set {0,...,n}. In total, the number of configuration

tuples is at most (n+1)K+1, in particular, it is polynomial in the input size.

We can in this way associate with each node v in the tree the configuration tuple

cvof jobs j whose set Mjis the path starting in v. If svis the size multiplicity of the

small jobs among them, i.e. their total size is in the interval ](sv−1)·εC,sv·εC], we

add up to one dummy job of size up to εC to make the total size exactly sv·εC. By

leaving that job on machine v in the schedule, we obtain

Lemma 3. If there is a schedule of length at most (1+ε)C in the rounded instance,

there is a schedule of length at most (1+2ε)C in the rounded and modified instance.

Let us now consider such a schedule σ of length at most (1+2ε)C. On every

machine (node) v, a certain subset σ−1(v) of jobs is scheduled. Hence, it has a cor-

responding configuration tuple associated with it, the total size of which is at most

(1+3ε)C. The additional loss is again incurred because the small jobs in σ−1(v)

might not be an integral multiple of εC. It is these configurations that we will find by

dynamic programming.

3

Page 4

3 The algorithm

In this section, we describe how to find a feasible assignment of configuration tuples

to machines, if it exists, and how to convert this back into a schedule with a small

increase in makespan.

The core of our algorithm is a local procedure which works as follows for a node v:

1. In the first step, we accumulate the possible subsets of not-yet-scheduled jobs

that v may need to accept from its children. We maintain a set of possible subset

configuration tuples S, which initially contains only the all-zero tuple. Then, for

each child of v in turn, we consider the set S?of tuples it pushes towards the root

and set S := S+S?= {c+c?: c ∈ S,c?∈ S?}. Since the size of S and S?is always

polynomial, this can be done in polynomial time for every child, and since there

are at most n children, finding the ultimate S with all children taken into account

also takes polynomial time.

2. Then, we augment S by adding to each tuple the tuple cvof jobs that are only

available for scheduling on v and its ancestors. The resulting set, which we still

denote S, still has polynomial size.

3. For each c∈S, we consider every possible subconfiguration ˆ s that can be sched-

uled on v, i.e. is of total size at most (1+3ε)C. Then, the relative complement

c− ˆ c corresponds to jobs that would need to be pushed towards v’s parent node

if we schedule according to ˆ c on v. Again, since S is polynomially bounded

and the number of possible ˆ c is as well, this can be done in polynomial time

and yields a polynomially-sized set of configurations that are possibly pushed

upwards.

Our algorithm, for a given target makespan C, will execute this procedure in any

leaf-to-root order, i.e. it is always run on the children of a node before it is run on

the node itself. We return that a feasible schedule exists if it is possible to push up

the all-zero configuration tuple from the root. The configuration tuples themselves

can be obtained by standard bookkeeping techniques, i.e. storing, for each sum-of-

configurations configuration that occurs one (and only one) set of witness summands.

Clearly, if there is a feasible assignment of configurations to machines of length at

most (1+3ε)C, the algorithm will find one, too, since all configuration tuples that can

be pushed into a node are considered.

Tocompletetheproofof??, itremainstoshowhowtoassignthejobs. Thisistrivial

for large jobs: we select feasible jobs of that size in an arbitrary fashion bottom-up,

pushing the remainder upwards. Since nothing is pushed beyond the root, all large

jobs are assigned. The situation for small jobs is slightly more complicated, since

4

Page 5

we do not know the exact total size of the small jobs. However, we can simply fill

the available space in a greedy manner until it is fully used (or we run out of small

jobs), i.e. the last small job may protude beyond the allotted size. Since the last job’s

size is at most εC by definition, this will increase the makespan of the schedule we

generate by another +εC to at most (1+4ε)C, and it will at most decrease the total

size of small jobs pushed towards the root, which clearly maintains feasibility of the

remaining configurations.

4 Conclusion

This note shows another case, tree-hierarchical structures, in which scheduling with

assignment restrictions can be approximated within arbitrary accuracy. This mostly

settlesthecomplexity: anFPTAScannotexistsincethesettinggeneralizesthestrongly

NP-hard problem P||Cmax, the existance of an EPTAS is still open.

For other important settings, the question of inapproximability vs. PTAS is still

open: in particular, two natural cases would be cross-free families, where for two sets

Mj,Mj?, Mj∪Mj? = {1,...,m} may also occur in addition to the three cases defining

nested families as given in the introduction, and interval restrictions, where every Mj

is of the form {αj,...,ωj} for a fixed permutation of the machines.

References

[EKS08] Tomás Ebenlendr, Marek Krcal, and Jiri Sgall. Graph balancing: a special

caseofschedulingunrelatedparallelmachines. InShang-HuaTeng, editor,

SODA, pages 483–490. SIAM, 2008.

[HL10] Yumei Huo and Joseph Y.-T. Leung. Fast approximation algorithms for job

scheduling with processing set restrictions. Theoretical Computer Science,

2010. To appear.

[LL08] Joseph Y.-T. Leung and C.-L. Li. Scheduling with processing set restric-

tions: a survey. International Journal of Production Economics, 116:259–

271, 2008.

[LLP09] Kangbok Lee, Joseph Y.-T. Leung, and Michael Pinedo. A note on graph

balancing problems with restrictions.

110(1):24–29, 2009.

Information Processing Letters,

[LST90] Jan Karel Lenstra, David B. Shmoys, and Éva Tardos. Approximation

algorithms for scheduling unrelated parallel machines. Mathematical Pro-

gramming, 46:259–271, 1990.

5