Gabor Szabo - Diss - ETH - 16207 PDF

DISS. ETH No.
16207, 2005
Optimization Problems in
Mobile Communication
A dissertation submitted to the

Swiss Federal Institute of Technology, ETH Zurich
for the degree of Doctor of Technical Sciences
presented by
Dipl. Eng. in Comp. Sc. Gabor Vilmos Szabo
born 19.12.1976, citizen of Zalau, Romania
accepted on the recommendation of

Prof. Dr. Peter Widmayer, ETH Zurich, examiner
Dr. Thomas Erlebach, University of Leicester, coexaminer
Dr. Riko Jacob, ETH Zurich, coexaminer
Katibogaramnak
Abstract
In one way or another mobile phones have changed everyones life.
Mobile communication networks made it possible to be connected
and reachable even in the most remote places. A lot of research ef-
fort has been put lately in the planning and optimization of mobile
networks. Network providers as well as users can only gain in effi-
ciency and usability if the algorithmic optimization community pro-
vides them with efficient algorithmic solutions to the optimization
problems raised by mobile communication networks.
In this thesis, we analyze three different algorithmically interest-
ing problems stemming from mobile telecommunication: the base
station location with frequency assignment; the OVSF code assign-
ment problem; and the joint base station scheduling problem.
We propose a new solution technique to the problem of position-
ing base station transmitters and assigning frequencies to the trans-
mitters. This problem stands at the core of GSM network design
and optimization. Since most interesting versions of this problem are
N P-hard, we follow a heuristic approach based on the evolutionary
paradigm to find good solutions. We examine and compare two stan-
dard multiobjective techniques and a new algorithm, the steady state
evolutionary algorithm with Pareto tournaments (stEAPT). The evo-
lutionary algorithms used raised an interesting data structure prob-
lem. We present a fast priority queue based technique to solve the
layers-of-maxima problem arising in the evolutionary computation.
The layers-of-maxima problem asks to partition a set of points of
size n into layers based on their non-dominatedness. A point in d-
dimensional space is said to dominate another point if it is not worse
than the other point in all of the d dimensions.
We also look at the problem of dynamically allocating OVSF
codes to users in an UMTS network. The combinatorial core of the
OVSF code assignment problem is to assign some nodes of a com-
plete binary tree of height h (the code tree) to n simultaneous con-
nections, such that no two assigned nodes (codes) are on the same
root-to-leaf path. A connection that uses 2d of the total bandwidth
requires an arbitrary code at depth d in the tree. This code assignment
is allowed to change over time, but we want to keep the number of
code changes as small as possible. We consider the one-step code as-
signment problem: Given an assignment, move the minimum number
ii
of codes to serve a new request. We show that the problem is N P-

hard. We give an exact nO(h) -time algorithm, and a polynomial time
greedy algorithm that achieves approximation ratio (h). A more
practically relevant version is the online code assignment problem.
Our objective is to minimize the overall number of code reassign-
ments. We present a (h)-competitive online algorithm. We give
a 2-resource augmented online-algorithm that achieves an amortized
constant number of assignments.
The joint base station scheduling problem (JBS) arises in UMTS
networks. Consider a scenario where radio base stations need to send
data to users with wireless devices. Time is discrete and slotted into
synchronous rounds. Transmitting a data item from a base station to a
user takes one round. A user can receive the data item from any of the
base stations. The positions of the base stations and users are mod-
eled as points in Euclidean space. If base station b transmits to user u
in a certain round, no other user within distance b u2 from b can
receive data in the same round due to interference phenomena. Given
the positions of the base stations and of the users the goal is to mini-
mize the number of rounds necessary to serve all users. We consider
this problem on the line (1D-JBS) and in the plane (2D-JBS). For 1D-
JBS, we give an efficient 2-approximation algorithm and polynomial
time optimal algorithms for special cases. We also present an exact
algorithm for the general 1D-JBS problem with exponential running
time. We model transmissions from base stations to users as arrows
(intervals with a distinguished endpoint) and show that their conflict
graphs, which we call arrow graphs, are a subclass of perfect graphs.
For 2D-JBS, we prove N P-hardness and show lower bounds on the
approximation ratio of some natural greedy heuristics.
iii
Zusammenfassung
Auf die eine oder andere Art hat Mobilfunk viele Menschen beein-
flusst. Mobilfunknetzwerke haben es ermoglicht, selbst in den abgele-
gensten Orten erreichbar zu sein. In letzter Zeit wurde viel Forschung
in die Planung und Optimierung von Mobilfunknetzwerken investiert.
Netzwerkanbieter und Nutzer konnen nur davon profitieren, wenn Al-
gorithmiker effiziente Losungen fur Optimierungsprobleme aus die-
sem Umfeld liefern.
In dieser Dissertation analysieren wir drei verschiedene algorith-
misch interessante Probleme der mobilen Telekommunikation: Funk-
mastplatzierung mit Frequenzzuweisung, OVSF Code Zuweisung und
Joint Base Station Scheduling.
Wir prasentieren eine neuartige Losungstechnik fur das Problem,
Funkmasten zu positionieren und ihnen Frequenzen zuzuordnen. Die-
se Fragestellung ist ein Kernproblem beim Design und der Optimie-
rung von GSM Netzwerken. Da die interessanteste Version dieses
Problems N P-hart ist, benutzen wir einen heuristischen Ansatz, der
auf dem evolutionaren Paradigma beruht, um gute Losungen zu fin-
den. Wir untersuchen und vergleichen zwei multikriterielle Techni-
ken und einen neuen Algorithmus, den ,,steady state evolutionaren
Algorithmus mit Pareto Turnieren (stEAPT). Die evolutionaren Al-
gorithmen, die hier benutzt werden, werfen ein interessantes Daten-
strukturen Problem auf. Wir stellen eine auf Prioritatswarteschlangen
basierende Technik vor, die das entstehende ,,Maxima-Schichten Pro-
blem lost. Dieses Problem besteht darin, eine Menge von Punkten der
Groe n so in Schichten aufzuteilen, dass sich keine zwei Punkte in
einer Schicht dominieren. Hierbei dominiert ein Punkt in Rd einen
anderen, wenn er in keiner Dimension schlechter ist als der andere
und in mindestens einer besser.
Weiterhin betrachten wir das Problem, dynamisch OVSF Codes in
einem UMTS Netzwerk zu allozieren. Der kombinatorische Kern des
OVSF Code Zuweisungsproblems besteht darin, Knoten eines voll-
standigen binaren Baums der Hohe h (Codebaum) n gleichzeitigen
Verbindungen zuzuweisen, so dass keine zwei zugewiesenen Codes
auf einem Wurzel-Blatt Pfad sind. Eine Verbindung, die einen Anteil
von 2d der zu Verfugung stehenden Bandbreite benotigt, braucht
einen beliebigen Code der Tiefe d im Baum. Diese Codezuweisung
kann sich mit der Zeit andern. Dabei wollen wir die Anzahl der Code-
iv
Neuzuweisungen moglichst klein halten. Wir betrachten das Ein-

Schritt Codezuweisungsproblem: Gegeben eine Codezuweisung, be-
wege die minimale Anzahl von Codes, um die neue Anfrage zu bedie-
nen. Wir zeigen, dass dieses Problem N P-vollstandig ist. Wir stellen
einen exakten nO(h) Zeit Algorithmus vor und einen polynomiellen
,,Greedy-Algorithmus mit Approximationsrate (h). Eine praktisch
relevantere Variante ist das Online-Codezuweisungsproblem: Mini-
miere die Zahl der Codezuweisungen uber eine (unbekannte) Anfra-
gesequenz. Dafur prasentieren wir einen (h)-kompetitiven Algo-
rithmus. Schlielich stellen wir einen 2-,,Ressourcen-augmentierten
Online Algorithmus vor, der eine amortisiert konstante Anzahl von
Zuweisungen benotigt.
Das Problem des verbundenen Funkmast Scheduling (JBS) ent-
steht in UMTS Netzwerken. Betrachten wir ein Szenario, in dem
Funkmasten Daten an Benutzer mit Mobilgeraten senden. In unserem
Modell betrachten wir die Zeit diskretisiert und synchron in Runden
segmentiert. Die Ubertragung eines Datenpakets vom Funkmasten
zum Benutzer benotigt eine Runde. Ein Benutzer kann ein Daten-
paket von einem beliebigen Funkmasten erhalten. Die Position des
Funkmasten und des Benutzers modellieren wir als Punkte in der eu-
klidischen Ebene. Wenn Funkmast b an Benutzer u in einer bestimm-
ten Runde sendet, kann wegen Interferenz kein Benutzer innerhalb
einer Distanz von b u2 von b in der gleichen Runde Daten emp-
fangen. Fur gegebene Positionen von Funkmasten und Benutzern be-
steht die Aufgabe darin, die Anzahl der Runden zu minimieren, bis
alle Benutzer ihre Daten erhalten haben. Dieses Problem betrachten
wir auf der Geraden (1D-JBS) und in der Ebene (2D-JBS). Fur 1D-
JBS prasentieren wir einen effizienten 2-Approximationsalgorithmus
und Polynomialzeitalgorithmen fur Spezialfalle. Weiterhin stellen wir
einen exakten Algorithmus fur 1D-JBS mit exponentieller Laufzeit
vor. Ubertragungen vom Funkmasten zu den Benutzern werden im
Eindimensionalen als Pfeile dargestellt. Wir zeigen, dass die entste-
henden Konfliktgraphen, die wir ,,arrow graphs nennen, eine Sub-
klasse der Perfekten Graphen sind. Fur 2D-JBS zeigen wir N P-Voll-
standigkeit und untere Schranken fur die Approximierbarkeit einiger
Greedy-Heuristiken.
v
Acknowledgment
No thesis is ever the product of only one persons efforts, and cer-
tainly this one was no exception. It would never have become real-
ity without the help and suggestions of my advisors, colleagues and
friends.
First of all I would like to thank my supervisor prof. Peter Wid-
mayer for his constant guidance, support and for his thoughtful and
creative comments.
I am also very grateful to my co-examiners Dr. Thomas Erlebach
and Dr. Riko Jacob for reading my thesis and for working with me
on some of the challenging algorithmic problems presented in this
piece of work. I would also like to express many thanks to my coau-
thors Matus Mihalak, Marc Nunkesser, Karsten Weicker and Nicole
Weicker for the brainstorming hours and also for the fun we had at
conferences. In this regard, I am also indebted to Michael Gatto for
sharing the office with me for the past two years, for being such a
great colleague, for proof reading my thesis as well as for the discus-
sions on photography and many other topics.
I would also like to take this opportunity to thank many people and
friends with whom I spent time, academically and socially. I thank
Dr. Christoph Stamm for giving me advice on good programming
style and also for being my supervisor during my diploma work. A
special thank you goes to Barbara Heller who always helped me when
I needed advice regarding the academic life at the ETH and life in
Zurich. I am also grateful to my former and current colleagues for
their friendship: Luzi Anderegg, Dr. Mark Cieliebak, Jorg Derungs,
Dr. Stephan Eidenbenz, Dr. Alex Hall, Dr. Tomas Hruz, Zsuzsanna
Liptak, Dr. Sonia P. Mansilla, Dr. Leon Peeters, Dr. Paolo Penna,
Conrad Pomm, Dr. Guido Proietti, Franz Roos, Konrad Schlude, Dr.
David Taylor and Mirjam Wattenhofer. In this respect I would also
like to thank my Hungarian and Romanian friends from the ETH for
organizing the numerous parties and many other social events.
I am also grateful to my parents for their support and encourage-
ment during these five years.
My biggest thank you goes to Veronika Bobkova who always
made me motivated when I was loosing faith in my work and for
supporting me.
vi
Contents
1 Introduction 1
1.1 GSM and UMTS System Planning and Optimization 2
1.2 Short Theory of Algorithms and Complexity . . . . . 5
1.3 Summary of Results . . . . . . . . . . . . . . . . . . 10
2 Base Station Placement with Frequency Assignment 15

2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . 15
2.1.1 Related Work . . . . . . . . . . . . . . . . . 16
2.1.2 Model and Notation . . . . . . . . . . . . . 17
2.1.3 Summary of Results . . . . . . . . . . . . . 20
2.2 Design Criteria and Multiobjective Methods . . . . . 22
2.3 Concrete Realization . . . . . . . . . . . . . . . . . 25
2.3.1 Repair Function . . . . . . . . . . . . . . . . 25
2.3.2 Initialization . . . . . . . . . . . . . . . . . 26
2.3.3 Mutation . . . . . . . . . . . . . . . . . . . 26
2.3.4 Recombination . . . . . . . . . . . . . . . . 28
2.3.5 Selection . . . . . . . . . . . . . . . . . . . 29
2.3.6 Algorithm . . . . . . . . . . . . . . . . . . . 33
2.4 Experiments . . . . . . . . . . . . . . . . . . . . . . 35
2.4.1 Experimental Setup . . . . . . . . . . . . . . 35
2.4.2 Statistical Comparison . . . . . . . . . . . . 36
2.4.3 Parameter Settings . . . . . . . . . . . . . . 37
2.4.4 Multiobjective Methods . . . . . . . . . . . 38
i
ii Contents
2.5 Conclusions and Open Problems . . . . . . . . . . . 39
3 Maxima Peeling in d-Dimensional Space 49

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . 49
3.1.1 Related Work . . . . . . . . . . . . . . . . . 51
3.2 Sweep-Hyperplane Algorithm . . . . . . . . . . . . 54
3.2.1 The Layer-of-Maxima Tree . . . . . . . . . . 54
3.2.2 Space and Running Time Analysis . . . . . . 59
3.3 Divide and Conquer Algorithm . . . . . . . . . . . . 61
3.3.1 Algorithm . . . . . . . . . . . . . . . . . . . 61
3.3.2 Space and Running Time Analysis . . . . . . 65
3.4 Semi-Dynamic Set of Maxima . . . . . . . . . . . . 70
4 OVSF Code Assignment 75

4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . 75
4.1.1 Related Work . . . . . . . . . . . . . . . . . 77
4.2 Properties of OVSF Code Assignment . . . . . . . . 81
4.2.1 Feasibility . . . . . . . . . . . . . . . . . . . 81
4.2.2 Irrelevance of Higher Level Codes . . . . . . 82
4.2.3 Enforcing Arbitrary Configurations . . . . . 83
4.3 One-Step Offline CA . . . . . . . . . . . . . . . . . 86
4.3.1 Non-Optimality of Greedy Algorithms . . . 86
4.3.2 N P-Hardness . . . . . . . . . . . . . . . . 87
O(h)
4.3.3 Exact n Algorithm . . . . . . . . . . . 90
4.3.4 h-Approximation Algorithm . . . . . . . . . 92
4.4 Online CA . . . . . . . . . . . . . . . . . . . . . . . 98
4.4.1 Compact Representation Algorithm . . . . . 99
4.4.2 Greedy Online Strategies . . . . . . . . . . . 101
Contents iii
4.4.3 Minimizing the Number of Blocked Codes . 102

4.4.4 Resource Augmented Online Algorithm . . . 106
4.5 Discussions and Open Problems . . . . . . . . . . . 108
5 Joint Base Station Scheduling 109

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . 109
5.1.1 Related Work . . . . . . . . . . . . . . . . . 110
5.2 1D-JBS . . . . . . . . . . . . . . . . . . . . . . . . 116
5.2.1 Relation to Other Graph Classes . . . . . . . 116
5.2.2 1D-JBS with Evenly Spaced Base Stations . 118
5.2.3 3k Users, 3 Base Stations in k Rounds . . . . 121
5.2.4 Exact Algorithm for the k-Decision Problem 122
5.2.5 Approximation Algorithm . . . . . . . . . . 125
5.2.6 Different Interference Models . . . . . . . . 128
5.3 2D-JBS . . . . . . . . . . . . . . . . . . . . . . . . 130
5.3.1 N P-Completeness of the k-2D-JBS Problem 130
5.3.2 Base Station Assignment for One Round . . 141
5.3.3 Approximation Algorithms . . . . . . . . . . 143
iv Contents
Chapter 1
Introduction
In one way or another mobile phones have changed everyones life.

We can say that nowadays more than half of the population has a
mobile phone or at least has used a mobile phone. Mobile communi-
cation networks made it possible to be connected and reachable even
in the most remote places. One might question whether this is good
or bad. The truth is mobile phones can nowadays save lives but the
electro-smog can also endanger life if not kept below the allowed
limits. Since predictions show that in future most of the communica-
tion will be in the mobile domain (maybe even the internet), it makes
sense to optimize mobile networks for the most efficient utilization of
the frequency spectrum and for minimizing smog.
Both the telecommunication network providers and the users can
only gain in efficiency and usability if we theoreticians provide them
with the most efficient algorithmic solutions to all interesting prob-
lems raised by these networks. While there exist a number of re-
sults on several aspects of telecommunication network planning and
management, very little is known about models that use a holistic ap-
proach trying to take all aspects into account at the same time. Most
theoretical problems in telecommunications turn out to be N P-hard,
which makes the existence of efficient polynomial-time algorithms
that find optimum solutions highly unlikely. The notion of approxi-
mation algorithms was introduced for such situations. Approximation
algorithms are algorithms that run in polynomial time and find solu-
tions that are guaranteed to be at most a certain factor (i.e., a constant
1
2 Chapter 1. Introduction
or a function of the input size) off the optimum solution. This con-
trasts with the concept of a heuristic, where no such guarantee can
be given, but good solutions are found for most instances arriving in
practice. In practice, heuristics often outperform provablyworst-
case optimum approximation algorithms.
From a practical point of view, mobile phones affect all of us.
New mobile phone networks are being designed for each new tech-
nology generation. Each generation poses a different set of problems.
When designing new networks, algorithmically challenging and com-
putationally intensive problems without existing theoretical models
have to be solved. In this thesis we elaborate on three of these chal-
lenging problems: coverage and frequency allocation (in Chapter 2),
spreading code allocation (in Chapter 4), and load balancing with cell
synchronization (in Chapter 5). In addition we analyze a data struc-
ture problem (in Chapter 3) that improves the runtime efficiency of a
class of evolutionary multi-objective optimization strategies.
First, we present shortly some aspects of the design and optimiza-
tion problems raised by 2nd and 3rd generation mobile telecommu-
nication networks. For a technical description on the existing and
future generation mobile networks, the interested reader is referred
to [76, 46] and [60]. Next, we present briefly the algorithmic tools
and theory used for solving and analyzing the problems tackled in
this thesis. At the end of this chapter we present our main results
and in the following chapters we present in detail each of the above
mentioned problems.
1.1 GSM and UMTS System Planning and

Optimization
Global System for Mobile communication (GSM) is the current most
widely spread digital cellular mobile communication standard. Its ra-
dio interface is based on Frequency Division Multiple Access (FDMA).
It offers a broad range of telephony, messaging and data services to
the mass market, and enables roaming internationally between net-
works belonging to different operators.
GSM networks are large scale engineering objects consisting of
numerous technical entities and requiring high financial investments.
They certainly benefit from a systematic design approach using pre-
1.1. GSM and UMTS System Planning and Optimization 3
cisely stated network design objectives and requirements. There ex-

ists a large number of technical, economical and social objectives.
These design objectives and requirements are often contradictory to
each other.
Beside the primary Radio Frequency (RF) objective of providing
a reliable radio link at every location in the planning region, state-of-
the-art network design has to ensure a high quality-of-service (degree
of satisfaction of a user of a service), while considering the aspects of
cutting the cost of engineering and deploying a radio network. The
design objectives can be separated in three groups.
Base Station Transmitter (BST) location problem. The RF de-

sign objectives are usually expressed in terms of radio link
quality measures. Among other RF design objectives a good
link design has to ensure a sufficient radio signal level through-
out the planning region and minimized signal distortion by chan-
nel interferences.
Frequency Channel Assignment (FCA) problem. Since the avail-

able frequencies (channels) are extremely limited, the network
design has to take into account predictions on the teletraffic1
and therefore the number of channels required in a cell as pre-
cisely as possible. To increase the total system capacity, the
design has to enforce a large frequency reuse factor.
Network deployment objectives. The network deployment ob-

jectives mainly address the economic aspects of engineering
and operating a radio network. Deploying a new network or
installing additional hardware has significant costs. Therefore,
an efficient network design has to minimize hardware costs as
well as adverse effects on the public, such as radio smog.
The conventional design procedure for cellular systems is based

on the analytical design approach. This approach is mainly focused
on the determination of the transmitter parameters, like position, an-
tenna type, or transmitting power. It obeys the described RF objec-
tives, but neglects the capacity and the network deployment objectives
during the engineering process. This analytical approach is the base
of most of todays commercial cellular network planning tools. The
1 Statistical estimation of user requests for a certain service area [79].
analytical approach consists of four phases: radio network definition,

propagation analysis, frequency allocation, and radio network analy-
sis. These four phases are iteratively processed in several turns until
the specified design objectives and requirements are met.
In Chapter 2 we pursue a holistic approach that combines the ob-
jectives of base station location (BST), frequency channel assignment
(FCA) and network deployment. The currently popular approach of
sequentially solving the BST, FCA and network deployment problem
does not exploit interdependencies among the problems. We there-
fore believe that an integrated approach leads to better results. Such a
holistic approach is feasible because of the increasing power of com-
puters: while the computational task of finding solutions for only one
of the three problems seemed non-negotiable only a few years ago,
attacking all three problems simultaneously is possible today. An in-
tegrated, holistic approach is highly complex as the objectives of the
subproblems are contradictory. For example: in regions with high de-
mand, we cannot achieve good coverage without having interference,
which in turn leads to poor frequency reuse.
GSM systems belong to the 2nd generation (2G) and 2 12 G mo-
bile networks. The mobile telecommunication industry throughout
the world is currently switching its focus to 3G Universal Mobile
Telecommunications System (UMTS) technology. The goal of UMTS
is to deliver multimedia services to users in the mobile domain. The
new multimedia services and the new Wide-band Code Division Mul-
tiple Access (WCDMA) radio interface of UMTS have a significant
impact on the design and network optimization aspects of these net-
works.
The major differences, compared to GSM, in the UMTS radio sys-
tem planning process occur in coverage and capacity planning. While
the cells in the GSM networks were statically defined with the BST
location and power allocation, the cell size in the UMTS systems is
changing in a dynamic fashion (with online power adjustment) de-
pending on the online service requests. In the Chapters 4 and 5 we
look at some aspects of the coverage and capacity planning phase and
the code and frequency planning phase of UMTS networks.
The most valuable resource in a mobile network is the bandwidth
available to the users. In WCDMA radio access networks this band-
width is shared by all users inside one cell and is allocated on demand
depending on the type of services requested by the user. The user sep-
1.2. Short Theory of Algorithms and Complexity 5
aration inside one cell is achieved by assigning orthogonal spreading

(channelization) codes to the users. These codes are assigned from
an Orthogonal Variable Spreading Factor (OVSF) code tree and are
dynamically maintained by the BSTs of the cells. As user requests
arrive and depart, the code tree gets fragmented and code reshuffling
(reassignment) becomes necessary. We analyze this algorithmically
interesting problem in Chapter 4.
In UMTS systems two radio access technologies are used together
with the CDMA channel separation technology. The Time Division
Duplex (TDD) technology is considered mainly as a capacity booster
for areas where high bandwidth data requests are dominant while the
Frequency Division Duplex (FDD) technology can be used for low
bandwidth continuous communication. TDD is suited to offer ser-
vices with very high bit rates and hence is used as a separate capacity-
enhancing layer in the network. The limiting factor in the TDD net-
work is the intercell interference. A so called fast dynamic channel al-
location strategy tries to find the best combination of time slots (when
the user is served) for each user in each cell. This leads to another
algorithmically interesting problem. We call this problem the Joint
Base Station scheduling problem and we analyze different versions
of it in Chapter 5.
In this thesis, we analyze and provide solution approaches to some
of the algorithmic questions raised by the optimization problems men-
tioned above by using complexity theory, heuristics, approximation
and online algorithms. Some of the algorithmic questions remain
open and some of the approaches leave space for further improve-
ment. In the next section, we give a short overview of these theoreti-
cal techniques and categories of algorithms.
1.2 Short Theory of Algorithms and Com-

plexity
In this section we take a short tour of the theory of algorithms and
their complexity classes. The terms and techniques presented here
are used in later chapters to analyze and solve the problems.
First we introduce two types of problems that we are concerned
with in this thesis: decision and optimization problems. We recall
these definitions as presented in [7].
Definition 1.1 A problem D is called a decision problem if the set

I of all instances of D is partitioned into a set of positive (yes)
instances and a set of negative instances (no) and the problem asks,
for any instance x I, to verify whether x is a positive instance.
From a practical point of view, optimization problems are more im-

portant than decision problems since most real life applications ask
for a cost function to be either minimized or maximized.
Definition 1.2 An optimization problem is characterized by a quad-

ruple (I, S, m, g), where:
I is the set of instances of ;
S is a function that associates to any input instance x I the

set of feasible solutions of x;
m is the measure (objective) function, defined for pairs (x, y)

s.t. x I and y S(x). The measure function returns a
positive integer which is the value of the feasible solution y;
g {M IN, M AX} specifies whether is a minimization or

a maximization problem.
Notions from Complexity Theory

An important aspect of decision and optimization problems is their
computational complexity. Computational complexity is aimed at
measuring how difficult is to solve a computational problem as a func-
tion of the input instance size. The most widely used measures of
complexity are the time it takes to produce a solution and the amount
of memory needed.
The conventional notions of time and space complexity are based
on the implementation of algorithms on abstract machines, called ma-
chine models. In complexity theory the multitape Turing machine
model is used most often. A more realistic computational model is
the random access machine (RAM). Another well known model of
computation is the storage modification machine (SMM) model also
known as the pointer machine. A definition of these computational
models can be found in [82].
In this thesis we are interested in the complexity classes P and

N P. The class P contains the set of decision problems solvable by a
deterministic Touring machine in time polynomially bounded on the
input size. On the other hand the class N P contains decision prob-
lems which can be solved in polynomial time by a nondeterministic
Touring machine. This is equivalent to the class of decision problems
whose constructive solutions can be verified in time polynomial in
the input size. As long as we stay in the realm of polynomially solv-
able problems, the machine model of choice is not relevant. Instead
of the Turing machine the log-cost RAM model (where as storage
and operation cost the number of bits required to encode the num-
bers involved) could be used equivalently. For further information
on complexity classes the interested reader is referred to the textbook
[67].
A fundamental problem in theoretical computer science is whether

P=? N P. It is easy to see that PN P since a deterministic Turing
machine is a special case of a non-deterministic Turing machine. It
is widely believed that the two complexity classes are different. As-
suming that P=N P, there can be considerable practical significance
in identifying a problem as ,,complete for N P under an appropri-
ate notion of reducibility. If the reducibility considered is of Karp
type [57] then such problems will be polynomial time solvable if and
only if P=N P. Since reducibility is transitive, it orders the problems
in N P with respect to their difficulty.
Definition 1.3 Let N P, we say that is N P-complete if any

problem N P can be reduced in polynomial time to .
Cook [20] and Levin [61] proved that the satisfiability problem
is N P-complete. To show N P-completeness of a new problem it
is enough to show that it is in N P and to find a polynomial time
reduction from one of the problems already known as being N P-
complete. Because of the transitive property of Karp type reductions,
the existence of a polynomial time algorithm for one of the N P-
complete problems would imply polynomial time algorithms for all
problems in N P.
Approximation Algorithms
In the previous section we presented the complexity class N P and
the concept of N P-completeness. In real life applications it turns out
that most interesting problems are N P-complete. In such cases, one
cannot expect polynomial time optimal algorithms unless P=N P.
The widely believed assumption in complexity theory is that P=N P
and thus there is little hope for someone to prove the contrary. Hence,
it is worth looking for algorithms that run in polynomial time and
return, for every input, a feasible solution whose measure is not too
far from the optimum.
Given an input instance x for an optimization problem , we say
that a feasible solution y S(x) is an approximate solution of prob-
lem and that any polynomial time algorithm that returns a feasible
solution is an approximation algorithm.
The quality of an approximate solution can be defined in terms
of the distanceof its measure from the optimum. In this thesis we
use only relative performance measures. The following definition is
from [7]. There are other definitions on the performance ratio that use
values smaller than one for minimization problems. The two defini-
tions are basically the same and for ease of presentation we use the
definition from [7].
Definition 1.4 Given an optimization problem and an approxima-

tion algorithm A for , we say that A is an r-approximate algorithm
for if, given any input instance x of , the performance ratio of the
approximate solution A(x) is bounded by r, that is:

m(x, A(x)) m (x)
R(x, A(x)) = max , r,
m (x) m(x, A(x))
where m (x) is the measure of an optimum solution for the problem
instance x.
In this thesis we provide approximation algorithms with guaran-

teed performance ratios for most of our N P-complete optimization
problems (see Chapters 4 and 5). A vast literature has been written
about designing good approximation algorithms and analyzing prob-
lems based on their approximability. It is out of the scope of this the-
sis to give an extensive overview of this theory, the interested reader
is referred to [7] and [84].
Heuristics
In the previous section we presented the notion of approximation al-
gorithms that provide good quality solutions (in terms of running time
and solution measure) to N P-complete problems. However, in prac-
tice most applications use algorithms that do not provide such guaran-
tees and still produce good enough solutions in a short time for most
input instances.
In the following, we refer to algorithms that do not provide any
worst case (or average case) guarantees on their execution time nor on
their solution quality as heuristic methods (or heuristics). In practice,
heuristics often outperform provably worst-case optimum approxi-
mation algorithms.
Evolutionary algorithms are one of the state of the art heuris-
tic methods that can handle efficiently multi-objective optimization
problems. In Chapter 2 we present an evolutionary algorithm tailored
to a specific multi-objective optimization problem. Other local search
type heuristics are the following: simulated annealing, tabu search,
neural networks, and ant colony optimization. A brief description of
these methods can be found in [7] and [27].
Online Computation
Traditional optimization techniques assume complete knowledge of
all data of a problem instance. However, in reality decisions may
have to be made before the complete information is available. This
observation has motivated the research on online optimization. An
algorithm is called online if it takes decisions whenever a new piece
of data requests an action. The input is given as a request sequence
r1 , r2 , . . . presented one-by-one. The requests must be served by an
online algorithm ALG at the time they are presented. When serving
request ri , the algorithm ALG has no knowledge about the requests
rj , j > i. Serving ri incurs a cost and the overall goal is to minimize
the total service cost of the request sequence.
We can formally define online optimization problems as a request-
answer game, in the following way.
Definition 1.5 A request-answer game is defined by (R, A, C), where

R is the request sequence, A = A1 , A2 , . . . is a sequence of nonempty
answer sets and C = c1 , c2 , . . . is a sequence of cost functions with

ci : Ri A1 A2 . . . Ai R+ {+} (here Ri is the request
sequence up to the request ri ).
In this thesis we are interested only in deterministic online algorithms

that are defined as follows.
Definition 1.6 A deterministic online algorithm ALG for the request-

answer game (R, A, C) is a sequence of functions fi : Ri Ai ,
i N. The output of ALG for the input request sequence =
r1 , r2 , . . . , rm is
ALG[] := (a1 , a2 , . . . , am ) A1 . . . Am ,
where ai := fi (r1 , . . . , ri ). The cost incurred by ALG on , denoted
by ALG() is defined as
ALG() := cm (, ALG[]).
An optimal offline algorithm is an algorithm that has all the knowl-

edge about the sequence of requests that have to be processed in
advance and chooses the action that minimizes the total cost. The
performance of online algorithms is expressed by their competitive-
ness versus an optimal offline algorithm. Suppose that we are given a
request-answer game, we define the optimal offline cost on a sequence
Rm as follows:
OP T () := min{cm (, a) : a A1 . . . Am }.
Definition 1.7 Let c 1 be a real number. A deterministic online

algorithm ALG is called c-competitive if for any request sequence
ALG() cOP T (). The competitive ratio of ALG is the infimum
over all c such that ALG is c-competitive.
One important observation is that we impose no restriction on the

computational resources of an online algorithm. The only scarce re-
source in competitive analysis is information.
1.3 Summary of Results

In this thesis we analyze four different algorithmically interesting
problems: the BST location with frequency assignment problem (Chap-
1.3. Summary of Results 11
ter 2); maintaining the layers of maxima in d-dimensional space (Chap-

ter 3); the OVSF code assignment problem (Chapter 4); and the joint
base station scheduling problem (Chapter 5). As usually happens in
the computer science community, more than one scientist work in
collaboration to solve interesting research problems. Some of the re-
sults presented are joint work with: Thomas Erlebach, Riko Jacob,
Matus Mihalak, Marc Nunkesser, Nicole Weicker, Karsten Weicker,
and Peter Widmayer.
In Chapter 2 we propose a new solution to the problem of posi-

tioning base station transmitters of a mobile phone network and as-
signing frequencies to the transmitters, both in an optimal way. This
problem stands at the core of GSM network design and optimization.
Since an exact solution cannot be expected to run in polynomial time
for most interesting versions of this problem (they are all N P-hard),
our algorithm follows a heuristic approach based on the evolution-
ary paradigm. For this evolution to be efficient, that is, at the same
time goal-oriented and sufficiently random, problem specific knowl-
edge is embedded in the operators. The problem requires both the
minimization of the cost and of the channel interference. We exam-
ine and compare two standard multiobjective techniques and a new
algorithm, the steady state evolutionary algorithm with Pareto tourna-
ments (stEAPT). The empirical investigation leads to the observation
that the choice of the multiobjective selection method has a strong
influence on the quality of the solution.
The evolutionary algorithm used in Chapter 2 raised an interesting

data structure problem. In Chapter 3 we present a fast priority queue
based technique to solve the layers-of-maxima problem. The layers-
of-maxima problem asks to partition a set of points of size n into
layers based on their non-dominatedness. A point in d-dimensional
space is said to dominate another point if it is not worse than the
other point in all of the d dimensions. We present two different al-
gorithmic paradigms that solve the problem and have the same run-
ning time of O(n logd2 (n) log log(n)). This result is an improve-
ment over the best known algorithm from [51] that has running time
O(n logd1 (n)). In Section 3.2, we present a d-dimensional sweep
algorithm that uses a multilevel balanced search tree together with
a van Emde Boas priority queue [81]. In Section 3.2.2, we show
that the running time of this algorithm is O(n logd2 (n) log log(n))
and the storage overhead is also O(n logd2 (n) log log(n)). In Sec-
tion 3.3 we present a divide-and-conquer approach similar to the one

used in [51] with an improved base case for the two-dimensional
space. The analysis from Section 3.3.2 shows that the running time
is the same as for the sweep algorithm and that the space overhead
is just O(d n). We also present an easy to implement data structure
for the semi-dynamic set of maxima problem in Section 3.4 that has
update time O(logd1 (n)).
The natural next step after analyzing GSM network optimization

problems was to look at interesting optimization problems from the
3G mobile telecommunication networks. In Chapter 4 we present the
problem of dynamically allocating OVSF codes to users in an UMTS
network. Orthogonal Variable Spreading Factor (OVSF) codes are
used in UMTS to share the radio spectrum among several connec-
tions of possibly different bandwidth. The combinatorial core of the
OVSF code assignment problem is to assign some nodes of a com-
plete binary tree of height h (the code tree) to n simultaneous con-
nections, such that no two assigned nodes (codes) are on the same
root-to-leaf path. A connection that uses 2d of the total bandwidth
requires some code at depth d in the tree. This code assignment is al-
lowed to change over time, but we want to keep the number of code-
changes as small as possible. Requests for connections that would
exceed the total available bandwidth are rejected. We consider the
one-step code assignment problem: Given an assignment, move the
minimum number of codes to serve a new request. Minn and Siu in
[64] present the so-called DCA-algorithm and claim to solve the prob-
lem optimally. In contrast, we show that DCA does not always return
an optimal solution, and that the problem is N P-hard. We give an
exact nO(h) -time algorithm, and a polynomial time greedy algorithm
that achieves approximation ratio (h). A more practically relevant
version is the online code assignment problem, where future requests
are not known in advance. Our objective is to minimize the overall
number of code reassignments. We present a (h)-competitive on-
line algorithm, and show that no deterministic online-algorithm can
achieve a competitive ratio better than 1.5. We show that the greedy
strategy (minimizing the number of reassignments in every step) is
not better than (h) competitive. We give a 2-resource augmented
online-algorithm that achieves an amortized constant number of reas-
signments.
Another interesting optimization problem that arises in UMTS

1.3. Summary of Results 13
networks that use the TDD radio interface together with the CDMA
channel separation technology is the joint base station scheduling
(JBS) problem. In Chapter 5 we present different versions of the JBS
problem. Consider a scenario where radio base stations need to send
data to users with wireless devices. Time is discrete and slotted into
synchronous rounds. Transmitting a data item from a base station to a
user takes one round. A user can receive the data from any of the base
stations. The positions of the base stations and users are modeled as
points in Euclidean space. If the base station b transmits to user u in
a certain round, no other user within distance at most b u2 from
b can receive data in the same round due to interference phenomena.
The goal is to minimize, given the positions of the base stations and of
the users, the number of rounds until all users have received their data.
We call this problem the Joint Base Station Scheduling Problem (JBS)
and consider it on the line (1D-JBS) and in the plane (2D-JBS). For
1D-JBS, we give an efficient 2-approximation algorithm and poly-
nomial time optimal algorithms for special cases. We also present
an exact algorithm for the general 1D-JBS problem with exponential
running time. We model transmissions from base stations to users as
arrows (intervals with a distinguished endpoint) and show that their
conflict graphs, which we call arrow graphs, are a subclass of perfect
graphs. For 2D-JBS, we prove N P-hardness and show that some nat-
ural greedy heuristics do not achieve approximation ratio better than
O(log n), where n is the number of users.
Chapter 2
Base Station Placement

with Frequency
Assignment
2.1 Introduction
The engineering and architecture of large cellular networks is a highly
complicated task with substantial impact on the quality-of-service
perceived by users, the cost incurred by the network providers, and
environmental effects such as radio smog. Because so many different
aspects are involved, the respective optimization problems are proper
objects for multiobjective optimization and may serve as real-world
benchmarks for multiobjective problem solvers.
For all cellular network systems one major design step is selecting
the locations for the base station transmitters [BST Location (BST-L)
problem] and setting up optimal configurations such that coverage of
the desired area with strong enough radio signals is high and deploy-
ment costs are low.
For Frequency Division/Time Division Multiple Access systems
a second design step is to allocate frequency channels to the cells.
For Global System for Mobile communications systems, a fixed fre-
quency spectrum is available. This spectrum is divided into a fixed
15
16 Chapter 2. BST Placement with Frequency Assignment
number of channels. For a good quality of service, network providers

should allocate enough channels to each cell to satisfy all simultane-
ous demands (calls). The channels should be assigned to the cells in
such a way that interference with channels of neighbor cells or in-
side the same cell is low. In the literature, this problem is called the
fixed-spectrum frequency channel assignment problem (FS-FAP).
2.1.1 Related Work

The BST-L and the FAP problem are known to be NP-hard: the min-
imum set cover problem can be reduced in polynomial time to the
BST-L problem, and the FAP problem contains the vertex coloring
problem as a special case. For both problems, BST-L and FAP, several
heuristic based approaches have been presented [3, 4, 8, 9, 35, 36, 43,
50]. For the BST-L problem with signal interferences, one interesting
practical approach was presented in [80]. The most recent result is by
Galota et al. [41], showing a polynomial time approximation scheme
for one version of the BST-L problem. Also, for a weighted coloring
version of the FAP, an optimization algorithm was presented recently
[91] that works for the special case of series-parallel graphs.
Two separate optimization steps, BST-L followed by FAP, must
be viewed criticallya solution of BST-L restricts the space of pos-
sible overall solutions considerably and might delimit the outcome
of the FAP optimization. Usually, an iterated two-phase procedure is
chosen to approach a sufficiently good solution. However, it is diffi-
cult to feed back the results of the second phase into an optimization
of the first phase again. In this chapter we show that with todays
increased availability of computing power it has become practically
feasible to address the cellular network design problems (BST-L and
FS-FAP) with an integrated approach that considers the whole prob-
lem in a single optimization phase. Since the two separate optimiza-
tion steps influence each other for practical problem instances, we
expect better overall results when they are integrated into a single de-
sign step, although the search space is enlarged drastically. To our
knowledge, there were very few papers that addressed the integrated
problem (e.g. [52]), and none of them pursues an evolutionary ap-
proach. We are interested in exploring the potential that evolutionary
algorithms have to offer.
For successfully coping with the enlarged search space, two de-
2.1. Introduction 17
sign issues are of major importance concerning the evolutionary al-

gorithm. First, the general concept of evolutionary computation must
be tailored to match the abundance of constraints and objectives of
the integrated problem for cellular network design in its full practical
complexity. Second, the multiobjective character of the problem must
be reflected in the selection strategy of the algorithm such that a sensi-
ble variety of solutions is offered, reflecting the tradeoff between cost
and channel interferences. Our experimental results demonstrate that
even though we cannot guarantee bounds on the worst-case behavior,
our evolutionary approach can handle real problem instances.
2.1.2 Model and Notation

For our problem we use a real teletraffic matrix for the region of
Zurich. The teletraffic matrix is computed using statistical data about
population, buildings and land type [79]. From now on, we refer to
the teletraffic in a certain unit area as demand. A demand node in our
model has a fixed location and carries a certain number of calls per
time unit. This number can vary across demand nodes. We consider
a service area in which a set of demand nodes with different locations
and numbers of calls are given. The task is to place transmitters in
the service area in such a way that all calls of the demand nodes can
be served with as little interference as possible. The transmitters may
be given different power (signal strength) and capacity (number of
channels). The power of a transmitter, together with a wave propaga-
tion function, determines the cell in which the transmitter can serve
calls. The capacity of a transmitter is the number of different fre-
quency channels on which the transmitter can work simultaneously.
Electromagnetic interference may be a problem in an area where two
signals with the same frequency or with very similar frequencies are
present. As the cells of the transmitters can overlap, interference can
occur between different transmitters and within one transmitters cell.
To summarize the problem, we want to determine locations of
transmitters, and assign powers and frequencies to them such that all
calls can be served. We aim at minimizing two objectives:
the cost for the transmitters
the interference.
We define formally the parameters of the problem as follows.

We are given a service area A = ((xmin , ymin ), (xmax , ymax ), res),
where (xmin , ymin ) is the lower left corner of a terrain, given in some
standard geographical coordinate system, (xmax , ymax ) is the upper
right corner of the terrain, and res N is the resolution of the ter-
rain. We limit ourselves to grid points, for all purposes. That is, a
point (x, y) is said to be in A ,(x, y) A, if x = xmin + i res
xmin
and y = ymin + j res for some integers 0 i
xmaxres and
ymax ymin
0j
res .
With D = {d1 , . . . , dn } we denote the finite set of demand nodes,
given by their position inside the service area A and the number of
calls they carry, i.e., di = (pos i , ri ), where pos i A is the position
of demand node di and ri N is the number of calls at di , 1 i n.
F = {f1 , . . . , fL }, L N is a fixed size frequency spectrum, where
fi is a frequency channel that can be used for communication. Each
of the channels has a unique label from an ordered set (i.e. fi < fj or
fj < fi for i = j and i, j {1, . . . , L}).
By T we denote a finite set of possible transmitter configura-
tions, where t = (pow , cap, pos, F ) T has transmitting power
pow [MinPow , MaxPow ] N, the capacity of the transmit-
ter is cap [0, MaxCap] N, the position of the transmitter is
pos A, and the set of channels assigned to the transmitter is F F
(|F | cap).
We model the wave propagation function wp : T P(A) as a
function of the power and the position of a transmitter. This function
defines for every transmitter its cell A. In the simple, planar grid
interpretation of the service area, the cell is a circle, discretized to the
grid, where the position of the transmitter t is the center of the cell t
and the power determines the radius. Inside the cell, the signal of the
transmitter is strong enough for communication. We consider a step-
like signal fading for which outside the cell the signal is not strong
enough to produce interference with signals of other transmitters.
A demand node d D is covered if all its calls can be served.
A call from d is satisfied if there is at least one selected transmitter
t = (pow , cap, pos, F ) that has a sufficiently strong signal at d (i.e.
d cell t ) and has a channel f F assigned for this call. In this case
the transmitter t is considered a server for d. More than one selected
transmitter can serve the same demand node, but not the same call.
We consider two types of channel interference:
The co-channel interference occurs between neighboring cells

that use a common frequency channel. In contrast to the for-
mula given in [79] we use a discrete interference model for
the computation of co-channel interference. For each selected
transmitter we count the noisy channels. A channel allocated to
a transmitter t is said to be noisy if it has an overlapping region
with another transmitter using the same channel, and in their
overlapping region there is at least one demand node satisfied
by the transmitter t. NC CC (t) is the set of all noisy channels
for a selected transmitter t with respect to co-channel interfer-
ence. We consider this model for the co-channel interference
because it captures the worst case scenario in real situations:
two customers of overlapping cells (at least one of them in the
overlapping region) make their calls and because both get as-
signed the same frequency channel, by their server transmitters,
they hear only noise.
The adjacent-channel interference appears inside one or be-

tween neighboring cells using channels close to each other on
the frequency spectrum. Like most other relevant literature,
we consider adjacent-channel interference only inside the same
cell between adjacent channels. To avoid this type of inter-
ference, usually a frequency gap gAC N is specified that
must hold between assigned frequency channels. For a selected
transmitter t T the frequency channel with minimum label
from a pair (fi , fj ) is considered noisy with respect to adjacent-
channel interference, if fi , fj F, i = j, |fi fj | < gAC .
NC AC (t) is the set of all noisy channels for a selected trans-
mitter t from an adjacent-channel interference point of view.
Figure 2.1.1 gives a simple example for interference, where for trans-
mitter A channels 2, 4 are noisy from a co-channel interference point
of view since B uses the same channels and A serves demands in the
overlapping region. With a frequency gap gAC = 2, the channel 1
is noisy from an adjacent-channel interference point of view because
the channel 2 is also present at transmitter A and hence it violates the
frequency gap.
The set of all candidate solutions S is defined as

S = {t1 , . . . , tm } m N ti T, i {1, . . . , m} .
{1, 2, 4} A C {1, 3, 5}
{2, 4, 6}
Figure 2.1.1: Example for co-channel and adjacent-channel interfer-

ence.
The set of all feasible solutions FS with respect to a set of demand

nodes D is defined as

FS = S S di D, di covered by S .
The cost of a feasible solution S FS is the sum of the costs of its

|S|
transmitters, cost(S) = i=1 cost(ti ). The cost of one transmitter
ti = (pow i , cap i , pos i , Fi ) is a function cost : T R+ of the
power and the capacity of the transmitter that is monotonous in both
parameters: cost(ti ) = fc (pow i , cap i ). The interference ratio of a
feasible solution is
|S|
|NC (ti )|
IR(S) = i=1 n ,
i=1 ri
n
where NC (ti ) = NC CC (ti ) NC AC (ti ) and i=1 ri is the total
number of call requests.
The goal of the optimization is to find a feasible solution S FS
s.t. cost(S) and IR(S) are as small as possible.
2.1.3 Summary of Results

In Section 2.2 we outline the design criteria used to incorporate prob-
lem knowledge into the evolutionary algorithm as well as the options
to handle multiple objectives. The concrete realization of our evo-

lutionary algorithm, tailored to the problem, follows in Section 2.3.
We show the main experimental results in Section 2.4 together with
a statistical analysis and finally conclude in Section 2.5. The results
presented in this chapter are joint work with Nicole Weicker, Karsten
Weicker and Peter Widmayer and have been published earlier in [86].
2.2 Design Criteria

and Multiobjective Methods
Evolutionary algorithms (EAs) are a broad class of different random-
ized search heuristics based on the idea of natural evolution. Best-
known examples are genetic algorithms (GAs), evolution strategies,
and evolutionary programming.
Let us briefly recall the general idea of evolutionary algorithms.
The points representing the possible candidate solutions define the
solution space for a problem. For each point, an evaluation function
or objective function gives an assessment of its quality in solving the
problem. Usually the assessment is given by a real-valued number
so that all points can be compared to each other according to their
assessment.
The usual procedure in running an evolutionary algorithm is to
initialize a population with some randomly chosen points of the solu-
tion space. Those individuals are evaluated using the objective func-
tion. Then points are selected for the recombination, serving as par-
ents to produce offspring. The offspring are mutated with a certain
probability, and from those offspring and perhaps the parents a new
population is formed using an environmental selection strategy. This
procedure is repeated until one of the stopping criteria is met: for in-
stance, the number of generations reaches a specified maximum, or
the best individual in the current generation is better than a certain
threshold, or the user stops the execution. The general scheme of an
evolutionary algorithm is given in Figure 2.2.1.
The necessity to tailor an evolutionary algorithm to a specific
problem is not only a conclusion of the No Free Lunch Theorems
of Wolpert and Macready [88] but has also been applied many times
by practitioners (see e.g. [22]). However, few general guidelines are
available for designing an algorithm. In case of the base station trans-
mitter placement with frequency assignment, the following design
criteria have been regarded through the whole process of incorpo-
rating domain knowledge.
1. It has to be guaranteed that the representation is able to express
all candidate solutions.
2. Since the problem includes certain constraints, it has to be guar-
anteed that any individual that can be produced by the genetic
2.2. Design Criteria and Multiobjective Methods 23
Initialization
End / Output Evaluation
Termination Parent
criteria selection
Environmental
selection Recombination
Evaluation Mutation
Figure 2.2.1: General evolutionary algorithm scheme.
operators presents a feasible candidate solution, or, if this can-

not be guaranteed, can be repaired to a feasible one.
3. Every point in the solution space should be reachable by the

evolutionary operators at any step of the evolutionary algo-
rithm. Each operator must possess its reverse.
4. The evolutionary operators have to be chosen in such a way that

a balance between exploration and exploitation of the search
space can be reached. This means that there is a need not only
for problem specific operators guaranteeing only little changes
to an individual, but also for randomly driven operators able to
explore new areas of the search space.
One of the difficulties of the problem described in Section 2.1.2

lies in the combination of three aims: we want to cover all demand
nodes, with minimal costs for the needed transmitters and also min-
imal interference. The first aim is a constraint and, thus, we decided
to use a genetic repair approach [90], i.e. in all candidate solutions
all demand nodes must be coveredthis is enforced using a repair
function (see Section 2.3.1).
When defining genetic operators, the need for the repair function
should be as small as possible to have a high correlation between par-
ents and offspring. Moreover, we want to reach a good combination
of directed search operators (resulting in an exploitation) and those
which work more randomly (bringing the necessary exploration com-

ponent). Also we want to use the power of recombination operators
that combine different solutions in a meaningful way. The operators
are presented in Sections 2.3.3 and 2.3.4.
For the handling of the two minimization objectives a vast vari-
ety of multiobjective methods is available. All those algorithms are
used to produce potentially optimal candidate solutions as elements
of the Pareto front. At any stage of the evolution, the Pareto front
is the set of current candidate solutions that are non-dominated by
other current candidate solutions, i.e. currently there is no other feasi-
ble solution available that will yield an improvement in one objective
without causing a degradation in at least one other objective (as in-
troduced by Pareto [68]). An early approach was the vector evaluated
genetic algorithm (VEGA) [72] that often produces solutions distinct
from the Pareto set or even favors rather extreme candidate solutions.
Another rather intuitive method is the use of aggregating functions
like in a weighted sum [77]. However, the projection of multiple ob-
jective values to one scalar value handicaps concave regions of the
Pareto front during search [69]. In the 1990s, research concentrated
primarily on methods using the Pareto dominance directly. Exam-
ples are the Niched-Pareto Genetic Algorithm (NPGA) [48], the Non-
dominated Sorting Genetic Algorithm (NSGA) [75], and the Multi-
Objective Genetic Algorithm (MOGA) [37]. The price for the success
of these techniques is high complexity since they all spread the solu-
tions across the Pareto front and check for Pareto dominance. These
algorithms also lack a technique for elitism. Therefore, several algo-
rithms have been proposed recently that tend to avoid these short-
comings, e.g. the Strength Pareto Evolutionary Algorithm (SPEA)
[93], the improved SPEA2 [92], the improved NSGA-II [24], and the
Multi-Objective Messy Genetic Algorithm (MOMGA) [83]. We de-
cided to compare SPEA2, NSGA-II, and a new multiobjective steady
state algorithm described in Section 2.3.5.
2.3. Concrete Realization 25
2.3 Concrete Realization

In order to represent a candidate solution within the evolutionary al-
gorithm, we decided to use the native representation inherent in the
problem description of Section 2.1.2. That means each individual is
of the form ind S, which gives a variable length representation
since the number of transmitters is not fixed.
An individual that represents a feasible candidate solution ind
FS is called a legal individual.
2.3.1 Repair Function

An individual that has been created and is infeasible at an intermedi-
ate stage of the algorithm can be transformed to a legal individual by
means of a so-called repair function.
To repair an individual we traverse the demand nodes in an arbi-
trary order. If a demand is not totally covered, then one of the follow-
ing actions is taken:
1. If there exist transmitters whose cells cover the demand node

and the transmitters have free capacity to satisfy the unsatisfied
calls, then the one with strongest signal will be selected to sat-
isfy the calls. For this transmitter new channels are allocated
for the unsatisfied calls.
2. If there exists no transmitter with free capacity whose cell cov-

ers the demand node, then for one of the neighboring non-
maximum capacity transmitters, power is increased to cover
the demand node. Which of the neighboring transmitters will
be changed, is decided based on the extra deployment cost in-
troduced by this change. The one with a minimum cost change
will be chosen to satisfy the calls. If the minimum cost change
will be bigger than the cost of introducing a new transmitter
with some default configuration that can satisfy the calls or
each neighboring transmitter already operates at maximum ca-
pacity, the action in step 3. is taken instead.
3. If none of the above actions are possible, then a new trans-

mitter is introduced having the same or a neighboring location
with the demand node in focus. This transmitter gets default
power and also default capacity. The frequency channels will

be allocated for the unsatisfied calls of the demand node.
In the repair operator we consider only the deployment cost as a crite-

rion to decide which repair action will be chosen. This repair function
results always in a legal individual.
2.3.2 Initialization
To initialize individuals at random, we start with an empty individual,
and we fill it with transmitters by applying the repair function. To
produce another, different, individual, we just reorder the sequence
of demands, and then repeat the first step. The reason for the reorder-
ing lies in the property of the repair function to take the order into
account.
This procedure has the advantage of producing legal individuals
only. A pure random setting of the single values of an individual
would instead lead with a high probability to an illegal individual.
It is perhaps a small disadvantage of this approach that the max-
imal population size depends on the number of demand nodes, since
the described initialization gives us only as many different individuals
as there are permutations of the sequence of demand nodes. However
this is not an issue for our real-world problem instances.
2.3.3 Mutation
Just like in most successful real-world applications of evolutionary
algorithms, we need to include problem knowledge in the genetic op-
erators to make the overall process effective and efficient. Since there
are some rules of thumb used by experts to get better solutions, we
introduce several mutation operators that use information produced
by the evaluation function. These mutation operators are able to yield
local changes of a given solution. We call them directed mutations.
Operators with a similar intention have also been used in timetabling
(e.g. [70]).
Using only such operators does not guarantee that all points in the
search space are reachable. Therefore, we also introduce some addi-
tional mutation operators that do not consider problem knowledge
and we call them random mutations.
Some of the directed and random mutation operators change the

individual in such a way that we cannot guarantee the individual to
remain legal. These operators are DM2 , DM3 , DM6 , RM1 , RM3 ,
RM4 . For these operators the repair function has to be applied addi-
tionally on the individual.
Directed mutations use additional computed information; their
application is limited to situations that satisfy certain preconditions.
DM1 Precondition There exist transmitters with unused fre-

quency channels.
Action Reduce the capacity.
Comment The goal is to reduce cost.
DM2 Precondition There exist transmitters with maximal ca-

pacity that use all frequency channels.
Action Place a transmitter with default power and
capacity in the neighborhood.
Comment The goal is to introduce micro-cells in ar-
eas with high number of calls.
DM3 Precondition There exist transmitters with big overlap-

ping regions.
Action Remove such a transmitter.
Comment The goal is to reduce the interference by
reducing the overlapping regions.
DM4 Precondition There exist transmitters with big overlap-

ping regions.
Action Decrease the power of such a transmitter
in a way that all satisfied calls remain sat-
isfied.
Comment The goal is to reduce cost and interference.
DM5 Precondition Interference occurs.

Action Change one of a pair of interfering fre-
quency channels.
Comment The goal is to reduce interference.
DM6 Precondition There exist transmitters satisfying only a

small number of calls.
Action Delete such a transmitter.
Comment The goal is to reduce cost.
Pure random mutations can be applied to any individual; there are

no preconditions.
RM1 Action Change the position of a randomly chosen

transmitter leaving power and capacity un-
changed.
Comment This operator is needed because the place-
ments of the transmitters in the service area are
not randomly chosen.
RM2 Action Introduce a new randomly generated individ-

ual.
Comment This is done by applying the repair function
starting with an empty individual as described
in Section 2.3.2. A random permutation of the
demand node sequence is used. This opera-
tor alone does not guarantee the reachability
of all points in the search space, since the re-
pair function follows some strict rules. With
this mutation it is possible to bring fresh ge-
netic material into the optimization.
RM3 Action Change the power of one randomly chosen

transmitter randomly.
Comment This operator is necessary to keep a balance to
the directed mutation DM4 .
RM4 Action Change the capacity of one randomly chosen

transmitter randomly.
RM5 Action Change the frequency channels allocated by

one randomly chosen transmitter randomly.
2.3.4 Recombination
In addition to the different mutation operators, we want to use the
possibility of combining genetic material of two individuals. Such a
recombination makes more sense if we also include problem knowl-

edge, so that the probability of combining good characteristics of the
parents is high.
The problem at hand has the characteristic that it is possible to
evaluate an individual according to parts of the terrain (i.e. parts of
the demand list). The aim of the recombination operator is to take
good parts from the parents and to merge them for constructing a new
individual the offspring.
Our recombination operator is based on a decomposition of the
service area (terrain) into two halves along one of the dimensions
(vertical or horizontal). For each half we evaluate the fitness of the
parent individuals, and the offspring will inherit the configuration for
each of the sub-areas from the parent that is fitter for that sub-area.
With this approach, there might be some undesired effects close to
the cutting line of the service area. If the offspring inherits the trans-
mitters that were located close to the cutting line from both parents,
huge overlapping regions can occur which probably lead to high in-
terference. To avoid such undesired effects, we leave a margin of the
size of a maximum cell radius on both sides of the cutting line, and
we inherit the transmitter configurations from the parents only for the
reduced half regions. In Figure 2.3.1 an example of the recombination
operator can be seen.
The recombination operator may lead to illegal individuals that
have to be repaired by the repair function.
2.3.5 Selection
The selection method is based on the cost cost(ind ) and the interfer-
ence IR(ind ) of the individuals ind in the population.
We have investigated the two standard multiobjective methods
Strength Pareto Evolutionary Algorithm 2 (SPEA2) [92] and the fast
elitist Nondominated Sorting Genetic Algorithm NSGA-II [24].
SPEA2 uses an external archive where the best candidate solu-
tions are stored. Each individual in the archive and the population
gets a strength value assigned which denotes how many individuals it
dominates. The raw fitness of an individual is computed as the sum
of the strength values of all individuals that dominate the individual.
The final fitness is obtained by adding a density information to the
parent 1 parent 2
recombination
repair
Figure 2.3.1: Recombination.
raw fitness which favors individuals with fewer neighbors from a set
of individuals with equal raw fitness. The parental selection is imple-
mented as a tournament according to the final fitness values. The time
complexity of the algorithm depends primarily on the density compu-
tation needed for the integration phase. If both the archive size and
the population size are N the integration of N newly created individ-
uals using the naive approach presented in [92] takes O(N 2 ) time. If
the archive size is N and the population size is 1, the time to integrate
N individuals is O(N 3 ).
NSGA-II computes all layers of non-dominated fronts. This re-
sults in a rank for each individual. Furthermore a crowding distance
is computed that is a measure for how close the nearest neighbors
are. Selection takes place by using a partial order where an individual
with lower rank is considered better and if the individuals have equal
rank the individual with bigger crowding distance is preferred. The
complexity of this method is determined by the expensive computa-
tion of the non-dominated fronts. In [24] a naive approach is used to
compute the Pareto fronts which turns out to run in O(M N 2 ) time,
where M is the number of objectives and N is the population size. In

Chapter 3 we present an approach that computes the Pareto fronts in
O(N logM 2 (N ) log log(N )) time.
Both standard methods have a rather generational character. One
may use the SPEA2 algorithm in a steady state mode but the time
complexity increases considerably. Also, there are no recommen-
dations concerning the population and archive sizes in the primary
literature.
At the initial stage of our application it was decided that a steady
state approach might be interesting, since it enters new individuals
immediately and favors a faster evolution speed. This is of big im-
portance since the consideration of more complex wave propagation
models may require much more time per evaluation. Therefore, a
new steady state selection was developed that pays special attention
to the replacement strategy and its time complexity. We refer to
the algorithm as steady state Evolutionary Algorithm with Pareto
Tournaments (stEAPT).
Both the parental selection as well as the replacement strategy are
based on a ranking strategy that takes into consideration the concept
of domination. We consider two subsets of the population when as-
signing a rank (fitness value ) to an individual ind , namely
Dominates(ind ), the set of individuals that are dominated by

ind , and
IsDominated (ind ), the set of individuals that dominate ind .
In our particular application both objectives are to be minimized,

hence the individuals that are dominated by an individual ind are
above and to the right of ind. The individuals that dominate ind are
below and to the left of ind.
The population is stored in a two-dimensional range tree, where
the keys are the two objectives. We use the two-dimensional dictio-
nary data structure from the Library for Efficient Data structures and
Algorithms (LEDA) [63]. This data structure can handle two dimen-
sional range queries in time O(k + log2 n) where k is the size of the
returned set and n is the current size of the dictionary. Insert, delete,
and lookup operations take time O(log2 n).
As a scalar fitness to be minimized the following value
fitness(ind ) = |IsDominated (ind )| PopSize + |Dominates(ind )|,
is assigned to each individual. Clearly the number of dominating in-

dividuals establishes a primary ranking in the population. This is the
primary cause for the selective pressure towards the overall Pareto
front. If there are individuals that are dominated by an equal number
of individuals, those that dominate fewer individuals are preferred.
This is a primitive mechanism to favor individuals from less crowded
regions in the objective space. We base this fitness computation on the
assumption that a considerable fraction of individuals are dominated.
If the complete population consists of non-dominated individuals se-
lection acts as a mere uniform selection and genetic drift may occur.
However, in all experiments using the real-world instance this never
appeared to be a problem.
The parental selection is implemented as a tournament selection
using the fitness value. After the variation operations a new individual
new has to be integrated into the population. For this purpose the
sets IsDominated(new) and Dominates(new) are computed. We
consider the following three cases for the integration of new.
Case 1: Both sets are empty. That means that new is a new non-
dominated candidate solution and should be inserted into the
population. The individual with worst fitness value worst is
deleted and the rank of individuals in IsDominated(ind) is
decreased by one (light gray area in Figure 2.3.2). The new
individual new is inserted with rank 0.
Case 2: The set Dominates(new ) = . Therefore, the worst indi-

vidual worst Dominates(new ) is deleted. Individual new
is inserted with its properly computed rank. The rank of all
individuals in IsDominated (worst) \ IsDominated (new ) is
decreased by one (light gray area in Figure 2.3.3). For individ-
uals in Dominates(new ) the rank is increased by PopSize.
Case 3: Dominates(new ) = and IsDominated (new ) = . The

new individual appears to be no improvement over any individ-
ual in the population and is therefore discarded. The case is
shown in Figure 2.3.4.
For the case that all individuals are in the Pareto front, we con-
sidered to compute a crowding measure online to determine the worst
individual and to prevent genetic drift. However, we did not encounter
such a situation so far.
worst
f2
dominates
new
dominated
case 1 f1
Figure 2.3.2: Replacement strategy for case 1.
worst
f2
dominates
new
dominated
case 2 f1
2.3.6 Algorithm
The main loop of stEAPT is sketched in Algorithm 2.1; it follows
the usual steady state scheme. For the variation of a selected individ-
ual only one of the operators, directed mutation, random mutation, or
recombination, is applied. The probability for the application of these
different kinds of operators is set by the parameter pDM for the prob-
ability to apply a directed mutation and pRM for the probability to
apply a random mutation. pDM + pRM < 1 is required and the prob-
ability for applying recombination follows as pRC = 1pDM pRM .
The repair function is applied to each newly created illegal individual.
f2
dominates
new
worst
dominated
case 3 f1
Algorithm 2.1 Steady state evolutionary algorithm, AlgstEAP T .

in: G - max. generations;
var: P - population; Ip - parent individual; In - new individual
out: PF - nondominated set of individuals;
begin
1: initialize(P )
2: t 0
3: evaluate(P )
4: while t G do
5: Ip selection(P )
6: In variate(Ip )
7: evaluate(In )
8: update(P, In ) integrate new individual and update rankings
9: if IsDominated (In ) = then
10: update(PF , In )
11: end if
12: inc(t)
13: end while
end AlgstEAP T
2.4. Experiments 35
2.4 Experiments
2.4.1 Experimental Setup
The three described multiobjective methods are applied to realistic
demand distributions on a 9000 9000 m2 area in the city of Zurich.
We use two different resolution grids on top of the service area. The
demand nodes are distributed on a 500 m resolution grid, for the
transmitter positions we use a finer grain resolution of 100 m.
The number of calls at a certain demand node are computed ac-
cording to the formula described in [79]. This formula is based on
information related to the call attempt rate (considered the same for
every mobile phone), number of mobile units per square kilometer,
the mean call duration and the size of the area represented by the
demand node. All these entities relate factors like land usage, pop-
ulation density and vehicular traffic with the calling behavior of the
mobile units.
For the studied service area we have |D| = 288 demand nodes
with a total number of 505 calls. Figure 2.4.1 shows the demand dis-
tribution: each disk represents a demand with its radius proportional
to the number of carried calls. The empty area is the lake of Zurich.
Figure 2.4.1: Demand node distribution in Zurich.
We have chosen a maximum number |F | = 128 of frequency

channels, to closely reflect reality for the GSM900 systems. The
adjacent-channel gap that should be respected at each cell in order
to have no adjacent-channel interference was chosen to be gAC = 2.
The maximum capacity of a transmitter is derived from the maxi-
mum number of channels and the adjacent-channel gap: MaxCap :=
|F |
gAC = 64 in our case. We use a simple isotropic wave propagation
model, where propagation depends only on the transmitting power
(in dBmW). The cell radius of a transmitter is computed as wp(ti ) :=
25pow i . We have a discrete set of power values that can be set for the
transmitters: MinPow = 10 dBmW, MaxPow = 130 dBmW, with
increments of 1 dBmW. The transmitter positions are chosen from a
discrete set of positions, given by the terrain resolution and the ser-
vice area. The deployment cost of each transmitter is cost(ti ) :=
10 pow i + cap i , for ti = (pow i , cap i , pos i , Fi ).
The three multiobjective methods have been applied to the given
problem using various settings for population size, tournament size,
number of objective evaluations, and probability distribution for the
different types of operators (pDM , pRM , pRC ). For each algorithm
with a specific parameter setting 16 independent, consecutive runs
have been executed.
2.4.2 Statistical Comparison

Single runs could identify several candidate solutions on a very high
competitive level which justifies the general approach used. There
is still a very high variance in the quality of the runs using the same
method and parameters. Although the development of very special-
ized operators was emphasized, the problem landscape seems still
to be so rugged that there are many local optima where the non-
dominated set of candidate solutions can get stuck.
As a consequence the comparison of different parameter settings
or multiobjective methods turns out to be difficult. However to get
statistical confidence concerning our conclusions we have chosen the
following approach. Given a Pareto front of one run and the observa-
tion that the front is convex in almost all experiments, one candidate
solution may be chosen using a weighted sum. If this is done for
all runs of two different algorithms, we get two data series consist-
ing of 16 weighted sums representing the best solution concerning
the respective weights. Those data series may be compared using a
Students t-test to get an idea whether there is a significant differ-

ence. In particular the two objectives are scaled, IR(ind ) = IR(ind)
0.7

and cost(ind ) = cost(ind)7500 , and for {0.1, 0.2, . . . , 0.9} the
4500

weighted sum W S(ind ) = IR(ind ) + (1 )cost(ind ) is consid-
ered.
2.4. Experiments 37
This comparison turns out to be very useful for the optimization

problem at hand since it reduces the visually hardly interpretable data
to exact numbers. In the comparisons given in the following two
sections, all values of support the respective statements.
2.4.3 Parameter Settings

In our experiments, there are too many possible parameter settings to
try them all. Unfortunately, there is no way to know the ,,best para-
meter values right from the start. As an unavoidable consequence, a
set of experiments cannot yield an insight that we can claim in full
generality. Nevertheless, after plenty of experiments, we gained a
,,feeling for what would be parameter settings that reveal an under-
lying principle.
The examination of a wide range of population sizes lead finally
to the population size 80 that is used in all experiments. Concerning
SPEA2 both the archive size and the population size are chosen to be
80. In the same way the tournament size was chosen to be 5. Also a
set of experiments with varying number of evaluations has led to the
judgment that 64000 evaluations are sufficient since no substantial
improvement takes place after that in most experiments.
Concerning the probability distribution for the different operators,
experiments show that the problem specific operators alone (pDM =
1 or pRC = 1) lead to a quick convergence of the population on a bad
quality level for both objectives. This is reasonable since these special
operators are not able to reach every point in the search space and tend
to get stuck in local optima. The random mutations alone yield fairly
good results, as can be seen in Figures 2.4.2, 2.4.3, and 2.4.4 which
show the non-dominated individuals of the 16 runs (different symbols
represent different runs).
As we can see in Figures 2.4.5, 2.4.6 and 2.4.7, the combination
of random and directed mutations gives better results. The proba-
bilities pDM = pRM = 0.5 are used. The difference is significant
according to the statistical investigation described above. The inter-
action between the explorative global (random) and the exploitative
local (directed) operators provides the power to find better solutions
than with random mutation alone. This is also in accordance with the
theoretical findings of Weicker [85] concerning the shift from explo-
ration to exploitation during search.
Various probability distributions putting different emphasis on the

three types of operators have been investigated. The best results could
be obtained using pDM = 0.3, pRM = 0.3, and pRC = 0.4. Again
the difference to the two previously described probability settings are
significant. The results are displayed in Figures 2.4.8, 2.4.9, and
2.4.10.
2.4.4 Multiobjective Methods
The comparison of the three presented multiobjective methods turns

out to be difficult. A visual comparison of Figures 2.4.22.4.10 leads
to no result. The statistical comparison shows also that no signif-
icant difference can be proven for the two operator schemes using
no recombination. In fact for all considered values of , the aver-
age weighted sums are almost identical across all three multiobjective
techniques.
However, by setting pDM = 0.3, pRM = 0.3, and pRC = 0.4
(the best performing scheme) we get a different result. The new
method stEAPT reaches worse average weighted sums for all val-
ues of . For = {0.3, 0.4, . . . , 0.9} the best values are reached
by NSGA-II. And for = 0.6 and = 0.7 the difference between
NSGA-II and stEAPT turns out to be significant with an error proba-
bility of less than 0.06.
These findings show that there is no difference in the performance
of the three compared methods concerning the hard real-world prob-
lem as long as the mutation operators are considered. Here the stEAPT
method proves to be a useful alternative especially since the computa-
tion time is considerably smaller than in the other approaches. How-
ever, as soon as a very specialized recombinative operator is added,
the choice of the multiobjective method makes a difference. The only
possible explanation for this phenomenon is, that both NSGA-II and
SPEA2 select the parental individuals in a more appealing way for
the recombination. As a consequence, better offspring are produced.
Presumably, the more sophisticated crowding procedures within the
fitness computation of NSGA-II and SPEA2 lead to a more diverse
recombinative behavior.
2.5. Conclusions and Open Problems 39
2.5 Conclusions and Open Problems

In this chapter, we have shown that evolutionary algorithms are a
strong enough tool to tackle the real-world problem of base station
transmitter placement and frequency assignment. The success of the
evolutionary approach is primarily due to the tailored problem spe-
cific operators.
As a new multiobjective technique the stEAPT approach was in-
troduced. It combines a steady state scheme with an efficient data
structure leading to better time complexity. In general the stEAPT
algorithm proves to be competitive to NSGA-II and SPEA2at least
for the considered hard real-world problem.
However, the probably most intriguing outcome of this examina-
tion is the interplay between the crowding mechanisms and the re-
combination operator. Here NSGA-II and SPEA2 turn out to support
the recombinative potential of the population in a considerably bet-
ter way than the simpler stEAPT. The Pareto fronts based ranking
strategy used in the NSGA-II evolutionary algorithm lead us to inves-
tigate the interesting d-dimensional layers-of-maxima problem that
we present in the Chapter 3.
11500
10500
Preto Front (N SG A 2)
C ost
9500
8500
7500
0
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
Interference
Figure 2.4.2: NSGA-II: Experiments using random mutations only.

11500
10500
Pareto Front (SPEA 2)
C ost
9500
8500
7500
0
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
Interference
Figure 2.4.3: SPEA2: Experiments using random mutations only.

11500
10500
Pareto Front(stEA PT)
C ost
9500
8500
7500
0.7
0.6
0.5
0.4
0.3
0.2
0.1
Interference
Figure 2.4.4: stEAPT: Experiments using random mutations only.

11500
10500
Pareto Front (N SG A 2)
C ost
9500
8500
7500
0
0.7
0.6
0.5
0.4
0.3
0.2
0.1
Interference
Figure 2.4.5: NSGA-II: Experiments using a combination of 50%

random mutations, 50% directed mutations and no recombination.
11500
10500
Pareto Front (SPEA 2)
C ost
9500
8500
7500
0
0.7
0.6
0.5
0.4
0.3
0.2
0.1
Interference
Figure 2.4.6: SPEA2: Experiments using a combination of 50% ran-

dom mutations, 50% directed mutations and no recombination.
11500
10500
C ost
9500
8500
7500
0.7
0.6
0.5
0.4
0.3
0.2
0.1
Interference
Figure 2.4.7: stEAPT: Experiments using a combination of 50% ran-

dom mutations, 50% directed mutations and no recombination.
11500
10500
Pareto Front(N SG A 2)
C ost
9500
8500
7500
0.7
0.6
0.5
0.4
0.3
0.2
0.1
Interference
Figure 2.4.8: NSGA-II: Experiments using a combination of 30%

random mutations, 30% directed mutations and 40% recombination.
10'th
11'th
12'th
13'th
14'th
15'th
16'th
1'st
2'nd
3'rd
4'th
5'th
6'th
7'th
8'th
9'th
11500
10500
Pareto Front(SPEA 2)
C ost
9500
8500
7500
0.7
0.6
0.5
0.4
0.3
0.2
0.1
Interference
Figure 2.4.9: SPEA2: Experiments using a combination of 30% ran-

dom mutations, 30% directed mutations and 40% recombination.
11500
10500
C ost
9500
8500
7500
0.7
0.6
0.5
0.4
0.3
0.2
0.1
Interference
Figure 2.4.10: stEAPT: Experiments using a combination of 30%

random mutations, 30% directed mutations and 40% recombination.
Chapter 3
Maxima Peeling in
d-Dimensional Space
3.1 Introduction
Most real life optimization problems contain more than just one op-
timization criteria and usually these objectives are conflicting with
each other. Hence, there is no single best solution to such problems
but rather a set of good solutions. One state-of-the-art meta-heuristic
approach to solve complicated, real-life multiobjective optimization
problems is by using evolutionary algorithms.
Most multiobjective evolutionary algorithms (MOEA) use Pareto
domination to guide the search in finding a set of bestsolutions. In
a d-dimensional space a solution dominates another solution if and
only if it is at least as good as the other solution in all objectives and
there is at least one dimension in which it is strictly better than the
other solution. Here, we focus on the case where all objectives are to
be maximized. For an example, consider the solution represented by
the point p in Figure 3.1.1 for the two-dimensional space. Every point
inside the gray area is dominated by the point p. A solution (point)
is nondominated if it is not dominated by any other solution. Recent
MOEAs return the Pareto front, the solutions not dominated by any
other solution in the search space.
Even though most MOEAs nowadays work with several objec-
49
50 Chapter 3. Maxima Peeling in d-Dimensional Space
x2
x1
Figure 3.1.1: The point p dominates all points inside the gray rect-
angle.
tives simultaneously, they still transform these objectives into one sin-
gle fitness value. This is necessary because what makes evolutionary
algorithms advance in the search space is the selection of highly fit
individuals (solutions) over less fit ones. Two of the most successful
MOEAs are Zitzler and Thieles strength Pareto evolutionary algo-
rithm (SPEA [94]) and Deb et al.s nondominated sorting genetic al-
gorithm (NSGA-II [25]). As fitness value for an individual they both
use some combination between the number of individuals it domi-
nates and the number of individuals it is dominated by. The computa-
tionally most expensive task of these algorithms is the fitness compu-
tation. Hence it makes sense to get as fast as possible algorithms for
solving this task.
We focus our attention on the NSGA-II technique, where the fit-
ness value is given by the layer-of-maxima to which the individual
belongs. The set of maxima is the subset of the original points that are
nondominated. The layers-of-maxima problem asks for a partition of
the points into layers. The first layer is formed by the points in the set
of maxima. Layer i (i > 1) is formed by points that are dominated by
at least one point from layer i 1 and are not dominated by any point
from layers j i. The NSGA-II approach, as all evolutionary algo-
rithms, maintains a population of individuals (solutions) from which
new individuals are created. The new individuals enter the population
only after a whole new generation of the same size as the old popula-
tion was created. The new population is formed by individuals from

the new generation and the old population by filtering out the weaker
individuals. The filtering is done based on the fitness value and hence
based on the layer numbers. Therefore these layer numbers have to
be recomputed after every generation. Thus it is important to have a
fast algorithm to compute the layers-of-maxima.
3.1.1 Related Work
A straight-forward approach to solve the layers-of-maxima problem

is by repeatedly solving the set of maxima problem. In each iteration
one layer is identified and subtracted from the original set. The algo-
rithm stops when the set becomes empty. Finding the set of maxima
in a point set S of size n in d-dimensional space is an old problem
analyzed in computational geometry [59]. The algorithm presented
in the original paper by Kung, Luccio and Preparata [59] is the most
efficient deterministic solution to this problem. It has running time
O(n logd2 (n) + n log(n)) in the general d-dimensional case.
Thus the straight-forward approach would peel the layers of maxima
in the worst case in O(n2 logd2 (n)) time.
In [51] M.T. Jensen presented a divide-and-conquer algorithm for
the layers-of-maxima problem with running time O(nlogd1 (n)). In
[51] it is mentioned that if there would be an O(n log(n)) algorithm
for the three-dimensional layers of maxima problem then it could be
used as the base case of the divide-and-conquer algorithm leading to a
O(n logd2 (n)) algorithm for the d-dimensional problem. Actually
there is an O(n log(n)) algorithm for the three-dimensional layers
of maxima problem presented in [13]. But the approach from [13]
cannot be used for higher dimensions with the divide-and-conquer
approach. The solution presented in [13] is based on the property
that the layers-of-maxima in the two-dimensional space are mono-
tone, that is they can be represented as staircases that never intersect
each other. However, in higher dimensions it can happen that two
points a and b are incomparable and a belongs to a smaller labelled
layer than b even though when projected into the plane b dominates
a. This shows that when points in higher dimensions are considered
the layers projected into the plane dont have the monotone property
anymore.

The candidate solutions (individuals) are represented as points in d-
dimensional space. A point u in this space is fully defined by its d
coordinates, u = (u1 , u2 , . . . , ud ) Rd . The input set of points is
denoted by S and contains n points.
A point u = (u1 , u2 , . . . ud ) dominates point v = (v1 , v2 , . . . vd )
if and only if it is bigger or equal than the other point in all dimensions
and there is at least one dimension in which it is strictly bigger than
the other point: i {1 . . . d}, ui vi and j {1 . . . d} such
that uj > vj . We denote this domination relation with u v (read u
dominates v). Two points are incomparable if none of them dominates
the other. A point in S is nondominated if there is no point in S that
dominates it. The maxima set (or Pareto layer) of a point set S is
the subset of points that are nondominated, P L = {p S | v
S : v p}. An example of the maxima set for the two-dimensional
space is depicted in Figure 3.1.2 by the staircase labeled with 1.
The general d-dimensional layers-of-maxima is an offline prob-
lem where we are given in advance all points of the set S. The task
is to assign labels to the points according to the layer of maxima to
which they belong. The first layer is the maxima set. We define the
label function that returns the layer number for every point as follows,
l : S N+ , where
l(p) := max {1, max {1 + l(q) | q S q p}}.
All the points belonging to the same layer are incomparable between
themselves. An example for the correct labelling of point p in two-
dimensional space can be seen in Figure 3.1.2. The model of com-
putation used in this chapter (unless stated otherwise) is the pointer
machine model (SMM), for a definition of this model the interested
reader is referred to the chapter on machine models from [82]. We
relax the pointer machine model by allowing reals to be stored and
compared instead of integers.

In the following sections we present our results on the d-dimensional
layers-of-maxima problem. We present two different algorithmic para-
digms that solve the problem in O(n logd2 (n) log log(n)) time.
x2
1
2 1
2
2 1
3 2
max
p
4 l(p) = 1 + 2
3
x1
Figure 3.1.2: Labeling the point p. The points inside the gray rect-
angle dominate p.
This result is an improvement over the best known algorithm from

[51] that has running time O(n logd1 (n)).
In Section 3.2 we present a d-dimensional sweep algorithm that
uses a multilevel balanced search tree together with a van Emde Boas
priority queue [81]. In Section 3.2.2 we show that the running time
of this algorithm is O(n logd2 (n) log log(n)) and the storage over-
head is also O(n logd2 (n) log log(n)). In Section 3.3 we present a
divide-and-conquer approach similar to the one used in [51] with an
improved base case for the two-dimensional space. The analysis of
Section 3.3.2 shows that the running time is the same as for the sweep
algorithm and that the space overhead is just O(n d + n log log(n)).
We also present an easy to implement data structure for the semi-
dynamic set of maxima problem in Section 3.4 that has an update
time of O(logd1 (n)).
3.2 Sweep-Hyperplane Algorithm

In this section we show how to solve the layers-of-maxima problem
in d-dimensional space using a sweep approach together with a mul-
tilevel binary search tree.
In a preprocessing step the algorithm sorts the points in S accord-
ing to the dth coordinate. In case of equality the lexicographical order
is taken. Then, a sweep-hyperplane scans the points in decreasing dth
coordinate. Based on the already visited points it computes the layer
number of the current point. From the definition of domination it fol-
lows that all the points p S that dominate the current point q have
greater or equal dth coordinate and hence they were already visited
by the sweep-hyperplane. This observation leads to the following in-
variant:
Invariant 3.1 The sweep-hyperplane algorithm computes the label

for a point q only after all the points dominating it already have their
correct label.
The sweep-hyperplane reduces the original static d-dimensional prob-

lem to a sequence of semi-dynamic d 1 dimensional problems. The
d 1-dimensional problem is the following: given a query point q,
compute its layer-of-maxima label, with respect to the points labelled
earlier. To do so, efficiently maintain dynamically in a data struc-
ture the set of already labeled points. The freshly labeled point q is
inserted into the data structure. We call this problem semi-dynamic
because we dont have explicit deletions; we have only queries and
insertions. The pseudo-code of the algorithm can be seen in Al-
gorithm 3.2. The function update in the pseudo code is meant to
compute the layer-of-maxima label for point q and to update the data
structure Tlm . The correctness of the algorithm follows from the In-
variant 3.1. If we denote by Cu the runtime of the update function,
the runtime of the sweep-hyperplane algorithm is O(n Cu ). In the
following subsection we present the semi-dynamic data structure Tlm
and refer to it as the layer-of-maxima tree.
3.2.1 The Layer-of-Maxima Tree

The layer-of-maxima tree is a multilevel balanced binary search tree
data structure that supports the following operations: query for the
3.2. Sweep-Hyperplane Algorithm 55
Algorithm 3.2 Sweep-hyperplane algorithm, Algsweep (S, d)

in: S - the point set; d - dimension;
parameter: Tlm - semi-dynamic data structure;
out: correctly labeled points in S;
begin
1: sort(S, d)
2: for all q S do
3: update(q, Tlm )
4: end for
end Algsweep
label of a point and insert a correctly labeled point. A multilevel

balanced binary search tree is a cascaded balanced search tree. The
ith-level tree stores in its leaves the points sorted according to their
d ith coordinate (where i {1, . . . , d 1}). To every inner node
v in this tree there is a corresponding i + 1th-level tree that stores in
its leaves the points in the subtree of level i rooted at node v. The
advantage of such a level tree decomposition is that it induces only a
log(n) factor query time overhead per dimension. Multilevel tree data
structures were successfully used for d-dimensional range queries and
other geometric object intersection queries, see [26].
Query: A layer-of-maxima query for query point q = {q1 , . . . , qd }

is performed as follows. We search in the 1st-level tree for the key
qd1 . Along the search path we identify the nodes that contain at
the leaf level points with bigger d 1-coordinates than q. These are
the right siblings of the nodes on the search path and we call them
active nodes. In addition we consider as active node also the leaf
at the end of the search path if its d 1-coordinate is higher than
qs. We are interested only in the active nodes because all the points
that dominate the query point q are stored in the subtrees of these
nodes. At the active nodes we do a search in the 2nd-level trees for
the key qd2 . This search is repeated until the d 1th-level trees are
reached, where we search for the key q1 . At the inner nodes of the
d 1th-level trees we store in addition to the 1st-coordinate keys the
maximum label of the points stored in the subtree rooted at this node.
The answer to the query is the maximum of the labels stored in the
active nodes of this d 1th level tree. Then this value is propagated
upwards to the previous level and again the maximum label is chosen.
The propagation stops at the 1st level tree. The correct label of the
point q is the maximum of the labels returned from the active nodes
of the 1st-level tree plus one. Figure 3.2.1 visualizes the way a query
is performed in the multilevel balanced binary search tree. The path
shown on the figure is the search path and the nodes shown are the
active nodes.
Insert: Inserting the point p (after its label was computed) is done
by inserting the point into the 1st-level tree and then into the lower
level trees of the nodes on the search path. The insertion is carried
out recursively until the last level trees are reached. Here, besides
inserting the point p, the maximum labels of the nodes on the search
path are updated if smaller than the label of p.
If we use a balanced binary search tree for all d 1 dimen-
sions then the sweep-hyperplane algorithm has a running time of
O(n logd1 (n)), which is not better than the algorithm presented
in [51]. To improve the running time we consider a different data
structure for the one-dimensional case (d 1th-level trees). For this
case we need a data structure that is able to answer layer-of-maxima
queries and can be updated faster than in O(log(n)) time.
The problem reduced to the one-dimensional space is the follow-
ing. We are given the projection onto the line of a subset S of the
original points in S together with their correct layer-of-maxima label.
The layer-of-maxima labels reflect the layers in the d-dimensional
space and not on the line. We want to compute the intermediate
label for a query point q by looking at its projection onto the line
(considering only its q1 coordinate). We say intermediate label be-
cause this is the label computed at one of the d 1th-level trees in
the multilevel layer-of-maxima tree. An example instance of the re-
duced one-dimensional layer-of-maxima query problem is shown in
Figure 3.2.2. To find the intermediate label of q one has to find the
point with the maximum label that dominates it in the reduced one-
dimensional space. For the instance in Figure 3.2.2 the intermediate
label is 2. We also want to be able to insert a point p that is already
labeled. The label of the points partitions the line into layer regions.
A layer region is an interval (a, b] with the property that all the query
points falling into this interval get the same intermediate label l. The
intervals are defined by the position and label of the point at their
d 1th-level trees
1st-coordinate
lmax
q1
...
d 2th-coordinate
2nd-level trees
lmax
lmax
qd3
qd3
lmax,1
lmax,j
qd2
qd2
d 1th-coordinate
1st-level tree
qd1
1 + maxj {lmax,j }
active nodes
Figure 3.2.1: Processing a layer-of-maxima query in a multilevel

search tree.
52 1 4 2 21 1
q1 x1
Figure 3.2.2: Example instance for the reduced one-dimensional

layer-of-maxima query problem.
52 1 4 q1 21 1
x1
5 4 2 1 0
Figure 3.2.3: Partitioning the line into layer regions.
52 1 4 5p 21 1
x1
5 4 2 1 0
insert(p, 5)
5 2 1 0
Figure 3.2.4: Inserting point p with label 5.
right boundary b. In Figure 3.2.3 one can see the layer regions for the
instance presented in Figure 3.2.2. An important property of the layer
region partition is that the labels of the regions are decreasing from
left to right.
Answering a query is now reduced to the problem of finding the
upper bound b of the layer region to which the query point belongs
and returning its label.
An insertion of the labeled point p = (p1 , p2 , . . . , pd ) can be car-
ried out by finding the layer region to which it belongs based on the
p1 coordinate. If the label of the point p is less or equal than the la-
bel of the region then the point is discarded. Otherwise, the region is
split into two at the position p1 and the new point p defines the label
of the newly created region at its left side. The predecessor regions
of p with smaller label than p have to be merged into one single re-
gion defined by p. An example for inserting the point p with label 5
is shown in Figure 3.2.4. After inserting the point p the region with
label 2 is split and the newly created region with label 5 is merged
with the predecessor regions having labels 4 and 5.
The operations needed to maintain the layer regions under inser-
tions and layer queries define a data structure that supports the fol-
lowing operations: predecessor, successor, insert, delete. One effi-
cient implementation of such a data structure is by using van Emde

Boas priority queue [81]. Van Emde Boas priority queue works
with a fixed universe of elements and provides the following oper-
ations: predecessor, successor, insert, delete, min, max. The worst
case running time is O(log log(N )) for all these operations, where N
is the size of the universe. Our layer query can be answered using a
successor query and an insert can be carried out using the operations
predecessor, successor, insert, delete. Hence, instead of balanced bi-
nary search trees at the d 1th level in the multilevel data structure
we can use van Emde Boas priority queues. The fixed universe of a
certain priority queue at level d 1 is given by the subset of query
points from S that will reach this priority queue and the subset of
points that will be inserted into this priority queue. Since our original
problem is a static problem the universe of every d 1th level van
Emde Boas priority queue can be computed in a preprocessing step.
The size of the universe is bounded from above by n, the size of S.
3.2.2 Space and Running Time Analysis

As already stated at the beginning of Section 3.2 the running time
of the Algorithm 3.2 is O(n Cu ), where Cu is the query and up-
date time of the multilevel layer-of-maxima tree. In the multilevel
layer-of-maxima tree both the insert and query operations induce an
O(log(n)) factor running time overhead per dimension except on the
last level where we have an O(log log(n)) factor for the query. The
insertion might involve several delete operations but we know that a
point can be deleted only once and hence the deletion cost can be
charged to the insertion of the point that is deleted. Hence in an
amortized sense the insertion also costs only O(log log(n)) time. The
multilevel layer-of-maxima is built for the first d 1 dimensions. The
last dimension is taken care by the sweep hyperplane. Hence, the run-
ning time Cu is in O(logd2 (n) log log(n)) and the running time of
the sweep hyperplane algorithm is O(n logd2 (n) log log(n)). To
avoid rebalancing complications of the multilevel layer-of-maxima
tree one can construct the whole multilevel tree structure in a pre-
processing step and store additional flags in the nodes to mark if a
node is present at the time when the current sweep hyperplane is pro-
cessed. In the preprocessing step we store with every point in a linked
list O(logd2 (n)) pointers to guide the query and insertion in the van
Emde Boas priority queues. These pointers dont change the asymp-
totic space usage nor the asymptotic runtime and make our algorithm
work in the comparison based pointer machine model. Setting the
flag doesnt change the asymptotic running time of the algorithm and
the preprocessing step can be done in O(n logd2 (n) log log(n))
time.
The space usage is determined by the multilevel layer-of-maxima
tree. The tree at the 1st level induces a factor O(n) storage and every
lower level induces a factor O(log(n)) except the last level (van Emde
Boas priority queues) that induces a factor O(log(n) log log(n)) stor-
age overhead. All together the storage overhead of the sweep hyper-
plane algorithm is O(n logd2 (n) log log(n)). We conclude our
analysis with the following theorem.
Theorem 3.3 The running time and space usage of Algorithm 3.2 is
O(n logd2 (n) log log(n)).
3.3. Divide and Conquer Algorithm 61
3.3 Divide and Conquer Algorithm

In this section we present another O(n logd2 (n) log log(n)) algo-
rithm that solves the d-dimensional layers-of-maxima problem. The
benefit of this algorithm over the sweep hyperplane algorithm is its
space efficiency.
This algorithm is a modification of the divide-and-conquer ap-
proach presented in [51] which in turn is based on the general multi-
dimensional divide-and-conquer technique of Bentley [10]. The mul-
tidimensional divide-and-conquer approach was successfully used for
computational geometry problems in high dimensional space. The
basic idea of the multidimensional divide-and-conquer technique is
to divide the original problem given for the d-dimensional space into
subproblems of smaller sizes (usually two subproblems half the size
of the original). Then recursively solve the smaller problems still in
d-dimensions and at the end merge the solutions produced for the
subproblems to get a solution for the original problem. The decom-
position into subproblems is done in such a way that the merging step
is doable in a d 1-dimensional space. In the following subsection
we present a multidimensional divide-and-conquer approach for the
layers-of-maxima problem in d-dimensional space.
3.3.1 Algorithm
Every divide-and-conquer algorithm works in two steps: problem de-
composition (divide step) and solution merging (conquer step).
Two-dimensional case For readability reasons we first present these

two steps for the two-dimensional layers-of-maxima problem and then
we generalize it for the d-dimensional space.
Divide step: We divide the original set S into two subsets A and B
such that the number of points in A and B is approximately the same
and in addition all the points in B have higher 1st-coordinates than
the points in A. This division can be done in linear time by finding
the median point pm (see [11]) according to the 1st coordinate. Fig-
ure 3.3.1 shows an example division using the vertical line L defined
by the 1st coordinate of the median point. One important property
x2
A
pm
B
L x1
Figure 3.3.1: Space decomposition as divide step of the di-

vide-and-conquer approach.
of this space decomposition is that the points in A cannot dominate

the points in B. For the sake of correctness, the divide-and-conquer
algorithm needs to satisfy the following invariant:
Invariant 3.4 The labels of the points in A are bounded from below
by the labels of the points in B that dominate them.
The invariant says that points in A dominated by points in B must

have bigger labels than the points in B that dominate them. The in-
variant together with the property that points in A cannot dominate
points in B, leads to the conclusion that first the recursion on the set
B has to be done, then the contribution from B onto A and at the end
the recursion on the set A.
Merge step: In this step we have to update the labels of the points in
the set A by taking into consideration the points from B that dominate
them. Before the merging is started all the points in B have already
their correct labels. It is enough to consider only the projection of the
two point sets A and B onto the division line L, because all the points
in B have higher 1st coordinates than the points in A. If we consider
that the points in both sets A and B are presorted according to their
2nd coordinates, then a simple parallel scan of the sets A and B (in
decreasing 2nd coordinate order) is enough to initialize the label of
x2
1
1
1
2
A 3
B
3
3
1
L x1
Figure 3.3.2: Contribution of the points in B onto the points in A.
the points in A. The label of a point q in A is initialized by consider-

ing the maximum label of a point in B having higher 2nd coordinate
than q. The label initialization rule for a point q = (q1 , q2 ) A is the
following: l(q) = max(l(q), maxp=(p1 ,p2 )B {1 + l(p) | p2 q2 }).
In Figure 3.3.2 we show the contribution of the set B onto the set A,
where the set B is already correctly labeled.
General case The divide-and-conquer algorithm presented above

can be generalized to the d-dimensional space. The pseudo-code is
shown in Algorithm 3.5. The splitting of the set S is done according
to the median along the dth dimension. The actual labeling of the
points is done in the merging function Algcontrib described by Al-
gorithm 3.6. In this function, the label of the points in A is updated
according to the maximum labeled points from B that dominate them.
This function stops in one of the following base cases: the size of A
or B is one, or the dimension is equal to the base case dimension. In
case that the dth coordinates of the points in A are smaller than the dth
coordinates in B the recursion Acontrib (B, A, d 1) is called (line
7 of Algorithm 3.6). In case that all the points in A have higher dth
coordinate than the points in B the algorithm stops since no points
from B can dominate any point from A. The remaining case is when
the sets A and B overlap with their min-max dth coordinates. In this
case we split them according to the median value xsplit d along the
dth coordinate. The subsets A1 , B1 contain points with smaller dth
Algorithm 3.5 d-dimensional divide-and-conquer algorithm,

Algdq (S, d)
in: S - the point set; d - dimension
out: correctly labeled points in S
begin
1: if | S |= 2 then
2: {label the two points by comparing them}
3: else
4: split(S, A, B, d)
5: Algdq (B, d)
6: Algcontrib (B, A, d 1)
7: Algdq (A, d)
8: end if
end Algdq
coordinate than xsplit

d and the points in A2 , B2 have higher dth coor-
dinate than xsplit
d . Since we know that no point in B1 can dominate
any point in A2 only three recursive calls are needed (lines 12-14 of
Algorithm 3.6). To solve the problem in the base case dimension a
different algorithm is used. In [51] a two-dimensional algorithm is
presented as base case that runs in O(n log(n)) time.
Base case In what follows we present an improved base case al-

gorithm (Algbase from Algorithm 3.6) for the merging step in two-
dimensional space with running time O(n log log(n)). The contri-
bution problem in the two-dimensional space is the following: we are
given as input two sorted sets of points A and B. The task is to up-
date the labels of the points in A by considering the correctly labeled
points in B. The update rule is the same as before and the domination
is considered in the two-dimensional space. The points are presorted
in descending order according to the x-coordinate. The problem can
be solved with a sweep line that goes from higher x-coordinate val-
ues towards lower ones. The algorithm maintains the points from B
visited so far in a semi-dynamic data structure and updates the label
of the points in A when they are met by the sweep line by querying
the data structure. This problem can be solved similarly to the one-
dimensional layers-of-maxima problem presented in Section 3.2.1.
In the contribution problem a layer-of-maxima query is issued when
y
1
1 0 0 0
0
0
q 3 3 3
24
5 2
14
33
s5 s4 s3 s2 s1 x
Figure 3.3.3: Sweep line approach to solve the base case contribution
problem in the plane.
the sweep line meets a point from the set A and a data structure up-
date is issued when a point from B is met. A problem instance in
two-dimensional space, together with the current sweep line s5 and
previous sweep line positions and the layer regions, is shown in Fig-
ure 3.3.3. The points of set A are represented with crosses and the
points from B are represented with circles. The figure also shows how
the labels change for the points in A that were already visited. In the
label notation l1 l2 for the visited points from set A, l1 represents
the old label of the point and l2 represents the new label after consid-
ering the points from B that dominate it. Hence, by using the sweep
line together with a van Emde Boas priority queue [81] the two-
dimensional contribution problem can be solved in O(n log log(n))
time and space.
3.3.2 Space and Running Time Analysis
In this section we analyze the runtime behavior of the Algorithms 3.6

and 3.5. We can describe the complexity of Algorithm 3.6 using the
following recursive function (where |A| = n1 , |B| = n2 , |A1 | = n1 ,
Algorithm 3.6 Contribution from B to A, Algcontrib (B, A, d)

in: B - correctly labeled point set; A - point set dominated in the
d + 1-coordinate by all points in B; d - dimension;
out: contribution from B reflected on A
parameters: k - base case dimension
begin
1: if | B |= 1 or | A |= 1 then
2: {update labels in A by exhaustive comparison with points in
B}
3: else if d = k then
4: Algbase (B, A)
5: else
6: if maxd (A) mind (B) then
7: Algcontrib (B, A, d 1)
8: else if mind (B) maxd (A) then
9: xsplit
d = mediand (A B)
10: split(A, A1 , A2 , xsplit
d , d)
11: split(B, B1 , B2 , xsplit
d , d)
12: Algcontrib (B1 , A1 , d)
13: Algcontrib (B2 , A1 , d 1)
14: Algcontrib (B2 , A2 , d)
15: end if
16: end if
end Algcontrib
|A2 | = n1 , |B1 | = n2 , |B2 | = n2 ):

Tc (n1 , n2 , d)+

Tc (n
1 , n2 , d 1)+
Tc (n1 , n2 , d) = Tc (n
1 , n
2 , d) + n1 + n2 if n1 , n2 > 1 and d > 2

d (n1 + n2 )
if n1 = 1 or n2 = 1
(n1 + n2 ) log log(n1 + n2 ) if d = 2
When n1 , n2 are not constants and d > 2 after a split of the sets A
and B we have three recursive calls (see lines 9-14 in Algorithm 3.6).
The splitting can be done in linear time. In case n1 or n2 is a constant
we can do exhaustive comparison to update the labels in A. When
d = 2 we run the base case algorithm from Section 3.3.1. We can
simplify this recursive function by considering n1 + n2 = n as the
only input parameter representing the size of the set A B. After this
simplification we get:

2 Tc ( n2 , d) + Tc (n, d 1) + n if n > 2 and d > 2
Tc (n, d) = 2d if n = 2

n log log(n) if d = 2
A general technique on how to prove upper bounds for recursive for-

mulas of multidimensional divide-and-conquer algorithms is given in
[65]. For our algorithm by guessing the running time a simple induc-
tion proves the same upper bound. In the proof of Theorem 3.7 we
show an upper bound of O(nlog(n)d2 log log(n)) for our recursive
formula Tc (n, d) using induction on the parameter d.

Theorem 3.7 Algorithm 3.6 has O n logd2 (n) log log(n) run-
ning time.
Proof. First we introduce the following parameter transformation p =

log(n) and we consider the function B(p, d) = Tc (22p ,d) + 1. Using
p
the recursive formula for Tc (2p , d) we get:

B(p 1, d) + B(p, d 1) if p > 1 and d > 2
B(p, d) = d+1 if p = 1

log(p) + 1 if d = 2
Next, we have to prove that B(p, d) O(pd2 log(p)). We use

induction on the parameter d to show that B(p, d) 1 + d + pd2
log(p). For the case d = 2 is easy to check that the inequality holds.
In the inductive step we assume that B(p, d 1) d + pd3 log(p)
holds and we prove that B(p, d) 1 + d + pd2 log(p) also holds.
From the recursive formula and our assumption we have: B(p, d)

B(p 1, d) + d + pd3 log(p). After unfolding the recursion with
respect to p and repeatedly applying our assumption we get:

p
B(p, d) B(1, d) + (k d3 log(k) + d)
k=2

p
d+1+ (k d3 log(k) + d)
k=2
It is easy to see that the right hand side of the last inequality is bounded
from above by 1 + d + pd2 log(p) if 3 < d < p, where p is consid-
ered to be a natural number. For d = 3 we can get the exact canonical
form for B(p, 3) by unfolding the recursion along p and knowing that
B(p, 2) = log(p) + 1:

p
B(p, d) = B(1, d) + (1 + log(k))
k=2

p
= 4 + (p 1) + log k .
k=2
By using the inequality between the geometric and

p arithmetic mean
p 1
k=2 k
of a series of positive numbers ( k=2 k) p1 p1 , we get:
p
k=2 k
B(p, d) 4 + (p 1) + (p 1) log
p1

p+2
4 + (p 1) + (p 1) log
2
4 + (p 1) log(p + 2).
The following inequality holds:
4 + (p 1) log(p + 2) 4 + p log(p),
where p 2. This concludes our proof.
For our main divide and conquer algorithm we define the running
time with the following function:

2 T ( n2 , d) + Tc (n, d 1) + O(n) if n > 2
T(n, d) =
2d if n = 2
Theorem 3.8 The complexity of Algorithm 3.5 using as base case

Algorithm 3.6 is O(n log(n)d2 log log(n)).
Proof. The proof is similar to the proof of Theorem 3.7.

The space usage of Algorithm 3.6 is defined by the recursion:

max {S( n2 , d), S(n, d 1)} + n if n > 2 and d > 2
S(n, d) = 2d if n = 2

n log log(n) + 2n if d = 2
One can show with induction on d that S(n, d) = nd+nlog log(n).

The space usage analysis of the main multidimensional divide and
conquer Algorithm 3.5 is the same as for Algorithm 3.6.
Theorem 3.9 The space usage of the Algorithm 3.5 is in O(n d +

n log log(n)).
3.4 Semi-Dynamic Set of Maxima
In this section we briefly summarize some minor results related to the

semi-dynamic set of maxima problem. The problem is to maintain the
set of maxima P L of points in d-dimensional space under point in-
sertions. When a new point p is processed one has to check whether
it is dominated or not by one of the maxima points in P L. If it is
not dominated then p has to be inserted and the points that are domi-
nated by p have to be deleted from the data structure maintaining P L.
The motivation for this problem is the SPEA evolutionary algorithm,
where new individuals are compared against the maxima set and the
parent individuals for producing the new individuals are chosen from
the current maxima set.
The fully dynamic case, where deletions are also allowed, was
studied intensively for the two-dimensional space. Overmars and
Van Leeuwen presented a data structure which requires splitting and
merging balanced trees when points are inserted and deleted [66].
Their scheme has O(log2 (n)) update time. Frederickson and Rodger
[40] and Janardan [49] have designed dynamic data structures which
maintain the two-dimensional staircase structure of the set of maxima
that allow insertions in O(log(n)) time and deletions in O(log2 (n))
time. The storage needed by their scheme is O(n). In [56] Kapoor
improves on the previous scheme by allowing deletions in O(log(n))
time. The presentation and proof of this result is overcomplicated
and very hard to read. All these previous results were for the two-
dimensional space and the data structure stores all the points and not
only the maximal ones. For our particular application only the maxi-
mal points are needed and they have to be maintained under insertions
only. In [56] an extension to d-dimensional space is mentioned as
well, however the two-dimensional base case is hard to implement.
In this section we present an easy to understand and to implement
semi-dynamic data structure that maintains the set of maxima in d-
dimensional space with an update time of O(logd1 (n)). The update
time of our approach meets the one of Kapoors in [56]. Our result
doesnt bring any asymptotic improvement over the existing ones, it
offers however an easy to understand and to implement alternative
solution.
Our data structure is a multilevel binary search tree like the one
presented in Section 3.2.1 with some differences at the d 2th level.
3.4. Semi-Dynamic Set of Maxima 71
qd
left sibling nodes
right sibling nodes
dth coordinate
Figure 3.4.1: Search path with its left and right sibling nodes.
At the d 2th level we are in two-dimensional space. In this level,

in the nodes of the trees we store besides the 2nd coordinate key, the
pair (min, max) representing the minimum respectively maximum
1st coordinate values of the points stored in the subtree rooted at
the node. Updating the multilevel binary search tree works in three
steps: dominance query, insertion and domination query. We define
as right sibling nodes of a search path the right child nodes of the path
nodes where the path continues to the left. Similarly we define the left
sibling nodes of a search path. In Figure 3.4.1 we show an example
for left and right sibling nodes.
Dominance query With a search in the multilevel tree we check

whether the new point p is dominated or not. We can do that by
searching in the first level tree for the key pd and along the search
path recurse to the 2nd level trees of the right sibling nodes. The
recursion stops at the d 2th level trees where we check if the maxi-
mum value of a pair (min, max) stored in the active nodes is bigger
than the 1st coordinate of p. In case one of the recursions returns with
a positive answer the update process can stop because the new point
is dominated by another point. Hence, it is not a maximal point. If

from all recursions the answer was negative then the insertion step is
started.
Insertion The insertion follows the search path starting at the first
level tree and continuing recursively on the second level trees of the
nodes on this path. The recursion stops at the d2th level trees where
the new point is inserted and the (min, max) values on the search
path are updated if needed. On the way back from the recursion the
point is inserted also in the higher level trees. Rebalancing is done as
presented in [62].
Domination query After the insertion we have to delete the points

that are dominated by the newly inserted point p. To detect the dom-
inated points we do a search by continuing recursively to the lower
level trees of the left sibling nodes of the current level tree. The re-
cursion stops at the d 2th level trees. There, we check if the min-
imum value of the pair (min, max) of the left sibling nodes of the
search path is smaller than the 1st coordinate of p. If it is smaller
then there must be at least one point in the subtree rooted at this node
that is dominated by p and we can continue the search in this sub-
tree until the dominated points are found. The dominated points are
then deleted from the multilevel tree structure using standard deletion
techniques.
Space and Running Time Analysis The first two steps of the up-
date clearly take worst case O(logd1 (n)) time and the third step
takes amortized O(logd1 (n)) time. The storage overhead of the data
structure is O(n logd2 (n)).

In this chapter we presented two different deterministic algorithms
to solve the general d-dimensional layers-of-maxima problem. Both
algorithms have O(n logd2 (n) log log(n)) running time and are
an improvement over the previously known algorithm with running
time O(n logd1 (n)). Our space usage analysis shows that the
divide-and-conquer approach is more space efficient than the sweep
hyperplane approach. We also pointed out that the O(nlog(n)) algo-
rithm from [13] for the three-dimensional layers-of-maxima problem
cannot be integrated as is into the divide-and-conquer approach.
One of the major open problems is whether there is a determinis-
tic algorithm with running time O(n logd2 (n)) matching the best
known deterministic algorithm for the related set of maxima prob-
lem. As far as we know there is no better lower bound for the set of
maxima problem than (n log(n)) in the d dimensional space [89].
Since the set of maxima is a subproblem of the layers-of-maxima
problem this lower bound applies to the layers-of-maxima problem
as well. The gap between this lower bound and the upper bound of
our algorithms is quite big. It would be interesting to tighten this
gap by proving some non-trivial lower bounds for the d-dimensional
layers-of-maxima problem.
Chapter 4
OVSF Code Assignment
4.1 Introduction
In this chapter we focus on a specific aspect of the air interface Wide-
band Code Division Multiple Access (W-CDMA) of UMTS networks
that turns out to be algorithmically interesting. More precisely, we
focus on its multiple access method Direct Sequence Code Division
Multiple Access (DS-CDMA). The purpose of this access method is
to enable all users in one cell to share the common resource, i.e. the
bandwidth. In DS-CDMA this is accomplished by a spreading and
scrambling operation. Here we are interested in the spreading op-
eration that spreads the signal and separates the transmissions from
the base-station to the different users. More precisely, we consider
spreading by Orthogonal Variable Spreading Factor (OVSF-) codes
[2, 47], which are used on the downlink (from the base station to the
user) and the dedicated channel (used for special signaling) of the up-
link (from user to base station). These codes are derived from a code
tree. The OVSF-code tree is a complete binary tree of height h that is
constructed in the following way: The root is labeled with the vector
(1), the left child of a node labeled a is labeled with (a, a), and the
right child with (a, a). Each user in one cell is assigned a different
OVSF-code. The key property that separates the signals sent to the
users is the mutual orthogonality of the users codes. All assigned
codes are mutually orthogonal if and only if there is at most one as-
signed code on each leaf-to-root path. In DS-CDMA users request
75
76 Chapter 4. OVSF Code Assignment
different data rates and get OVSF-codes of different levels. The data
rate is inversely proportional to the length of the code. In particular, it
is irrelevant which code on a level a user gets, as long as all assigned
codes are mutually orthogonal. We say that an assigned code in any
node in the tree blocks all codes in the subtree rooted at that node and
all codes on the path to the root, see Figure 4.1.1 for an illustration.
level bandwidth
(a)
3 8
(a,a) (a,-a)
2 4
height h
1 2
0 1
N leaves
assigned code blocked code
Figure 4.1.1: A code assignment and blocked codes.
As users connect to and disconnect from a given base station, i.e.

request and release codes, the code tree can get fragmented. It can
happen that a code request for a higher level cannot be served at all
because lower level codes block all codes on this level. For example,
in Figure 4.1.1 no code can be inserted on level two without reassign-
ing another code, even though there is enough available bandwidth.
This problem is known as code blocking or code-tree fragmentation
[60, 64]. One way of solving this problem is to reassign some codes in
the tree (more precisely, to assign different OVSF-codes of the same
level to some users in the cell). In Figure 4.1.2 some user requests a
code on level two, where all codes are blocked. Still, after reassigning
some of the already assigned codes as indicated by the dashed arrows,
the request can be served. Here and in many of the following figures
we only depict the relevant parts (subtrees) of the single code tree.
The process of reassigning codes necessarily induces signaling
overhead from the base station to the users whose codes change. This
overhead should be kept small. Therefore, a natural objective already
stated in [64, 71] is to serve all code requests as long as this is possi-
ble, while keeping the number of reassignments as small as possible.
As long as the total bandwidth of all simultaneously active code re-
quests does not exceed the total bandwidth, it is always possible to
serve them. The problem has been studied before with a focus on
level request for code on level 2

2
1
0
Figure 4.1.2: A code insertion on level 2 into a single code tree T ,

shown without the top levels.
simulations. In [64] the problem of reassigning the codes for a sin-

gle additional request is introduced. The Dynamic Code Assignment
(DCA) algorithm presented in [64] is claimed to be optimal. We prove
that this algorithm is not always optimal and analyze natural versions
of the underlying code assignment (CA) problem. Our intention is to
present a rigorous analysis of this problem.
4.1.1 Related Work

It was a paper by Minn and Siu [64] that originally drew our atten-
tion to this problem. The one-step offline code assignment problem
is defined together with an algorithm that is claimed to solve it op-
timally [64]. As we show in Section 4.3.1, this claim is not correct
(the argument contains errors). Many of the follow-up papers like
[6, 14, 16, 38, 39, 55, 71] acknowledge the original problem to be
solved by Minn and Siu and study some other aspects of it. Assarut et
al. [6] evaluate the performance of Minn and Sius DCA-algorithm,
and compare it to other schemes. Moreover, they propose a differ-
ent algorithm for a more restricted setting [5]. Others use additional
mechanisms like time multiplexing or code sharing on top of the
original problem setting in order to mitigate the code blocking prob-
lem [14, 71]. A different direction is to use a heuristic approach that
solves the problem for small input instances [14]. Kam, Minn and Siu
[55] address the problem in the context of bursty traffic and different
Quality of Service (QoS). They come up with a notion of fairness
and also propose to use multiplexing. Priority based schemes for dif-
ferent QoS classes can be found in [17], similar in perspective are
[38, 39].
Fantacci and Nannicini [33] are among the first to express the
problem in its online version, although they have quite a different

focus. They present a scheme that is similar to the compact repre-
sentation scheme in Section 4.4, without focusing on the number of
reassignments. Rouskas and Skoutas [71] propose a greedy online-
algorithm that minimizes, in each step, the number of additionally
blocked codes, and provide simulation results but no analysis. Chen
and Chen [15] propose a best-fit least-recently used approach, also
without analysis.

We consider the combinatorial problem of assigning codes to users.
The codes are the nodes of an (OVSF-) code tree T = (V, E). Here
T is a complete binary tree of height h. The set of all users using a
code at a given moment in time can be modelled by a request vector
r = (r0 . . . rh ) Nh+1 , where ri is the number of users requesting a
code on level i (with bandwidth 2i ). The levels of the tree are counted
from the leaves to the root starting at level 0. The level of node v is
denoted by l(v).
Each request is assigned to a position (node) in the tree, such that
for all levels i {0 . . . h} there are exactly ri codes on level i. More-
over, on every path pj from a leaf j to the root there is at most one
code assigned. We call every set of positions F V in the tree T that
fulfills these properties a code assignment. For ease of presentation
we denote the set of codes by F . Throughout this chapter, a code tree
is the tree together with a code assignment F . If a user connects to
the base station, the resulting additional request for a code represents
a code insertion (on a given level). If some user disconnects, this rep-
resents a deletion (at a given position). A new request is dropped if it
cannot be served. This is the case if its acceptance would exceed the
total bandwidth. By N we denote the number of leaves of T and by
n the number of assigned codes n = |F | N . After an insertion on
level lt at time t, any CA-algorithm must change the code assignment
Ft into Ft+1 for the new request vector r = (r0 , . . . , rlt +1, . . . , rh ).
The size |Ft+1 \ Ft | corresponds to the number of reassignments.
This implies that for an insertion, the new assignment is counted as
a reassignment. We define the number of reassignments as the cost
function. Deletions are not considered in the cost function, as they
are charged to the insertions. We can do that without any asymptotic
overhead since every code can be deleted at most once. When we

want to emphasize the combinatorial side of the problem we call a
reassignment a movement of a code.
We state the original CA problem studied by Minn and Siu to-
gether with some of its natural variants:
one-step offline CA Given a code assignment F for a request vec-

tor r in an OVSF code tree T and a code request for level l.
Find a code assignment F for the new request vector r =
(r0 , . . . , rl + 1, . . . , rh ) with minimum number of reassign-
ments.
general offline CA Given a sequence S of code insertions and dele-

tions of length m. Find a sequence of code assignments in an
OVSF code tree T such that the total number of reassignments
is minimum, assuming the initial code tree is empty.
online CA The code insertion and deletion requests are served as

they arrive without knowledge of the future requests. The cost
function is again the total number of reassignments over the
whole request sequence.
insertion-only online CA This is the online CA with insertions only.

The results presented in this chapter and Chapter 5 are joint work
with T. Erlebach, R. Jacob, M. Mihalak, M. Nunkesser and P. Wid-
mayer. It is not always easy to divide the work done together and
we dont want to loose in readability by leaving out some of the rel-
evant results. However, a partitioning of the results is still necessary
for clarity and the results contributed by the coauthors are attributed
to their names. Some of the results were found as joint investigation
from all authors and hence we do not attribute them to a particular
person. The partitioning of the results in these two chapters was done
in agreement with the coauthors. An extended abstract of these re-
sults was presented in [29] and [28] and will appear also in the thesis
of: M. Nunkesser and M. Mihalak.
The main contributions of the author of this thesis to the OVSF
code assignment problem are the following: We give a counterexam-
ple to the optimality of the DCA-algorithm in Section 4.3.1. In Sec-

tion 4.3.3 we give a dynamic programming algorithm that solves the
problem with running time nO(h) , where n is the number of assigned
codes in the tree.
The N P-completeness result for the original problem stated by
Minn and Siu for a natural input encoding in Section 4.3.2 will appear
with the complete proof in the thesis of M. Nunkesser. The involved
analysis from Section 4.3.4 showing that a natural greedy algorithm
already mentioned in [64] achieves approximation ratio h will appear
in an extended version in the thesis of M. Mihalak.
We tackle the online-problem in Section 4.4. It is a more natu-
ral version of the problem, because we are interested in minimizing
the signaling overhead over a sequence of operations rather than for
a single operation only. We present a (h)-competitive algorithm
and show that the greedy strategy that minimizes the number of re-
assignments in every step is not better than (h)-competitive in the
worst case. The optimal online algorithm from Subsection 4.4.3 for
the insertion-only online CA problem is joint work with M. Mihalak.
We also give an online-algorithm with constant competitive ratio that
uses resource augmentation, where we give our code tree one more
level than the adversary; this is joint work with R. Jacob.
4.2. Properties of OVSF Code Assignment 81
4.2 Properties of OVSF Code Assignment

In this section we present important properties of the OVSF code as-
signment problem that are relevant for the understanding of the fol-
lowing sections.
4.2.1 Feasibility
One might ask him/her-self whether there exists always a feasible
code assignment for a new code request. To answer this question we
present here the necessary conditions to have a feasible code assign-
ment. In the later sections we always consider only cases where it is
possible to have a feasible assignment.
Given an assignment F of n codes in an OSVF code tree T ac-
cording to the request vector r = (r0 , . . . , rh ) and a new code re-
quest on level li , we examine the existence of a code assignment F
for the request vector r = (r0 , . . . , rli + 1, . . . , rh ). Every assigned
code on level l has its unique path from the root to a node of length
h l. The path can be encoded by a word w {0, 1}hl . The
bits in the encoding determine whether the path follows the left or
right child at a certain level in the tree (left encoded with 0 and right
with 1). The orthogonality properties required by the code assign-
ment make the path/node identifiers to form a binary prefix free code
set. On the other hand, given a prefix free code set with code lengths
{hl1 , . . . , hln+1 } (where li is the level of code i {1, . . . , n+1})
we can clearly assign codes on levels li by following the paths de-
scribed by the code words (see Figure 4.2.1). This shows that a
code assignment F for codes on levels l1 , . . . , ln+1 exists if and
only if there exists a binary prefix free code set of given code lengths
{h l1 , . . . , h ln+1 }.
We use the Kraft-McMillan inequality to check the existence of a
prefix free code set of given code lengths.
Theorem 4.1 [1] A binary prefix free code set having code lengths
a1 , . . . , am exists if and only if

m
2ai 1. (4.2.1)
i=1
0 1
0 1
0 1
0 1 0 01 1
11
0 11
0 01 1
00
0 1 0 0 0
0
1 1
0 1
0
0 1 0 1 0 1 0 1 0
011 101
1 0 1 0
110
1 0 1
01 01 01 010100 1
001 10
0 1 01 01
Figure 4.2.1: Correspondence of code assignments in tree of height
4 with codes on levels {0,1,1,1,2} and prefix free codes of lengths
{4,3,3,3,2}
If we multiply Equation (4.2.1) by 2h and we consider the num-

ber of codes rli that are requested on level li we get the following
corollary.
Corollary 4.2 Given an OVSF code tree T of height h with N = 2h

leaves and a request vector r = (r0 , . . . , rh ) a feasible code assign-
ment exists if and only if

h
ri 2i N .
i=0
Corollary 4.2 shows that checking the existence of a feasible code

assignment given the request vector can be done in linear time.
4.2.2 Irrelevance of Higher Level Codes

We show that an optimal algorithm for the one-step CA problem
moves only codes on levels lower than the requested level lr . A sim-
ilar result was already given in [64]. In [64] the authors mention
that the optimal algorithm doesnt move codes on higher levels than
the requested level, but they fail to give an accurate proof. Here we
present a more formal statement together with an accurate proof.
Lemma 4.3 Let c be an insertion on level lr into a code tree T . Then

for every code reassignment F that inserts c and that moves a code
F \ F
F \ F
Tx Ty
xR
S R
S
cS
R
Figure 4.2.2: Non-optimality of a code assignment F that reassigns

codes also on higher levels than the requested level.
on level l lr there exists a code reassignment F that inserts c and

moves fewer codes, i.e., with |F \ F | < |F \ F |.
Proof. Let x F be the highest code that is reassigned by F on a

level above the level lr and let S denote the set of codes moved by
F into the subtree Tx rooted at node x. We denote by R the rest of
the codes that are moved by F (see Figure 4.2.2). The cost of F
is cost(F ) = |S| + |R|. The code reassignment F is defined as
follows: let y be the position where F moves the code x, then F
will move the codes in S into the subtree Ty rooted at y and leave the
code x in Tx and move the rest of the codes in R in the same way as
F . The cost of F is at least one less than the cost of F since it does
not move the code x. In the example from Figure 4.2.2 the cost of F
is 6 and the cost of F is 5.
4.2.3 Enforcing Arbitrary Configurations

In the case of the one-step offline CA problem it is not obvious that
initially the code tree can be in any feasible configuration. Our lower
bound example from Section 4.3.4 relies on a special initial code tree
configuration. Here we show that any optimal one-step algorithm A
can be forced to end up in a certain code assignment F of size n using
a polynomial (in n) sequence of code insertions and deletions. The
result also holds for algorithms that reassign codes only when it is
necessary, i.e. no reassignments are done after deletions and a code is
placed without any reassignments whenever this is possible.
The idea of the construction is to force the algorithm into a code

assignment with full capacity (the whole bandwidth is assigned) F ,
with F F , and then to delete the codes that are not present in
F . The construction starts with an originally empty code assignment
F0 . The following theorem states that algorithm A can be forced to
produce an arbitrary full capacity assignment F .
Theorem 4.4 Any one-step optimal algorithm A can be led to an ar-

bitrary full capacity assignment F with n assigned codes by a re-
quest sequence of length m < 3n .
Proof. The construction goes from the top levels towards the leaves:
for the current level l we insert codes in all positions that are not
blocked by codes on the levels above. Then all codes on level l that
are not in F are deleted and the construction proceeds recursively
to the lower levels until the assignment F is obtained. The number
of insertions used in this process is bounded from above by the total
number of nodes of a binary tree (not necessarily complete) that has
as leaves the code positions in F . Since the size of F is n we know
that the number of nodes in such a binary tree is at most 2n 1.
The number of deletions is the number of insertions minus the size of
F . In conclusion the total number of insertions and deletions used
to force algorithm A to produce the code assignment F is bounded
from above by 3n .
Now for arbitrary configurations we can state the following corol-

lary.
Corollary 4.5 Any one-step optimal algorithm A can be forced to

produce a code assignment F of size n in a code tree of height h by
using m < 4n h code insertions and deletions.
Proof. From Theorem 4.4 we know that algorithm A can be forced to

produce a full capacity assignment F of size n using a sequence of
at most 3n code insertions and deletions. We are interested in the full
capacity assignment F that is a superset of F and has the minimal
number of additional codes that are not in F . Each code in F causes
at most h additional codes to fill the gaps in F to get the full capacity
assignment F . This means the size of F is bounded from above
by n h and can be constructed using at most 3n h insertions and
deletions. From F to get to F we have to delete at most n h codes.

Altogether we need at most 4n h code insertions and deletions.
4.3 One-Step Offline CA

4.3.1 Non-Optimality of Greedy Algorithms
The one-step offline CA problem was first presented in [64] and a cer-
tain greedy algorithm, called DCA, was claimed to solve the problem
optimally. Here we analyze a more general class of greedy algorithms
(that includes as a special case the algorithm DCA) for the one-step
offline CA problem and prove their non-optimality.
A straight-forward greedy approach is to select for a code inser-
tion a subtree with minimum cost that is not blocked by a code above
the requested level, according to some cost function. All codes in the
selected subtree must then be reassigned. So in every step a top-down
greedy algorithm chooses the maximum bandwidth code that has to
be reassigned, places it at the root of a minimum cost subtree, takes
out the codes in that subtree and proceeds recursively. The DCA-
algorithm in [64] works in this way. In [64] the authors propose dif-
ferent cost functions, among which the topology search cost func-
tion is claimed to solve the one-step offline CA optimally. Here we
show the following theorem:
Theorem 4.6 Any top-down greedy algorithm Atdg depending only

on the current assignment of the considered subtree is not optimal.
As all proposed cost functions in [64] depend only on the current

assignment of the considered subtree, this theorem implies the non-
optimality of the DCA-algorithm.
Proof. Our construction considers the subtrees in Figure 4.3.1 and
the assignment of a new code to the root of the tree T0 . The rest of
the subtrees that are not shown are supposed to be fully assigned with
codes on the leaf level, so that no optimal algorithm would consider
to move codes into those subtrees. The tree T0 has a code with band-
width 2k on level l and depending on the cost function has or does
not have a code with bandwidth k on level l 1. The subtree T1
contains k 1 codes at leaf level and the rest of the subtree is empty.
The subtrees T2 and T3 contain k codes at leaf level interleaved with
k free leaves. From Corollary 4.5 we know that any optimal one step
algorithm can be forced to produce such an assignment. This original
assignment rules out all cost functions that do not put the initial code
at the root of T0 . We are left with two cases:
4.3. One-Step Offline CA 87
level T0 OPT
DCA
1
1
T1 1 T2 T3
l 2k 1
l-1 k
k
1 k-1,k+1
0 ... ...
k/2
k-1
Figure 4.3.1: Example for the proof of Theorem 4.6.
case 1: The cost function evaluates T2 and T3 as cheaper than T1 .

In this case we let the subtree T0 contain only the code with
bandwidth 2k. Algorithm Atdg reassigns the code with band-
width 2k to the root of the subtree T2 or T3 , which causes one
more reassignment than assigning it to the root of T1 , hence the
algorithm fails to produce the optimal solution.
case 2: The cost function evaluates T1 as cheaper than T2 and T3 . In
this case we let the subtree T0 have both codes. Atdg moves
the code with bandwidth 2k to the root of T1 and the code with
bandwidth k into the tree T2 or T3 , see solid lines in Figure
4.3.1. The number of reassigned codes is 3k/2 + 2. But the
minimum number of reassignments is k + 3, achieved when
the code with bandwidth k is moved in the empty part of T1
and the code with bandwidth 2k is moved to the root of T2 or
T3 , see dashed lines in Figure 4.3.1.
4.3.2 N P-Hardness
In this part we prove that the decision variant of the one-step offline
CA problem is N P-complete. The decision variant of the one-step
offline CA problem asks whether a new code request can be satis-
fied with at most cmax reassignments. The problem is obviously in
N P since one can guess an optimal solution and it can be checked
code request
for this level
triplet receiver
ll trees
trees trees
q
token tree
Figure 4.3.2: Initial code tree configuration for the reduction from a
3DM instance.
in polynomial time if it is feasible and if it has cost less than cmax .

We prove the N P-completeness by using a reduction from the three-
dimensional matching problem (3DM), known to be N P-complete,
that is defined in [42] as follows:
Problem 4.7 (3DM) Given a set M X Y Z, where X, Y

and Z are disjoint sets having the same number q of elements. Does
M contain a matching, i.e., a subset M M such that |M | = q
and no two elements of M agree in any coordinate?
To transform an 3DM instance into a code assignment instance we

first index the elements of the ground sets X, Y, Z from 1 to q. Next
we introduce the indicator vector of a triplet (xi , yj , zk ) as a zero-one
vector of length 3q that is all zero except at the indices i, q + j and
2q+k. The idea of the reduction is to use the indicator vectors instead
of the triplets and to observe that the problem 3DM is equivalent to
finding a subset of q indicator vectors that represent triplets in M such
that their sum is the all-one vector.
A 3DM instance is transformed into an initial feasible assignment
using the code tree from Figure 4.3.2. The initial assignment consists
of a token tree having q codes that are forced by a new code assign-
ment into the root of this tree to move into the roots of the triplet trees.
The codes from the triplet trees are reassigned into the receiver trees.
The fill trees complete the code tree. The choice of the q triplet trees
where the codes from the token tree are moved reflects the choice of
the corresponding triplets of a matching. The codes from the triplet
trees find place in the receiver trees without additional reassignments
if and only if their triplet trees represent a three-dimensional match-
ing.
(a) The zero tree. (b) The one-tree.
(c) A layer, consisting of a one-tree and its (d) Stacking lay-

sibling. ers.
Figure 4.3.3: Encoding of zero and one.
The codes in the token tree are positioned arbitrarily on level

lstart . The triplet trees are constructed from the indicator vectors and
have their roots on the same level lstart . For each of the 3q positions
of the indicator vector a triplet tree has four levels together called
a layer that encode either zero or one. We show this encoding in
Figure 4.3.3 (a) and (b). Even though the zero and one encoding sub-
trees in a certain layer contain the same number of codes and occupy
the same bandwidth they are still different. Figures 4.3.3 (c) and (d)
show how layers are stacked using sibling trees.
The receiver trees are supposed to receive all codes in the chosen
triplet trees. These codes fit exactly in the free positions, if and only
if the chosen triplets form a 3DM, i.e. if their indicator vectors sum
up to the all-one vector. The fill trees are trees that are completely full
and have one more code than the receiver trees. They fill up the level
lstart in the sibling-tree of the token tree.
An interesting question is whether this transformation from 3DM
to the one-step offline CA can be done in polynomial time. This de-
pends on the input encoding of our problem. To us, two encodings
seem natural:
a zero-one vector that specifies for every node of the tree if

there is a code or not,
a sparse representation of the tree, consisting only of the posi-
tions of the assigned codes.
The transformation cannot be done in polynomial time for the first

input encoding, because then the generated tree would have exponen-
tially many leaves (exponential in q). For the second input encoding
the transformation is polynomial, because the total number of gen-
erated codes is polynomial in q, which is polynomial in the input
size of 3DM. Another indication that we should rather not expect an
N P-completeness proof for the first input encoding, is the exact al-
gorithm from Section 4.3.3 that would suggest nO(log n) -algorithms
for all problems in N P.
We now state the crucial property of the construction in a lemma:
Lemma 4.8 Let M be an input for 3DM and the transformation

described above. Then M 3DM if and only if (M ) can be done
with = 21q 2 + 2q + 1 reassignments.
The proof of Lemma 4.8 is based on counting arguments that be-

come obvious from examining the code tree configuration used for
the reduction. It can be found in [28] and will appear also in M.
Nunkessers thesis. We conclude this section with the following the-
orem:
Theorem 4.9 The decision variant of the one-step offline CA is N P-

complete for an input given by a list of positions of the assigned codes
and the code insertion level.
4.3.3 Exact nO(h) Algorithm

In this section we solve the one-step offline CA problem optimally
using a dynamic programming approach. The key idea of the result-
ing algorithm is to store the right information in the nodes of the tree
and to build it up in a bottom-up fashion.
We define the signature of a subtree Tv with root v to be an
l(v) + 1-dimensional vector sv = (sv0 , . . . , svl(v) ), in which svi is the
number of codes in Tv on level i. An example with code assignment
and node signatures is shown in Figure 4.3.4. A signature s is feasible
if there exists a subtree Tv with a code assignment that has signature
s. For every node v of the code tree we build a table in which all pos-
sible feasible signatures of an arbitrary tree of height l(v) are stored
(2, 1, 1, 0)
(2, 1, 0) (0, 0, 1)
(0, 1) (2, 0) (0, 0) (0, 0)
(0) (0) (1) (1) (0) (0) (0) (0)
Figure 4.3.4: Node signatures.
together with their cost for Tv . The cost of a possible signature s for
Tv (usually s is different from the original signature sv of T v ) is de-
fined as the minimum number of codes in Tv that have to move away
from their old position in order to attain a tree Tv with signature s.
To attain Tv it might be necessary to move codes into Tv from other
subtrees but we do not count these movements in the cost of s for Tv .
Given a code tree T with all these tables computed, one can com-
pute the cost of any single code insertion on level l from the table at
the root node r: Let sr = (sr0 , . . . , srh ) be the signature of the whole
code tree before insertion, then the cost of the insertion is the cost of
the signature (sr0 , . . . , srl + 1, . . . , srh ) in this table plus one (for the
original assignment).
The computation of the tables starts at the leaf level, where the
cost of the one-dimensional signatures is trivially defined. At any
node v of level l(v) the cost c(v, s) of signature s for Tv is computed
from the cost incurred in the nodes left subtree Tl plus the cost in-
curred in its right subtree Tr plus the cost at v. The costs c(l, s ) and
c(r, s ) in the subtrees come from two feasible signatures with the
property s = (s0 + s0 , . . . , sl(v)1 + sl(v)1 , sl(v) ). We use the no-
tation s = (s + s , sl(v) ) to represent the composition of signature s
using the lower level signatures s and s . Any pair s , s of such sig-
natures corresponds to a possible configuration after the code inser-
tion. The best pair for node v gives c(v, s). Let sv = (sv0 , . . . , svl(v) )
be the signature of Tv and s , s are chosen such that s = (s + s , 0),
then the following holds:

c(l, (0, . . . , 0)) + c(r, (0, . . . , 0)), sl(v) = 1
c(v, s) = mins ,s {c(l, s ) + c(r, s )}, sl(v) = 0, svl(v) = 0

1, sl(v) = 0, svl(v) = 1.
The costs of all signatures s for v can be calculated simultane-

ously by combining the two tables in the left and right children of v.
For the running time observe that the number of feasible signatures is
bounded by (n + 1)h because there cannot be more than n codes on
any level. The time to combine two tables is O(n2h ), thus the total
running time is bounded by O(2h n2h ).
Theorem 4.10 The one-step offline CA can be optimally solved in

time O(2h n2h ) and space O(h nh ).
4.3.4 h-Approximation Algorithm

In this section we analyze a natural greedy algorithm for the one-step
offline CA problem. The algorithm assigns the new code c0 to the
root of a subtree Tg at level l(c0 ) that contains the minimum number
of assigned codes between all subtrees available at this level. By
the availability of a subtree at level l we mean that it is not blocked
from above and the root of the subtree is free. We are interested only
in these trees because we know from Lemma 4.3 that no codes are
assigned into subtrees that are blocked by levels above the level of the
code. The codes from Tg are reassigned in a top-down fashion starting
with the highest level codes and continuing recursively with the lower
levels until no more codes have to be reassigned. The pseudocode of
the algorithm Agreedy is presented in Algorithm 4.11, where (Tgt )
represents the assigned codes in the subtree Tg at time t.
At every iteration step t algorithm Agreedy keeps track of the set
Ct of codes that have to be reassigned into the current tree T t . Ini-
tially, C0 = {c0 } and T 0 = T .
In [64] a similar algorithm was presented as a heuristic for the
one-step offline CA but without mentioning theoretical bounds on its
approximation ratio. We prove that Agreedy has approximation ratio
h and this bound is asymptotically tight.
Algorithm 4.11 Greedy algorithm Agreedy

begin
1: C0 {c0 }; T 0 T
2: t 0
3: while Ct = do
4: ct element with highest level in Ct
5: g the root of a subtree Tgt of level l(ct ) with
the fewest codes in it and no code on or above its root
6: /* assign ct to position g */
7: T t+1 (T t \ (Tgt )) {g}
8: Ct+1 (Ct (Tgt )) \ {ct }
9: tt+1
10: end while
end Agreedy
First we show that Agreedy can be forced to use (h) OP T

reassignments (see Figure 4.3.5), where OP T refers to the number
of reassignments an optimal algorithm needs. A new code c0 is as-
signed by Agreedy to the root of Tg (which contains the least number
of codes). The two codes on level l 1 from Tg are reassigned as
shown in Figure 4.3.5, one code can be reassigned into Topt and the
other one goes recursively into T1 . In total, Agreedy does 2 l + 1
reassignments while the optimal algorithm assigns c0 into the root of
Topt and reassigns the three codes from the leaf level into the trees
T1 , T2 , T3 , requiring only 4 reassignments. Obviously, for this exam-
ple Agreedy is not better than (2l + 1)/4 times the optimal. In general
l can be (h).
To show the upper bound we compare the code movements of the
greedy algorithm Agreedy to the code movements of an optimal algo-
rithm Aopt . The optimal algorithm Aopt assigns the new code c0 into
the root of the subtree Tx0 and the codes from this subtree are moved
to other subtrees. We call the subtrees in the root of which Aopt re-
assigns the codes opt-trees and we denote the set of these subtrees by
Topt . By V (Topt ) we denote the set of nodes in Topt . The opt-arcs are
the pairs (u, v) of source-destination nodes describing the code move-
ments of Aopt . Figure 4.3.6 shows an example instance together with
the code movements done by Agreedy and an optimal algorithm Aopt .
Topt
...
T3
T2
T1
Agreedy Aopt
Tg
l1
l2
l3
l4
c0
0
l
Figure 4.3.5: Lower bound example for Agreedy .

c0
g
x0
an opt-arc greedy assignment
Figure 4.3.6: Greedy against optimal code reassignments, an exam-

ple.
Our proof works as follows: we show that in every step t of al-

gorithm Agreedy there is the possibility to assign the codes in Ct to
positions inside the opt-trees. We express this possibility with a code
mapping t : Ct V (Topt ). The main property of the greedy algo-
rithm is that in every step t it is possible to complete the assignment
of the codes in Ct by using t to move them into the opt-trees and
the opt-arcs to move the codes from the opt-trees. The proof of The-
orem 4.16 shows that this property ensures that Agreedy is not worse
than O(h) OP T .
To make the proof technically precise we introduce the following
definitions. In the process of the algorithm some opt-arcs have to be
changed in order to ensure the existence of t . These changed opt-
arcs are represented by the t -arcs.
Definition 4.12 Let Topt be the set of the opt-trees for a code inser-
tion c0 and let T t (together with its code assignment F t ) be the code
tree after t steps of the algorithm Agreedy . An -mapping at time t
is a mapping t : Mt V (Topt ) for some Mt F t , such that
v Mt : l(v) = l((v)) and t (Mt ) (F t \ Mt ) is a code
assignment.
The set t (Mt ) (F t \ Mt ) represents the resulting code assign-

ment after the reassignment of the codes Mt F t by t .
Definition 4.13 Let T t be a code tree, x, y be positions in T t and

t be an -mapping. We say that y depends on x in T t and t , if
there is a path from x to y using only tree-edges from a parent to a
child and t -arcs. By dept (x) we denote the set of all positions y that
depend on x in T t and t . We say that an t arc (u, v) depends on x
if u dept (x).
x
t
t t
t
t
Figure 4.3.7: Dependency set of x (grayed subtrees).
In Figure 4.3.7 we show the dependency set dept (x) of a code x.
Definition 4.14 At time t a pair (t , t ) of a code mapping t :

Ct V (Topt ) and an -mapping t is called an independent map-
ping for T t , if the following properties hold:
1. c Ct the levels of t (c) and c are the same (i.e. l(c) =

l(t (c)).
2. c Ct there is no code in T t at or above the roots of the trees

in dept (t (c)).
3. the code movements realized by t and t (i.e. the set t (Ct )

t (Mt ) (F t \ Mt )) form a code assignment.
4. all nodes in the domain Mt of t are in dept (t (Ct )) (i.e., no

unnecessary arcs are in t ).
Here for t and t we used their representation as an arc which is

equivalent to the function representation. We abused the notation for
the dependency set of a node and we extended itto the dependency
set of a node set: dept (t (Ct )) stands for the set cCt dept (t (c)).
From these definitions we can draw the following observations: For
two independent positions u, v T and for an independent mapping
(t , t ) we have dept (u) dept (v) = , i.e. the t -arcs of indepen-
dent positions point into disjoint subtrees. If we have an independent
mapping (t , t ) for T t , then dept (t (Ct )) is contained in opt-trees
and every node in dept (t (Ct )) can be reached through exactly one
path from Ct (using one t -arc and an arbitrary sequence of tree-

arcs, which always go from parent to child, and t -arcs from a code
c (T t ) to t (c)).
We now state an important invariant of the greedy algorithm.
Lemma 4.15 For every set Ct and code tree T t in algorithm Agreedy
there exists an independent mapping (t , t ).
Proof. The proof is done by induction on t and shows how to con-

struct an independent mapping (t+1 , t+1 ) from (t , t ) by case
analysis. The detailed proof can be found in [28] and will be included
in the thesis of M. Mihalak.
Lemma 4.15 actually applies to all algorithms that work level-wise
top-down and choose a subtree Tgt for each code ct Ct arbitrarily
with the condition that there is no code on or above the node g.
The cost of the optimal algorithm can be expressed in two ways:
(a) it is equal to the number of assigned codes in the opt-trees plus
one; (b) it is equal to the number of opt-trees. In the following theo-
rem we state the approximation ratio of the greedy algorithm.
Theorem 4.16 The algorithm Agreedy has approximation ratio h.
Proof. Since algorithm Agreedy works level-wise top-down all we

have to show is that when it reassigns the codes on level l it incurs a
cost of at most OP T . Consider the step t of Agreedy when the first
code on level l from Ct has to be assigned and let there be ql codes
of level l in Ct . We know from Lemma 4.3 and the fact that Agreedy
works level-wise top-down that in later steps there will be no other
codes of level l added to Ct+i . The greedy algorithm assigns all ql
codes of level l into subtrees of T t having the minimum number of
assigned codes. From Lemma 4.15 we know that there is an indepen-
dent mapping (t , t ), and hence t maps the level l codes from Ct
into different independent positions in the opt-trees. Therefore, the
cost of the t mapping restricted to the level l codes from Ct is upper
bounded by OP T (total cost of Aopt ) and is at least the cost incurred
by the greedy assignment of the ql codes on level l from Ct . Hence,
on every level the greedy algorithm Agreedy incurs a cost (number of
codes that are moved away from their position in the tree) that is at
most Aopt s total cost.
costA N 0 N/4 + 1
A ...
ins : N at 0 del : N/2 at 0 ins : 1 at h 1 del : N/4 at 0
...
Aopt
costopt N 0 1
Figure 4.4.1: Lower bound for the online CA problem.
4.4 Online CA
A practically more relevant version of the code assignment problem is
where several code insertions and deletions have to be satisfied in an
online fashion. In this section we give a lower bound on the competi-
tive ratio of any deterministic online algorithm, analyze several online
strategies and present a resource augmented algorithm with constant
competitive ratio.
Theorem 4.17 No deterministic algorithm A for the online CA prob-

lem can be better than 1.5-competitive.
Proof. Let A be any deterministic algorithm for the problem. First the
adversary asks for N leaf insertions. The adversary Aopt makes the
insertions in such a way that later on it needs no additional reassign-
ments. In the next step the adversary deletes N/2 codes (every sec-
ond from the assignment produced by A) to get the situation in Figure
4.4.1. Then a code request on level h 1 causes algorithm A to move
N/4 codes. We can proceed with the left subtree of fully assigned leaf
level codes recursively and repeat this process h1 times. Thus, Aopt
needs N + h 1 code assignments. Algorithm A needs N + T (N )
code assignments, where T (N ) = 1 + N/4 + T (N/2) and T (2) = 0.
After reducing the recursive formula we get the following canonical
form: T (N ) = h 1 + N2 (1 2/N ). For costA c costOP T we
must have c 3N/2+h2
N +h1 N 3/2.
4.4. Online CA 99
4.4.1 Compact Representation Algorithm

The compact representation online strategy maintains the codes in the
code tree T sorted by level from left to right (higher level codes are
always to the right of lower level ones) and compact to the left on the
same level. For a given node/code v T we denote by l(v) its level
and by w(v) its prefix free path encoding (see Section 4.2). We use
the lexicographic ordering when comparing two nodes given by their
path encoding. With U we denote the set of unblocked nodes of the
tree. The compact representation algorithm maintains the following
invariants:
Invariant 4.18 codes u, v F : l(u) < l(v) = w(u) < w(v).
Invariant 4.19 nodes u, v T : l(u) l(v) u F v U =

w(u) < w(v).
In what follows we show that this algorithm is not worse than

O(h) times the optimum offline algorithm that knows the sequence
of requests in advance. We also show an example for which the al-
gorithm is not asymptotically better than this bound, and hence it is
O(h)-competitive.
Theorem 4.20 Algorithm Acompact satisfying the Invariants 4.18

and 4.19 performs at most h code reassignments per insertion and
deletion.
Proof. When a request for inserting a code on level l is processed

by the algorithm it can happen that there is no free space in the com-
pact space allocated for this level. In this case a code from the right
hand side neighboring level is moved to make space for the new code
and is recursively inserted on its own level. In the worst case the
algorithm has to reassign one code per level to satisfy the insertion
request. When a code deletion request on level l is processed by the
algorithm it might happen that the Invariant 4.19 on the levels above
is violated. Hence, on these levels a code has to be moved from right
to left to fill in the gap produced by the deletion. In the worst case
this can also involve one reassignment per level. Since the number
of levels occupied with codes is bounded from above by h the com-
pact representation algorithm does at most h reassignments per code
insertion/deletion request.
Figure 4.4.2: Code assignments for levels 0, 0, 1, 2, 3, 4, . . . , h 1

and four consecutive operations: 1. DELETE(h-1), 2. INSERT(0),
3. DELETE(0), 4. INSERT(h-1).
Corollary 4.21 Algorithm Acompact satisfying invariants (4.18) and

(4.19) is O(h)-competitive.
Proof. In the sequence = 1 , . . . , m the number of deletions d

must be smaller or equal to the number i of insertions, which implies
d m/2. The cost of any optimal algorithm is then at least i m/2.
On the other hand, Acompact incurs a cost of at most m h, which
implies that it is O(h)-competitive.
Theorem 4.22 Any algorithm AI satisfying invariant (4.18) is (h)-

competitive.
Proof. For the sequence of code insertions on levels 0, 0, 1, 2, 3, 4,

. . . , h 1 there is a unique code assignment that satisfies the invariant
(4.18), see Figure 4.4.2. Now if the adversary requests the deletion of
the code at level h1 and insertion of a code on level 0 then AI has to
move every code on level l 1 to the right to create space for the code
assignment on level 0 and maintain the invariant (4.18). This takes
h1 code reassignments. Then the adversary requests the deletion of
the third code on level zero and an insertion on level h 1. Again, to
maintain the invariant (4.18), AI has to move every code on level l
1 to the left. This takes again h 1 code reassignments. An optimal
algorithm can handle these four requests with two assignments, since
it can assign the third code on level zero in the right subtree, where
AI assigns the code on level h1. After repeating these four requests
k times, the total cost of the algorithm AI becomes costI = h + 1 +
k 2(h 1), whereas Aopt has costOP T = h + 1 + k 2. When k
goes to infinity, the ratio costA /costOP T becomes (h).
4.4. Online CA 101
Figure 4.4.3: Requests that a greedy strategy cannot handle effi-

ciently.
4.4.2 Greedy Online Strategies

An optimal deterministic algorithm Ag for the one-step offline CA
problem can be used as a greedy online strategy. As an optimal algo-
rithm breaks ties in an unspecified way, the online-strategy can vary
for different optimal one-step offline algorithms.
Theorem 4.23 Any deterministic greedy online-strategy, i.e. a strat-

egy that minimizes the number of reassignments for every insertion,
is (h) competitive.
Proof. Assume that Ag is a fixed, greedy online-strategy. First the

adversary asks for N/2 code insertions on level 1. As Ag is de-
terministic the adversary can now delete every second level-1 code,
and ask for inserting N/2 level-0 codes. This leads to the assign-
ment shown in Figure 4.4.3. Next the adversary deletes two codes at
level l = 1 (as Ag is deterministic it is clear which codes to delete)
and immediately asks for a code insertion on level l + 1. As it is one-
step optimal (and up to symmetry unique) the algorithm Ag reassigns
two codes as shown in the figure. The optimal adversary arranges
the level-1 codes in a way that it does not need any additional reas-
signments. The adversary repeats this sequence along level 1 in the
first round from left to right, then on level 2 in a second round, and
continues towards the root. Altogether the greedy algorithm moves
N/4 codes in the first round and assigns N/23 codes. In general, in
every round i the greedy strategy reassigns N/4 level-0 codes and
assigns N/2i+2 level-i codes. Altogether the greedy strategy needs
O(N ) + (N/4)(h) = (N h) reassignments, whereas the optimal
strategy needs only O(N ) assignments.
1
0 1
0
0
1 0
1
11 0
00 1 11
00
Figure 4.4.4: Reassignment of one code reduces the number of

blocked codes from 3 to 2.
4.4.3 Minimizing the Number of Blocked Codes

The code assignment strategy that keeps the number of blocked codes
minimal was mentioned and tested with simulations in [71]. However
no theoretical analysis about the competitiveness of the algorithm was
presented there. Here we give a precise, formal description of the
algorithm and analyze its competitiveness.
The algorithm satisfies the following invariant after every code
insertion or deletion request (with the precondition that the invariant
holds also initially):
Invariant 4.24 The number of blocked codes in T is minimum.
Figure 4.4.4 shows an initial code assignment that does not satisfy
the Invariant 4.24. In this example the invariant can be established by
moving one code.
We prove that this algorithm is equivalent to the algorithm that
minimizes the number of gap trees on every level.
Definition 4.25 A gap tree is a maximal subtree of unblocked codes.

The level of its root is the level of the gap tree. The vector q =
(q0 , . . . , qh ) is the gap vector of the tree T , where qi specifies the
number of gap trees on level i.
Figure 4.4.5 highlights the gap trees for an example code assignment.
The implication of Invariant 4.24 is that there can be at most one gap
tree on every level.
Lemma 4.26 Let F be a code assignment in the code tree T . Then F

blocks a minimum number of codes in T if and only if T has at most
one gap tree on every level.
4.4. Online CA 103
gap trees
q = (1, 2, 1, 0, 0)
Figure 4.4.5: Gap trees and gap vector of a code assignment.
Proof. First we prove that it is necessary to have at most one gap tree
on every level to minimize the number of blocked codes. If there are
two gap trees Tu , Tv on a level l then by moving the codes from the
sibling tree Tu of Tu into the gap tree Tv we create a gap tree at level
l + 1 rooted at the parent of u and hence we reduce the number of
blocked codes by one. This shows that having at most one gap tree
per level is a necessary condition to minimize the number of blocked
codes.
Next we prove the sufficiency of the condition. Suppose that F
leaves at most one gap tree on every level of T . The free bandwidth
capacity of T can be expressed as

h
cap = qi 2i .
i=0
Since qi {0, 1}, the gap vector is the binary representation of the
number cap. Therefore the gap vector q is the same unique vector for
all code assignments having at most one gap tree at every level and
serving the same requests as F . The gap vector determines also the
number of blocked codes:

h
# blocked codes =(2h+1 1) qi (2i+1 1).
i=0
Algorithm 4.27 Algorithm, Agap (op, l, c)

in: op - requested operation (insert/delete); l - level of the insertion;
c - code to be deleted;
parameter: T - code tree; q - gap vector of T ; h - height of T
begin
1: if op = insert then
2: assign new code into the smallest gap tree of level l
3: else
4: delete(c, T )
5: q = gapvector(T )
6: for (i = 0; i h; inc(i)) do
7: if qi > 1 then
8: reduce number of gap trees at level i by filling in one of
the gap trees with codes from the sibling of the other gap
tree
9: q = gapvector(T )
10: end if
11: end for
12: end if
end Agap
This shows that any code assignment having at most one gap tree per
level and serving the same requests as F has the same number of
blocked codes as F .
In Algorithm 4.27 we show the pseudo code of Agap .
Lemma 4.28 The algorithm Agap always has a gap tree of sufficient
height to assign a code on level l and satisfies the Invariant 4.24.
Proof. First we show that the algorithm Agap satisfies the Invari-
ant 4.24 by showing that the tree T after the algorithm returns has
at most one gap tree on every level. Consider an insertion into the
smallest gap tree of level l where the code fits. New gap trees can
occur only on levels j, l j < l and only within the gap tree on
level l . At most one new gap tree can occur on every level. Suppose
that after creating a gap tree on level j, we have more than one gap
trees on this level. Then, since j < l , we would assign the code into
this smaller gap tree, a contradiction (Figure 4.4.6). Therefore, after
4.4. Online CA 105
j j
l ...
Figure 4.4.6: Two gap trees on a lower level than l violate the mini-
mality of the chosen gap tree.
an insertion there is at most one gap tree on every level.

After a code deletion the nodes of the subtree of that code become
unblocked, i.e., they belong to some gap tree. At most one new gap
tree can occur after a delete operation (and some gap trees may disap-
pear). Thus, when the newly created gap tree is the second one on the
level, we fill the gap trees and then we iteratively handle the newly
created gap tree on a higher level. In this way the gap trees are moved
up. Because we cannot have two gap trees on level h 1, we end up
with a tree with at most one gap tree on each level.
From the precondition of the online CA problem we know that
there is sufficient capacity
to serve the request, i.e. cap 2l . We also
know that cap = i qi 2 and because qi {0, 1} for all i (q is the
i
unique binary representation of cap), there exists a gap tree on level

j l.
Algorithm Agap does not need any extra code movements after
insertions and hence is optimal when only code insertions are con-
sidered. However, when deletions are also allowed the algorithm is
(h)-competitive.
Theorem 4.29 Algorithm Agap is (h)-competitive.
Proof. The request sequence from the proof of Theorem 4.23 shows
the (h)-competitiveness of algorithm Agap .
4.4.4 Resource Augmented Online Algorithm
In this section we present an online-strategy called 2-gap that is al-

lowed to use twice the amount of resource the offline adversary is us-
ing. Resource augmented online strategies were introduced in 1995
by Kalyanasundaram and Pruhs [53] for scheduling problems. Later,
in 2000, it was presented as an online analysis technique in [54]. In a
resource-augmented competitive analysis one compares the value of
the solution found by the online algorithm when it is provided with
more resources to the value of the optimal offline adversary using the
original resources. In the case of the OVSF online code assignment
problem the resource is the total assignable bandwidth. The strategy
2-gap uses a tree T of bandwidth 2b to accommodate codes whose
total bandwidth is b. By the nature of the code assignment we cannot
add a smaller amount of additional resource, even though our online
strategy needs only 1.5 times the amount of the nominal bandwidth b.
Here we prove that 2-gap uses only an amortized constant number of
reassignments per insertion or deletion.
The algorithm 2-gap is similar to the compact representation al-
gorithm of Section 4.4.1 (where codes are ordered according to their
level, Invariant (4.18)), only that it allows for up to 2 gaps at each
level l (instead of only one for aligning), to the right of the assigned
codes on l. For inserting a code at level l the algorithm assigns it in
the leftmost gap on this level. If no such gap exists, the leftmost code
of the next higher level l + 1 is reassigned, creating 2 gaps on level l
(one of them is filled immediately by the new code). The algorithm
repeats this procedure towards the root until no more codes have to
be reassigned. An insertion is rejected if the nominal bandwidth b
is exceeded. For deleting a code c on level l the rightmost code on
level l is moved into the place of c, keeping all codes at level l left
of the gaps of l. If this results in 3 consecutive gaps, the rightmost
code on level l + 1 is reassigned, in effect replacing two gaps of l
by one of l + 1. The algorithm proceeds towards the root until no
level has more than two gaps. More precisely, for every level the al-
gorithm 2-gap keeps a range of codes (and gaps) that are assigned
to this level. In every range there can be at most 2 gaps. If there is
no space in the range for a new code or if there are too many gaps,
the boundary between two consecutive levels is moved, affecting two
places on the lower level and one on the upper level. This notion of
a range is in particular important for levels without codes. The levels
4.4. Online CA 107
close to the root are handled differently, to avoid an excessive space

usage. The root-code of T has bandwidth 2b and it is never used.
The bandwidth b code can only be used if no other code is used. The
b/2 codes are kept compactly to the right. In general there is some
unused bandwidth between the highest level l b/4 codes and the
b/2 codes. This unused bandwidth is considered as one gap on level l
only if the nominal capacity b would still allow a code on l, otherwise
it is not counted as a gap. For all other levels ( b/8 codes) we de-
fine a potential-function that is equal to the number of levels without
gaps together with the number of levels having 2 gaps. The reason
why we count these levels is because they can produce additional re-
assignments in case of an insertion or deletion. With this potential
function it is sufficient to charge two reassignments to every insertion
or deletion, one for placing the code (filling the gap), and one for the
potential function or for moving a b/4-bandwidth code. The initial
configuration is the empty tree, where the leaf-level has two gaps, and
all other levels have precisely one gap (only the close-to-root levels
are as described above).
We have to show that our algorithm manages to host codes as
long as the total bandwidth used does not exceed b. To do this, we
calculate the bandwidth wasted by gaps, which is at most 2( 8b + 16
b
+

) b/2. Hence the total bandwidth used in T is 3b/2 < 2b.
Theorem 4.30 Let be a sequence of m code insertions and dele-

tions for a code-tree of height h, such that at no time the bandwidth
is exceeded. Then the online-strategy 2-gap using a code-tree of
height h + 1 performs at most 2m + 1 code reassignments.
Corollary 4.31 The online strategy 2-gap for resource augmentation

by a factor of 2 is 4-competitive.
Proof. Any sequence of m operations contains at least m/2 insert

operations. Hence the optimal offline solution needs at least m/2 as-
signments, and the above resource augmented online-algorithm uses
at most 2m + 1 reassignments, leading to a competitive ratio of 4.
This approach might prove to be useful in practice, particularly if

the code insertions only use half the available bandwidth.
4.5 Discussions and Open Problems

In this chapter we brought an algorithmically interesting problem
from the mobile telecommunications field closer to the theoretical
computer science community. We analyzed several versions of the
problem, but our analysis does not close the OVSF code assignment
problem. Some interesting open problems remain unanswered:
Is there a constant approximation algorithm for the one-step

offline CA problem?
Can the gap between the lower bound of 1.5 and the upper
bound of O(h) for the competitive ratio of the online CA be
closed?
Our paper [29] on OVSF code assignment published in 2004 raised

two other open questions:
Is there an instance where the optimal general offline algorithm

has to reassign more than an amortized constant number of
codes per insertion or deletion?
What is the complexity of the general offline CA problem?
Since then these two questions were analyzed in [78] and lead to the
following results: the general offline CA problem is N P-complete
and there exist instances of code trees for which any optimal offline
greedy algorithm needs to reassign more than one code per an inser-
tion/deletion request. Whether there are instances where more than an
amortized constant number of reassignments are necessary remains
still open.
Chapter 5
Joint Base Station

Scheduling
5.1 Introduction
We consider different combinatorial aspects of problems arising in the
context of load balancing in time division networks. These problems
turn out to be related to interval scheduling problems and interval
graphs.
The general setting is that mobile phone users are served by a set
of base stations. For our considerations the user is the mobile device.
In each time slot (round) of the time division multiplexing each base
station serves at most one user. Traditionally, each user is assigned
to a single base station that serves the user until it leaves the cell of
the base station or until its demand is satisfied. The amount of data
that a user receives depends on the strength of the signal it receives
from its assigned base station and on the interference, i.e. all signal
power it receives from other base stations. In [21], Das et al. propose
a novel approach. In their approach clusters of base stations jointly
decide which users to be served in which round in order to increase
network performance. Intuitively, if in each round neighboring base
stations try to serve pairs of users such that the mutual interference
is low, this approach increases the throughput. We turn this approach
into a discrete scheduling problem in one and two dimensions (see
109
110 Chapter 5. Joint Base Station Scheduling
Figure 5.1.1), the Joint Base Station Scheduling (JBS) problem.

In one dimension (see Figure 5.1.1(a)) we are given a set of n
users as points {u1 , . . . , un } on a line and we are given positions
{b1 , . . . , bm } of m base stations. Note that such a setting could cor-
respond to a scenario where the base stations and users are located
along a straight road. In our model, when a base station bj serves
a user ui , this creates interference for other users in an interval of
length 2|bj ui | around the midpoint bj . In any round a base station
is allowed to serve a user only if in that round no other base station
has signal at that user. Hence, in each round each base station can
serve at most one user. The goal is to serve all users in as few rounds
as possible. In two dimensions users and base stations are represented
as points in the plane. When base station bj serves user ui this cre-
ates interference in a disk with radius bj ui 2 and center bj (see
Figure 5.1.1(c)).
The one-dimensional problem is closely related to interval schedul-
ing problems. The particular way how the interference phenomena
appears leads to directed intervals (arrows). For these, we allow their
tails to intersect (intersecting tails correspond to interference that does
not affect the users at the heads of the arrows). We present results on
this special interval scheduling problem. Similarly, the problem is
related to interval graphs, except that we have conflict graphs of ar-
rows together with the conflict rules defined by the interference (ar-
row graphs).
5.1.1 Related Work

Das et al. [21] propose an involved model for load balancing that
takes into account different fading effects and calculates the result-
ing signal to noise ratios at the users for different schedules. In each
round only a subset of all base stations is used in order to keep the in-
terference low. The decision on which base stations to use is taken by
a central authority. The search for this subset is formulated as a (non-
trivial) optimization problem that is solved by complete enumeration
and that assumes complete knowledge of the channel conditions. The
authors perform simulations on a hexagonal grid, propose other algo-
rithms, and reach the conclusion that the approach has the potential
to increase throughput.
There is a rich literature on interval scheduling and selection prob-
u1 b1 u 2 u 3 u 4 b2 u 5 b3 u6
(a) A possible situation in some time slot (round). Base sta-

tion b2 serves user u2 , b3 serves user u6 . Users u3 , u4 and
u5 are blocked and cannot be served. Base station b1 cannot
serve u1 because this would create interference at u2 .
u1 b1 u 2 u 3 u 4 b2 u 5 b3 u6
(b) Arrow representation of (a).
b4 u11
u7
b5 u12
u6
u1 u4 u8
b2 b3
u3
b1 u10
u2
u5 u9
(c) A possible situation in some time slot in the 2D

case. Users u2 , u4 , u7 and u12 are served. Base
station b5 cannot serve user u1 , because this would
create interference at u4 as indicated by the dashed
circle.
Figure 5.1.1: The JBS-problem in one and two dimensions.

lems (see [32, 73] and the references given therein for an overview).
Our problem is more similar to a setting with several machines where
one wants to minimize the number of machines required to schedule
all intervals. A version of this problem where intervals have to be
scheduled within given time windows is studied in [19]. Inapprox-
imability results for the variant with a discrete set of starting times
for each interval are presented in [18].

In this section we define the problems of interest. Throughout the pa-
per we use standard graph-theoretic terminology, see e.g. [87]. Our
model of computation is the real RAM machine. The operands in-
volved (positions on the line or in the plane) could be restricted also to
rational numbers, but to preserve the geometric properties of interval
and disk intersections we use real operands. In the one-dimensional
case we are given the set B = {b1 , . . . , bm } R of base station
positions and the set U = {u1 , . . . , un } R of user positions on
the line in left-to-right order. Conceptually, it is more convenient to
think of the interference region that is caused by some base station bj
serving a user ui as an interference arrow of length 2|bj ui | with
midpoint bj pointing to the user, as shown in Figure 5.1.1(b). The in-
terference arrow for the pair (ui , bj ) has its head at ui and its midpoint
at bj . We denote the set of all arrows resulting from pairs P U B
by A(P ). If it is clear from the context, we call the interference ar-
rows just arrows. If more than one user is scheduled in the same
round then they are allowed to get signal only from their serving base
stations, that is, no interference coming from other base stations is al-
lowed. Thus, two arrows are compatible if no head is contained in the
other arrow; otherwise, we say that they are in conflict. Formally, the
head ui of the arrow for (ui , bk ) is contained in the arrow for (uj , bl )
if ui is contained in the closed interval [bl |uj bl |, bl + |uj bl |]. If
we want to emphasize which user is affected by the interference from
another transmission, we use the term blocking, i.e., arrow ai blocks
arrow aj if aj s head is contained in ai .
As part of the input we are given only the base station and user
positions. The arrows that show which base station serves which
user are part of the solution. For each user we have to decide which
base station serves it. This corresponds to selecting an arrow for the
user. At the same time, we have to decide in which round each se-
lected arrow is scheduled under the side constraint that all arrows in
each round must be compatible. To distinguish between the different
rounds we have to label the arrows scheduled in these rounds with
different labels. The arrows scheduled in the same round should be
labeled identically. For labeling the arrows we use colors that repre-
sent the rounds.
For the two-dimensional JBS problem we have positions in R2
and interference disks d(bi , uj ) with center bi and radius bi uj 2
instead of arrows. We denote the set of interference disks for the user
base-station pairs from a set P by D(P ). Two interference disks are
in conflict if the user that is served by one disk is contained in the
other disk; otherwise, they are compatible. The problems can now be
stated as follows:
1D-JBS
Input: User positions U = {u1 , . . . , un } R and base station posi-

tions B = {b1 , . . . , bm } R.
Output: A set P of n user base-station pairs such that each user

is in exactly one pair, and a coloring C : A(P ) N of the
set A(P ) of corresponding arrows such that any two arrows
ai , aj A(P ), ai = aj , with C(ai ) = C(aj ) are compatible.
Objective: Minimize the number of colors used.
2D-JBS
Input: User positions U = {u1 , . . . , un } R2 and base station

positions B = {b1 , . . . , bm } R2 .
Output: A set P of n user base-station pairs such that each user is

in exactly one pair, and a coloring C : D(P) N of the set
D(P) of corresponding disks such that any two disks di , dj
D(P), di = dj , with C(di ) = C(dj ) are compatible.
Objective: Minimize the number of colors used.
The two problems mentioned above are the same except the input in
1D-JBS is given on a line and in 2D-JBS is given in the plane. The
arrows can be considered as one-dimensional disks.
For simplicity we will write ci instead of C(ai ) in the rest of the

chapter. From the problem definitions above it is clear that both the
1D- and the 2D-JBS problems consist of a selection problem and a
coloring problem. In the selection problem we want to select one
base station for each user in such a way that the arrows (disks) cor-
responding to the resulting set P of user base-station pairs can be
colored with as few colors as possible. We call a selection P feasible
if it contains exactly one user base-station pair for each user. Deter-
mining the cost of a selection is then the coloring problem. This can
also be viewed as a problem in its own right, where given as input a
set of arrows, the task is to schedule them in the minimum number
of rounds. The conflict graph G(A) of a set A of arrows is the graph
in which every vertex corresponds to an arrow and there is an edge
between two vertices if the corresponding arrows are in conflict. We
call such conflict graphs of arrows arrow graphs. The arrow graph
coloring problem asks for a proper coloring of such a graph. It is
similar in spirit to the coloring of interval graphs. As we will see in
Section 5.2.1, the arrow graph coloring problem can be solved in time
O(n log n). We finish this section with a simple lemma that leads to
a definition:
Lemma 5.1 For each 1D-JBS instance there is an optimal solution

with each user being served by the closest base station to its left or
right.
Proof. This follows by a simple exchange argument: Take any op-

timal solution that does not have this form. Then exchange the ar-
row where a user is not served by the closest base station in some
round against the arrow from the closest base station on the same side
(which must be idle in that round). Shortening an arrow without mov-
ing its head can only resolve conflicts. Thus, there is also an optimal
solution with the claimed property.
The two possible arrows by which a user can be served according

to this lemma are called user arrows. It follows that for a feasible
selection one has to choose one user arrow from each pair of user
arrows.

As we already mentioned in Chapter 4 the work presented in this
chapter was done in collaboration with T. Erlebach, R. Jacob, M.
Mihalak, M. Nunkesser and P. Widmayer. Extended abstracts of these
results were presented in [30] and [31]. These results will also appear
in M. Nunkessers and M. Mihalaks dissertation. We explicitly spec-
ify here the parts that were done together with the co-authors and the
parts contributed by the author of this thesis. This somewhat forced
partitioning is not meant to be any clear-cut between parts done by
some of the authors since all the authors were equally involved in this
research. However, all authors agreed to present all the results and
emphasize more on those results where the corresponding author was
more involved.
We prove that arrow graphs are perfect and can be colored opti-
mally in O(n log n) time. For the one-dimensional JBS problem with
evenly spaced base stations we give a polynomial-time dynamic pro-
gramming algorithm. For another special case of the one-dimensional
JBS problem, where 3k users must be served by 3 base stations in k
rounds, we also give a polynomial-time optimal algorithm. From the
perfectness of arrow graphs and the existence of a polynomial-time
algorithm for computing maximum weighted cliques in these graphs,
we derive a 2-approximation algorithm for JBS based on an LP relax-
ation and rounding. In the two-dimensional case deciding whether all
users can be served in one round is doable in polynomial time. We
analyze an approximation algorithm for a constrained version of the
2D-JBS problem, and present lower bounds on the quality of some
natural greedy algorithms for the general two-dimensional JBS prob-
lem.
The following results are the contribution from the author of this
dissertation. For the general one-dimensional JBS problem, we show
that for any fixed k the question whether all users can be served in k
rounds can be solved in nO(k) time. For the 1D-JBS problem we show
that the 2-approximation result can be generalized to a more realistic
model where the interference region extends beyond the receiver. We
show that the k-decision version of 2D-JBS (where k 3) is N P-
complete.
5.2 1D-JBS
As mentioned earlier, solving the 1D-JBS problem requires selecting
an arrow for each user and coloring the resulting arrow graph with
as few colors as possible. To understand when a selection of arrows
leads to an arrow graph with small chromatic number, we first study
the properties of arrow graphs in relation to existing graph classes.
Next we analyze special cases of 1D-JBS that are solvable in polyno-
mial time. At the end of this section we present a dynamic program
that solves the decision version of the 1D-JBS problem in time nO(k) ,
where k is the number of rounds, and we show a 2-approximation al-
gorithm. The big open problem remains the complexity of the general
1D-JBS problem: Is it N P-complete or is it polynomially solvable?
5.2.1 Relation to Other Graph Classes

We will make use of properties of arrow graphs in the design of algo-
rithms for 1D-JBS in the following sections. Therefore, let us briefly
discuss the relationship between arrow graphs and other known graph
classes.1 Exact definitions and further information about the graph
classes mentioned in this section can be found in [12, 74].
Any interval graph is also an arrow graph where all arrows point
in the same direction. Thus, arrow graphs are a superclass of interval
graphs.
An arrow graph can be represented as the intersection graph of tri-
angles on two horizontal lines y = 0 and y = 1: Simply represent an
arrow with left endpoint and right endpoint r that points to the right
(left) as a triangle with corners (, 0), (r, 0), and (r, 1) (with corners
(r, 1), (, 1), and (, 0) respectively). With this representation two
triangles intersect if and only if the corresponding arrows are in con-
flict. See Figure 5.2.1 for an example. Intersection graphs of triangles
with endpoints on two parallel lines are known in the literature as PI
graphs. They are a subclass of trapezoid graphs, which are the inter-
section graphs of trapezoids that have two sides on two fixed parallel
1 The connections between arrow graphs and known graph classes such as PI
graphs, trapezoid graphs, co-comparability graphs, AT-free graphs, and weakly chordal
graphs were observed by E. Kohler, J. Spinrad, R. McConnell, and R. Sritharan at the
seminar Robust and Approximative Algorithms on Particular Graph Classes, held in
Dagstuhl Castle during May 2428, 2004.
5.2. 1D-JBS 117
Figure 5.2.1: An arrow graph (top) and its representation as a PI

graph (bottom).
lines. Trapezoid graphs are in turn a subclass of co-comparability

graphs, a well-known class of perfect graphs. Therefore, the contain-
ment in these known classes of perfect graphs implies arrow graphs
are also perfect. Consequently, the size of a maximum clique in an
arrow graph equals its chromatic number.
As arrow graphs are a subclass of trapezoid graphs, we can ap-
ply known efficient algorithms for trapezoid graphs to arrow graphs.
Felsner et al. [34] give algorithms with running-time O(n log n) for
chromatic number, weighted independent set, weighted clique, and
clique cover in trapezoid graphs with n vertices, provided that the
trapezoid representation is given. The coloring algorithm provided
in [34] is very similar to the following greedy coloring algorithm.
We assume for simplicity that the arrows A = {a1 , . . . , an } are
given in left-to-right order of their left endpoints. This sorting can
also be seen as the first step of the greedy coloring algorithm. The al-
gorithm scans the arrows from left to right in this sorted order. In step
i it checks whether there are colors that have already been used and
that can be assigned to ai without creating a conflict. If there are such
candidate colors, it considers, for each such color c, the rightmost
right endpoint rc among the arrows that have been assigned color c
so far. To ai is assigned the color c for which rc is rightmost (breaking
ties arbitrarily). If there is no candidate color, the algorithm assigns
a new color to ai . The optimality proof of this algorithm is given
in [30] and it is easy to see that the running time is O(n log n).
We sum up the discussed properties of arrow graphs in the fol-
lowing theorem.
Theorem 5.2 Arrow graphs are perfect. In arrow graphs chromatic

number, weighted independent set, clique cover, and weighted clique

can be solved in time O(n log n).
One can also show that arrow graphs are AT-free (i.e., do not
contain an asteroidal triple) and weakly chordal. For more details
on these graph classes the interested reader is referred to the text-
book [12].
5.2.2 1D-JBS with Evenly Spaced Base Stations

As it usually happens most problems are hard to model and solve
when all realistic parameters are considered. To gain more under-
standing of the structure and the hardness of the problem first simpli-
fied models are studied. The simplest and still interesting version of
the 1D-JBS problem that we can solve in polynomial time is when
base stations are spaced equidistant. Here we consider the special
case of the 1D-JBS problem where the base stations are spaced at
distance d from their neighbors. The far-out user on the left (right)
side is also not further than distance d from the first (last) base station.
We consider the base stations in left-to-right order.
The m base stations partition the line into a set {v0 , . . . , vm } of
intervals. In this special case and from Lemma 5.1 we have the prop-
erty that no interference arrow intersects more than two intervals, i.e.
the influence from a base station is limited to its direct left and right
neighboring base station. A solution (selection of arrows) is con-
sidered non-crossing if there are no two users u and w in the same
interval such that u is to the left of w, u is served from the right, and
w from the left, in two different rounds.
Lemma 5.3 For instances of 1D-JBS with evenly spaced base sta-
tions, there is always an optimal solution that is non-crossing.
Proof. Consider an optimal solution that violates the non-crossing

property. Let u and w be two users such that u and w are in the same
interval, u is to the left of w, and the optimal solution s serves u with
the right base station br in round t1 using arrow ar and w with the left
base station bl in round t2 using arrow al ; obviously, t1 = t2 . We can
modify s such that in round t1 base station br serves w and in t2 base
station bl serves u. The modified solution is feasible because both
the left and the right involved arrows al and ar have become shorter,
5.2. 1D-JBS 119
which means they block fewer users, and even though the head of al
has moved left and the head of ar has moved right there cannot be any
arrow that would block them. In t1 the arrow ar cannot be blocked
since there are no arrows coming from base stations positioned to the
right of br (property of equidistant base stations) and arrows coming
from the left side of br cannot block the new ar because they would
have blocked the old arrow ar (contradiction to the feasibility of s).
For t2 the reasoning is symmetric.
Any non-crossing solution can be completely characterized by a

sequence of m 1 division points, such that the ith division point
specifies the index of the last user that is served from the left in the
ith interval. (The case where all users in the ith interval are served
from the right is handled by choosing the ith division point as the in-
dex of the rightmost user to the left of the interval, or as 0 if no such
user exists.) A straight forward approach is to enumerate all possible
O(nm1 ) division point sequences (dps) and color the arrows corre-
sponding to each dps with the greedy algorithm from Section 5.2.1.
Dynamic Programming
We present a dynamic programming approach that solves the special
case of the 1D-JBS problem with evenly spaced base stations in time
O(m n4 log n). The idea is to consider the base stations in left-to-
right order. For every base station, compute a cost function for all
possible left and right division points in the intervals to the left re-
spectively right of the base station. The cost function that we store in
the table of base station bi , denoted by i (di1 , di ), is the minimum
number of rounds needed to schedule the users from u1 up to udi us-
ing the base stations b1 , b2 , . . . , bi . In the case of evenly spaced base
stations this cost depends only on the division point positions di1
and di that define the users served by the base station bi . An example
for division points is given in Figure 5.2.2.
By (vi ) we denote the set of potential division points for inter-
val vi , i.e., the set of the indices of users in vi and of the rightmost
user to the left of vi (or 0 if no such user exists). The table entries
1 (d0 , d1 ) for b1 , where d0 is set to zero and d1 (v1 ), are com-
puted using the greedy coloring algorithm. For i 1, we compute
the values i+1 (di , di+1 ) for di (vi ), di+1 (vi+1 ) from the
values i (, di ). The minimum coloring for fixed division points di
d0 d1 di1 di di+1 dm
b1 b2 ... bi1 bi bi+1 ... bm

v0 v1 vi1 vi vm
Figure 5.2.2: Dynamic programming approach.
and di+1 at base station bi+1 is the maximum between the number of
colors needed at bi , using the same di and choosing di1 such that
i (di1 , di ) is minimized, and the coloring ci of the arrows intersect-
ing the interval vi . In the case of evenly spaced base stations with
no far out users this cost ci depends only on the division points
di1 , di and di+1 and we denote it by ci (di1 , di , di+1 ). The col-
oring i (di1 , di ) is compatible with the coloring ci (di1 , di , di+1 )
up to redefinition of colors. The algorithm chooses the best division
point di1 to get:
i+1 (di , di+1 ) = min max {i (di1 , di ), ci (di1 , di , di+1 )}

di1 (vi1 )
The running time is dominated by the calculation of the ci values.

There are O(m n3 ) such values, and each of them can be computed
in time O(n log n) using the coloring algorithm. The optimal solu-
tion is found by tracing back where the minimum was achieved from
m (x, n). Here x is chosen among the users of the interval before
the last base station such that m (x, n) is minimum. For the trace-
back it is necessary to store a pointer to the entry in the previous table
where the minimum was achieved in the computation of the val-
ues. The traceback yields a sequence of division points that defines
the selection of arrows for an optimal schedule. The following the-
orem summarizes our result for the 1D-JBS with evenly spaced base
stations:
Theorem 5.4 The base station scheduling problem for evenly spaced
base stations without far out users can be solved in O(m n4 log n)
time by dynamic programming.
The running time is further bounded by O(m u4max log umax ),

where umax is the maximum number of users in one interval.
5.2. 1D-JBS 121
5.2.3 3k Users, 3 Base Stations in k Rounds

Here we analyze the following special case of the 1D-JBS problem:
We are given 3 base stations b1 , b2 and b3 , and 3k users with k far out
users among them. Far out users are the users to the left of b1 or to
the right of b3 whose interference arrows contain b2 . We want to find
out whether the users can be served in k rounds or not.
This special setting forces every base station to serve a user in
every round if there is a k-schedule. A far out user has to be served
by its unique neighboring base station. Since the arrows of far out
users contain b2 , all users between b1 and b2 are blocked when the
far out users of b1 are served. Hence they have to be served when the
far out users of b3 are served. Based on this observation every round
contains one of the following types of arrow triplets:
Type 1: b3 serves a far out user, b2 serves a user between b1 and b2 ,

and b1 serves a user that is not a far out user.
Type 2: b1 serves a far out user, b2 serves a user between b2 and b3 ,
and b3 serves a user that is not a far out user.
For every user, it is uniquely determined whether it will be served in

a round of Type 1 or Type 2.
We can schedule the users in the following way. Let k1 and k3 be
the number of far out users of b1 and b3 respectively with k = k1 +k3 .
First, we serve the far out users of b3 in rounds 1, . . . , k3 in the order
of increasing distance from b3 . Next, we match the resulting arrows in
a best fit manner with arrows produced by b2 serving users between
b1 and b2 (see Figure 5.2.3). For every round i = 1, 2, . . . , k3 , we
find the user closest to b2 that can be served together with the corre-
sponding far out user served by b3 , and schedule the corresponding
transmission in that round. Using this selection strategy the size of
the arrows of b2 grows with the number of the round in which they
are scheduled. Now we have to serve the remaining k3 users (that
are not far out users of b1 ) with b1 . We use a best fit approach again,
i.e., for every round i = 1, 2, . . . , k3 , we schedule the user with max-
imum distance from b1 (longest arrow) among the remaining users.
The schedule for the remaining users that form the rounds of Type 2
can be done similarly, starting with the far out users of b1 .
Theorem 5.5 For the 1D-JBS problem with 3 base stations and 3k
u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12

b1 b2 b3
round 1
round 2
round 3
Figure 5.2.3: Far out users u10 , u11 and u12 are served by b3 in
rounds 1, 2 and 3, respectively. The arrows represent the Type 1
rounds. Users u1 , u8 and u9 will be scheduled in a round of Type 2
(not shown).
users with k far out users deciding whether a k-schedule exists can
be done in O(n log n) time.
Proof. The proof can be found in [30] and will appear in the thesis
of M. Mihalak. The proof shows that the greedy scheduling strategy
finds such a k-schedule in time O(n log n) if one exists.
5.2.4 Exact Algorithm for the k-Decision Problem

In this section we present an exact algorithm for the decision variant
k-1D-JBS of the 1D-JBS problem: For given k and an instance of 1D-
JBS, decide whether all users can be served in at most k rounds. We
present an algorithm for this problem that runs in O(m n2k+1 log n)
time.
We use the result from Section 5.2.1 that arrow graphs are perfect.
Thus, the size of the maximum clique of an arrow graph equals its
chromatic number.
The idea of the algorithm, which we call AkJBS , is to divide
the problem into subproblems, one for each base station, and then
combine the partial solutions to a global one.
For base station bi , the corresponding subproblem Si considers
only arrows that intersect bi and arrows for which the alternative user
arrow2 intersects bi . We denote this set of arrows by Ai . Si1 and
2 For every user there are only two user arrows that we need to consider
(Lemma 5.1). If we consider one of them, the other one is the alternative user ar-
row.
5.2. 1D-JBS 123
Si+1 are the neighbors of Si . A solution to Si consists of a feasible

selection of arrows from Ai of cost no more than k, i.e., the selec-
tion can be colored with at most k colors. To find all such solutions
we enumerate all possible selections that can lead to a solution in k
rounds. For Si we store all such solutions {s1i , . . . , sIi } in a table Ti .
We only need to consider selections in which at most 2k arrows inter-
sect the base station bi . All other selections need more than k rounds,
because they must contain more than k arrows pointing in the same
direction at b . Therefore, the number of entries of Ti is bounded by
2k n i 2k
j=0 j = O(n ). We need O(n log n) time to evaluate a sin-
gle selection with the coloring algorithm of Section 5.2.1. Selections
that cannot be colored with at most k colors are marked as irrelevant
and ignored in the rest of the algorithm. We build up the global solu-
tion by choosing a set of feasible selections s1 , . . . , sm in which all
neighbors are compatible, i.e., they agree on the selection of common
arrows. It is easy to see that in such a global solution all subsolutions
are pairwise compatible.
We can find a set of compatible neighbors by going through the

tables in left-to-right order and marking every solution in each ta-
ble as valid if there is a compatible, valid solution in the table of
its left neighbor, or as invalid otherwise. A solution si marked as
valid in table Ti thus indicates that there are solutions s1 , . . . , si1 in
T1 , . . . , Ti1 that are compatible with it and pairwise compatible. In
the leftmost table T1 , every feasible solution is marked as valid. When
the marking has been done for the tables of base stations b1 , . . . , bi1 ,
we can perform the marking in the table Ti for bi in time O(n2k+1 )
as follows. First, we go through all entries of the table Ti1 and, for
each such entry, in time O(n) discard the part of the selection affect-
ing pairs of user arrows that intersect only bi1 but not bi , and enter
the remaining selection into an intermediate table Ti1,i . The table
Ti1,i stores entries for all selections of arrows from pairs of user ar-
rows intersecting both bi1 and bi . An entry in Ti1,i is marked as
valid if at least one valid entry from Ti1 has given rise to the entry.
Then, the entries of Ti are considered one by one. For each entry si
the algorithm looks up in time O(n) the unique entry in Ti1,i that
is compatible with si . If the compatible entry from Ti1,i is marked
as valid then the entry in Ti is also marked as valid. If in the end
the table Tm contains a solution marked as valid, a set of pairwise
compatible solutions from all tables exists and can be retraced easily.
bi bi+1
1
2
4
3
5
p
Figure 5.2.4: Arrow types intersecting at a point p between base

stations bi and bi+1 .
The overall running time of the algorithm is O(m n2k+1 log n).
There is a solution to k-1D-JBS if and only if the algorithm finds such
a set of compatible neighbors.
Lemma 5.6 There exists a solution to k-1D-JBS if and only if AkJBS

finds a set of pairwise compatible solutions.
Proof. () Every arrow intersects at least one base station. A global

solution directly provides us with a set of compatible subsolutions
opt = {sopt opt
1 , . . . , sm }. Since the global solution has cost at most k,
so have the solutions of the subproblems. Hence, the created entries
will appear in the tables of the algorithm and will be considered and
marked as valid. Thus, there is at least one set of compatible solutions
that is discovered by the algorithm.
() We have to show that the global solution constructed from
the partial ones has cost at most k. Suppose for a contradiction that
there is a point p where the clique size is bigger than k and therefore
bigger than the clique at bi (the left neighboring base station of p)
and the clique at bi+1 (the right neighboring base station of p). We
divide the arrows intersecting point p into 5 groups as in Figure 5.2.4.
Arrows of type 1 (2) have their head between bi and bi+1 and their
tail to the left (right) of bi (bi+1 ). Arrows of type 3 (4) have their
tail between bi and bi+1 and their head to the left (right) of bi (bi+1 ).
Finally, type 5 arrows intersect both bi and bi+1 . For the clique at p
to be bigger than that at bi some arrows not considered at bi have to
create conflicts. The only such arrows (considered at bi+1 but not at
bi ) are of type 4. Observe that arrows of type 1, 2 and 5 are consid-
ered both at the table for bi and at the table for bi+1 . If their presence
5.2. 1D-JBS 125
increases the clique size at p, then no type 3 arrow can be in the maxi-
mum clique at p (observe that arrows of type 3 and 4 are compatible).
Therefore, the clique at p cannot be bigger than the clique at bi+1 , a
contradiction.
The analysis of algorithm AkJBS and the Lemma 5.6 lead to the
following theorem:
Theorem 5.7 Problem k-1D-JBS can be solved in O(m n2k+1 log n)

time.
5.2.5 Approximation Algorithm

Even though we tried hard to find a polynomial time exact algorithm
for the general 1D-JBS problem we failed. We were also unable to
show that the problem would be N P-complete. What still remained
promising was to find good approximation algorithms. In this sec-
tion we present a 2-approximation algorithm for the 1D-JBS problem
based on the well known Linear Program (LP) relaxation technique
together with a straight forward rounding strategy.
The Integer Linear Program (ILP) formulation is based on the
properties of arrow graphs summarized in Theorem 5.2. From this
theorem we know that arrow graphs are perfect and hence it is equiv-
alent to ask for the minimum number of colors needed to color the
arrow graph of a possible arrow selection or to ask for the maximum
clique size of the arrow graph. Let A denote the set of all user arrows
of a given 1D-JBS instance and let Asel A be a feasible selection
of arrows with the arrow graph G(Asel ). We formulate the 1D-JBS
problem with the following ILP:
min k (5.2.1)

s.t. li + ri k, cliques C in G(A) (5.2.2)
li C ri C
li + ri = 1, i {1, . . . , |U |} (5.2.3)
li , ri {0, 1}, i {1, . . . , |U |} (5.2.4)
kN (5.2.5)
In the above formulation li and ri are binary indicator variables

specifying whether user ui is served from the left or right neighboring
base station using the left or right user arrow. With constraints (5.2.2)
we bound the size of the cliques in the arrow graph of the selected ar-
rows from above (those that have their indicator variable set to 1). The
constraints (5.2.3) are needed to make sure that all users are served
exactly with one user arrow. The objective is to minimize the maxi-
mum clique size k, where k N.
We obtain the LP relaxation by allowing li , ri [0, 1] and k
0. An optimal solution to the LP relaxation can be rounded to an
integer solution using the following rounding strategy: li :=
li +
0.5, ri := 1 li . This rounding gives an integer solution that is
not worse than twice the original optimal fractional solution. This is
true because in the worst case all arrows in a maximum clique can
get their weights (the value of their indicator variable) doubled. We
know that the optimal integer solution is a feasible fractional solution.
Hence, the optimal integer solution cannot be better than the optimal
fractional solution. Thus, we have shown that the cost of the rounded
solution is at most twice the cost of the optimal integer solution.
One might think that maybe a more clever analysis can prove bet-
ter upper bound for the rounded integer solution. Unfortunately this is
not the case because we show that indeed the rounded integer solution
can get as bad as twice the optimal fractional solution. Figure 5.2.5
gives an example where the cost of an optimal fractional solution is
indeed smaller than the cost of an optimal integral solution by a fac-
tor arbitrarily close to 2. In this example the basic construction I1
contains two base stations bl and br and one user u in between. Both
the solution of the ILP and the solution of the LP relaxation have cost
1. I2 is constructed recursively by adding to I1 two (scaled) copies
of I1 in the tail positions of the arrows. In this case the cost of the
relaxed LP is 1.5 and the integral cost is 2. The construction In , after
n recursive steps, is shown at the bottom of Figure 5.2.5. This con-
struction is achieved by using I1 and putting two scaled In1 settings
in the tail of the arrows from I1 . The cost of the LP relaxation for In
is n+1
2 , whereas the cost of the ILP is n.
We have to show that indeed the LP relaxation can be solved in

polynomial time (with respect to n and m). The only bottleneck is
the number of constraints (5.2.2) that can become exponential in n.
Figure 5.2.6 shows that this can really happen. In this example for
every choice of arrows from a compatible pair (a2i1 , a2i ) we get a
clique of size n/2, which is maximum. The 1D-JBS instance sup-
5.2. 1D-JBS 127
I1 :
lu = 0.5 ru = 0.5
bl u br
I2 :
bl u br
In :
In1 In1
bl u br
Figure 5.2.5: Lower bound example for the 2-approximation ratio of

the LP relaxation technique.
u1 u3 un1 b1 b2 un u4 u2
a1
a2
a3
a4
an1
an
Figure 5.2.6: Example for an arrow graph with exponential number

of maximum cliques.
porting these selected arrows has two base stations in the middle and
n/2 users on each sides. Fortunately, we can still solve such an LP in
polynomial time with the ellipsoid method of Khachiyan [58] applied
in a setting similar to [45]. This method only requires a separation or-
acle that provides us with a violated constraint for any values of li , ri ,
if one exists. It is easy to check for a violation of constraints (5.2.3)
and (5.2.4). For constraints (5.2.2), we need to check if for given val-
ues of li , ri the maximum weighted clique in G(A) is smaller than k.
By Theorem 5.2 this can be done in time O(n log n). Summarizing,
we get the following theorem:
Theorem 5.8 There is a polynomial-time 2-approximation algorithm

for the 1D-JBS problem.
5.2.6 Different Interference Models

Up to now we have analyzed the discrete interference model where
the interference region has no effect beyond the targeted user. One
step towards a more realistic model is to consider the interference re-
gion, produced by a base station sending a signal to a user, to span
also beyond the targeted user. We call the 1D-JBS problem using
this more realistic interference model the modified 1D-JBS problem.
For the 1-dimensional case this can be modeled by using interference
segments with the user somewhere between the endpoints of this seg-
ment (the small black circles on the segments in Figure 5.2.7) and the
base station in the middle of the segment. The conflict graph of such
interference segments is another special case of trapezoid graphs. For
an example see Figure 5.2.7. The trapezoid representing the segment
[a, b] (serving user u) from Figure 5.2.7 is built using the parallel
edges [a , u ] (the projection of the segment [a, u] onto the upper sup-
porting line of the trapezoid) and [u , b ] (the projection of the seg-
ment [u, b] onto the lower supporting line of the trapezoid).
We also get the trapezoid representation mentioned above if we
consider a segment with a user between its endpoints as two arrows
pointing to the user one from left and one from right. Then the tri-
angle transformation for arrows (from Section 5.2.1) results in the
trapezoid representation from Figure 5.2.7. Thus, for the modified
1D-JBS using Theorem 5.8 we have the following result:
Corollary 5.9 There is a polynomial-time 2-approximation algorithm

5.2. 1D-JBS 129
a u b
a u
u b
Figure 5.2.7: Example for interference segments.
for the modified 1D-JBS problem.
The proof is similar to the proof from Section 5.2.5, except that in-
stead of arrow graphs we have another special case of trapezoid graphs.
5.3 2D-JBS
After analyzing several versions of the 1D-JBS problem we get closer
to the real application from mobile communication and have a closer
look at the situation in the plane. In this section we analyze the
two-dimensional version of the base station scheduling problem (2D-
JBS). The decision variant k-2D-JBS of the problem asks whether
the users can be served in at most k rounds for a given k and a given
2D-JBS instance. We show that k-2D-JBS is N P-complete for any
k 3. For the case k = 1, we give a polynomial time algorithm.
Then we present a constant-factor approximation algorithm for a con-
strained version of 2D-JBS. At the end of the section, we show log-
arithmic lower bounds on the approximation ratio of several natural
greedy approaches.
5.3.1 N P-Completeness of the k-2D-JBS Problem

In this section, we show that the decision variant of the joint base sta-
tion scheduling problem in the plane (k-2D-JBS) is N P-complete.
We provide a reduction from the general graph k-colorability prob-
lem. Our reduction follows the methodology presented in [44] for
unit disk k-colorability. We present the realization of the auxiliary
graphs using 2D-JBS instances and show their correctness.
The general graph k-colorability problem is a well known N P-
complete problem which we recall here as it was presented in [42].
Graph k-Colorability: Given a graph G = (V, E) and a positive

integer k |V |. Is G k-colorable, i.e., does there exist a func-
tion f : V {1, 2, . . . , k} such that f (u) = f (v) whenever
{u, v} E?
Given any graph G, it is possible to construct in polynomial time

a corresponding 2D-JBS instance that can be scheduled in k rounds
if and only if G is k-colorable. We use an embedding of G into the
plane which allows us to replace the edges of G with suitable base
station chains with several users in a systematic fashion such that k-
colorability is preserved. The output vertices of the auxiliary graphs
represent the vertices of the original graph G.
In the following we recall the auxiliary graph structures from [44]
used for the embedding and we show their realization using JBS in-
5.3. 2D-JBS 131
stances. In the resulting JBS instances we make frequent use of

cliques joined to single vertices (see Figure 5.3.1(a)). A clique of
size k 1 is realized by a disk with k 1 users on the perimeter
and one base station b1 in the middle of the disk. We call this disk
the inner disk of base station b1 and the users on its perimeter the
inner users. A vertex uk connected to this clique is represented by
a user on a bigger disk. We call this disk the outer disk of base sta-
tion b1 and the user(s) on its perimeter the outer user(s). To force
this base station b1 to serve users only inside the disk d(b1 , uk ) we
place an auxiliary base station b1 with k users around it such that the
distance from b1 to any outer user of any other base station will be
greater than the distance from b1 to any user of b1 (see Figure 5.3.2).
In the 2D-JBS instances implementing the auxiliary graph structures
presented later we assume that the user positions are given with real
coordinates. The constructions would work also with rational (even
integer) coordinates in which case the inner users of a base station
are placed inside the inner disk rather then on its perimeter. In the
case of rational coordinates, the inner users of a base station bi still
cannot be served by other base stations than bi because of the aux-
iliary base stations. For ease of presentation we will use real values
for the coordinates. To simplify the drawings in what follows for
the JBS instances we omit the auxiliary base stations and the users
around them. Furthermore, we draw the cliques as disks labeled with
their size (see Figure 5.3.1(b)). For the properties of the definitions
that follow the factor 2 in the number of base stations and number of
users comes from counting also the auxiliary base stations and their
users. We now present the definitions of the auxiliary graph struc-
tures from [44] and their realization by JBS instances together with
their properties.
Definition 5.10 A k-wire of length l, denoted by Wkl , consists of l + 1

vertices Wv0 , Wv1 , . . . , Wvl and the (k 1)-cliques W C1 , . . . , W Cl
(l in number) such that for each 1 i l all vertices of the clique
W Ci are connected to both Wvi1 and Wvi . The vertices Wv0 and
Wvl are the output vertices of the k-wire (see Figure 5.3.3(a)).
The realization of the k-wire by a JBS instance is given in Fig-

ure 5.3.4(a). In this and the following JBS instances we have to show
that the number of users remains polynomial as a function of the num-
ber of vertices of the original graph G and that the transformation
b1
u1
uk1
u2
uk b1 uk k1
ui
(a) Realization with k users and one (b) Simplified drawing.

base station.
Figure 5.3.1: Example of a vertex connected to a k 1-clique.
vi vi+1
di,i+1
bi bi+1
di,i
bi bi+1
Figure 5.3.2: Forcing base stations to serve users only inside their
outer disk.
5.3. 2D-JBS 133
Kk1 Kk1 Kk1 Kk1

W v0 W v1 W v2 W v3 W v4
W C1 W C2 W C3 W C4
(a) The k-wire Wk4 .
Kk1 Kk1 Kk1

Kv0 Kv1 Kv2 Kv3 Kv4
KC1 KC2 KC3
(b) The k-chain Kk3 .

o0 o1 o2
Kk1 Kk1 Kk1 Kk1 Kk1 Kk1 Kk1

Cv1 Cv2 Cv3 Cv4 Cv5 Cv6
CC0 CC1 CC2 CC3 CC4 CC5 CC6
(c) The k-clone Ck3 of size 3.

v1
C1 v5 C2
Kk2 Kk2
v0 Kk2 v2
v4 C0 v6
C4 Kk2 v7 Kk2 C
3
v3
(d) The k-crossing Hk .
Figure 5.3.3: Auxiliary graph structures.

v0 v1 v2 vl2 vl1 vl
k1 k1 k1 ... k1 k1 k1
(a) The k-wire Wkl realized by a JBS instance.

v0 v1 v2 vl2 vl1 vl+1
vl
k1 k1 k1 ... k1 k1 k1 k1
(b) The k-chain Kkl realized by a JBS instance.
o0 k1 o1 k1 o2 k1
k1 k1 k1 k1 k1 k1 k1 k1 k1 k1 k1
Cv1 Cv2 Cv3 Cv4 Cv5 Cv6 Cv7 Cv8 Cv9 Cv10 Cv11
(c) The k-clone Ck5 of size 3 realized by a JBS instance.
Figure 5.3.4: Realization of the auxiliary graph structures by JBS

instances.
5.3. 2D-JBS 135
from G can be done in polynomial time. We also have to show that

the assignment of the users to base stations is uniquely defined if we
want to preserve k-colorability.
Property 5.11 A JBS instance for a Wkl has the following properties:
1. It has m = 2(l + 1) base stations and n = 2k (l + 1) users.

2. It can be scheduled in k rounds, but not in k 1.
3. Every k-scheduling assigns to every base station only its inner
and outer users.
4. Every k-scheduling assigns the two output vertices v0 and vl to
the same round.
Proof. A Wkl cannot be scheduled in less than k rounds since the

lower bound on the number of necessary rounds is m n
= k. We
l
know that there is a valid k-schedule for a Wk since the schedule that
assigns to each base station its inner and outer users needs exactly k
rounds. Since the number of users n is k m we know that all valid
k-schedules have to use all base stations in every round.
To prove that the only valid k-scheduling assigns only the corre-
sponding inner and outer users to each base station we need the aux-
iliary base stations and the k users around them. First, we prove that
every base station (including the auxiliary ones) must serve its own
inner users. Suppose that some base station bj serves an inner user
of base station bi (i = j) in round l. In round l base station bi can-
not serve any other inner user since they are all at the same distance
around bi and hence only one of them can be served in a round. In the
same round l, base station bi cannot serve any user that is farther away
than its inner users because the interference disk would block the in-
ner user that is served by base station bj . Hence base station bi has to
stay idle in round l, which contradicts the validity of this schedule as
a k-scheduling. We still have to prove that no base station serves the
outer users of other base stations. Suppose that base station bi serves
the outer user of another base station. W.l.o.g. let this other base sta-
tion be bi+1 . The auxiliary base station bi is placed in such a way that
the distance di,i is less than the distance di,i+1 (see Figure 5.3.2) and
thus the interference disk d(bi , vi+1 ) would block the auxiliary base
station bi from serving its inner users. This contradicts the fact that in
a valid k-scheduling every base station is active in every round.
The last property holds since the interference that the outer users
(v0 , . . . , vl ) produce forces every valid k-schedule to schedule them
in the same round.
Definition 5.12 A k-chain of length l, denoted by Kkl , consists of

a Wkl together with an additional vertex connected with one of the
output vertices. This new vertex and the vertex at the other end of
the original k-wire are the output vertices of the k-chain (see Fig-
ure 5.3.3(b)).
The realization of the k-chain using a JBS instance is given in

Figure 5.3.4(b).
Property 5.13 A JBS instance for a Kkl has the following properties:
1. It has m = 2(l + 2) base stations and n = 2k (l + 2) users.

and outer users.
4. Every k-scheduling assigns the two output vertices v0 and vl+1

to different rounds.
Proof. By the same argument as for the Wkl we can prove the second
property. From the properties of a k-wire we know that every valid k-
schedule schedules the outer users v0 . . . vl in the same round. User vl
cannot be served by the right-most base station because then the base
station to the left of it would have to stay idle in that round. Thus a
valid k-schedule will assign to every base station only its inner and
outer users. The user vl is in the interference region of the user vl+1 ,
hence it forces every k-schedule to schedule them in different rounds.

By using k-wires together with k-chains we can transform the edges
of a graph into a 2D-JBS instance. The following auxiliary graph
structure is used to transform a high degree node into an independent
set of vertices (output nodes) that copy the color of the original vertex
and connect to the neighbors of the original vertex.
5.3. 2D-JBS 137
Definition 5.14 A k-clone of size s 2 and length l, denoted by

Ckl , consists of the l(s 1) vertices Cv1 , Cv2 , . . . , Cvl(s1) , the (k
1)-cliques (1 + l(s 1) in number) CC0 , CC1 , . . . , CCl(s1) and
s output vertices o0 , o1 , . . . , os1 . Each Cvi , i = 1, . . . , l(s 1)
is connected to all vertices of CCi1 and CCi . Furthermore, each
output vertex oi , i = 0, . . . , s 1 is connected to all vertices of CCli
(see Figure 5.3.3(c)).
The realization of the k-clone Ck5 of size 3 using a JBS instance

is given in Figure 5.3.4(c).
Property 5.15 A JBS instance for a Ckl of size s has the following
properties:
1. It has m = 2(s + (s 1)l + 1) base stations and n = 2k (s +

(s 1)l + 1) users.
and outer users.
4. Every k-scheduling assigns the output vertices o0 . . . os1 to
the same round.
Proof. The proof follows similar arguments as the one presented for
a k-wire.
To avoid crossing edges when embedding the general graph into the
plane we need the following special graph structure.
Definition 5.16 A k-crossing, denoted by Hk (k 3), is represented

by the graph in Figure 5.3.3(d). The vertices v0 , v1 , v2 , v3 are the
output vertices of the k-crossing.
We can realize the k-crossing using the following helper gadgets:

for a (k 2)-clique connected to 4 vertices we can use the JBS in-
stance from Figure 5.3.5(a). For a (k 2)-clique connected to 3
vertices we can use the same gadget having just 3 k-wires instead of
4. For a high degree node like v4 or v0 (from Figure 5.3.3(d)) we
can use the JBS instance from Figure 5.3.5(b). The edges connect-
ing the vertices can be realized with JBS instances for k-chains. The
k-chains can be bent, they do not have to be vertical or horizontal.
v5
v4 v6
k 1 clique
k 2 clique
v7 k-wire
(a) JBS instance for a k 2 clique connected to 4 vertices.
vi
(b) JBS instance for a high degree

node vi .
Figure 5.3.5: Helper gadgets for realizing the k-crossing with JBS
instances.
5.3. 2D-JBS 139
Property 5.17 The JBS instance for a k-crossing Hk has the follow-
ing properties:
1. It has m (constant) base stations and n = k m users.

2. It can be scheduled in k-rounds, but not in k 1.
and outer users.
4. Every k-coloring (scheduling) f satisfies f (v0 ) = f (v2 ) and
f (v1 ) = f (v3 ).
5. There exist k-colorings f1 and f2 s.t. f1 (v0 ) = f1 (v2 ) =
f1 (v1 ) = f1 (v3 ) and f2 (v0 ) = f2 (v2 ) = f2 (v1 ) = f2 (v3 ).
Proof. The JBS instance for Hk is constructed in such a way that all
base stations are fully loaded with k users. Hence it is obvious that it
cannot be scheduled in less than k rounds. Similarly to the proof for
the k-wire, one can show that the only valid k-scheduling serves with
every base station only its own inner and outer users. Since this JBS
instance is a realization of the original k-crossing auxiliary graph we
know that every k-coloring satisfies the last two properties. For ease
of presentation we omitted the auxiliary base stations. One might
question if this construction really allows placing for every base sta-
tion also the corresponding auxiliary base station. We do not provide
a formal proof of this. But intuitively and also as the Figure 5.3.5(a)
shows there is free place next to the outer disk of every base station
to place the auxiliary base stations.
In what follows we give the main idea on how to embed a general
graph G into the plane using the auxiliary graph structures presented
above.
High degree vertices vi are broken into an independent set of vertices
vi,1 . . . vi,d (d 2 is the degree of vi ). Each such vertex vi,j is then
connected to one of the neighbors of vi . The vertices are placed on
a line such that the modified vertices coming from the same original
vertex are placed next to one another. The original edges are replaced
by horizontal and vertical lines connecting the corresponding vertices
(or modified vertices). The properties that must hold in order to do
the replacements without conflicting with each other are:
All edges consist of horizontal and vertical line-segments.

G:
v1 v2 v5
v4 v3
one possibe embedding of G
v1,1 v1,2 v2,1 v2,2 v2,3 v2,4 v3,1 v3,2 v4 v5
Figure 5.3.6: Example for the planar embedding.
Between parallel line segments, vertices, and crossings certain

minimal distances are preserved.
These minimal distances ensure that at most two line segments
cross in one point.
For each given graph this embedding can be computed in poly-
nomial time.
As an example we show the embedding for an input graph G in Fig-
ure 5.3.6. The replacement vertices for a high degree node can be
realized with a k-clone, the crossings with a k-crossing, the vertical
and horizontal line segments with k-wires and k-chains. A systematic
way for doing these replacements using unit disk graphs is presented
in [44] and the same technique works here using JBS instances of the
auxiliary graph structures.
Theorem 5.18 The k-2D-JBS problem is NP-complete for any fixed

k 3.
Proof. Let G = (V, E) be any graph and k 3. The construction

of the corresponding embedding using JBS instances with its conflict
graph G = (V , E) can be done in polynomial time (polynomial in
the number of edges of G). All that remains to be shown is that
G is k-colorable G is k-colorable. (5.3.1)
5.3. 2D-JBS 141
The proof is similar to the one given in [44] and is based on the prop-
erties of the auxiliary graph structures.
If G is k-colorable then using the embedding we get compatible col-
ors for the output vertices of the auxiliary graph structures. Since the
auxiliary graph structures are k-colorable in their own and knowing
that the output vertices with which they connect to other auxiliary
graph structures are compatible we get that G is also k-colorable.
Knowing that G is k-colorable we identify in constant time the origi-
nal vertices from G to which the output vertices of G correspond and
color them correspondingly. This coloring is a valid k-coloring of G
since G is a valid embedding of G.
A direct consequence of the reduction presented above is the fol-

lowing corollary.
Corollary 5.19 The coloring step of the k-2D-JBS problem is NP-

complete for any fixed k 3.
Proof. In the reduction presented for the k-2D-JBS problem, the se-
lection of serving base stations for every user in the auxiliary graphs
is uniquely determined by the construction. Hence the same reduc-
tion also works for just the coloring part of the k-2D-JBS problem.

5.3.2 Base Station Assignment for One Round

In the previous section we showed that the coloring step of the k-2D-
JBS problem is N P-hard. In this section, we look at the problem
where for every user we know in which round it is scheduled and
we want to find a feasible disk assignment in every round, if one ex-
ists. This assignment problem can be seen as the problem of deciding
whether a set of users U U can be scheduled in one round or not,
where the subset U is given as input parameter. We call this prob-
lem the 1-round 2D-JBS (1-2D-JBS) problem. It turns out that this
problem is solvable in polynomial time.
The following observation shows the property of an optimal disk
assignment for the 1-2D-JBS problem and is valid also for the general
2D-JBS problem.
Observation 5.20 Consider an empty disk d = d(b, u) for the user

u U and base station b B, i.e. a disk centered at b containing
only user u. We claim that every optimal solution can use d to serve
u without changing the disks selected for other users.
Proof. Consider that in an optimal schedule u is served by some base

station b = b. In the round when u is served, b has to be idle because
u is the closest user to b and hence any disk centered at b reaching
some other user would block user u. Since d does not contain any
other user we can serve u with b instead of b in the same round with-
out blocking anybody else.
For the 1-2D-JBS problem this observation implies that every op-
timal assignment (if one exists) must be a set of empty disks.
We now present the algorithm A1-round that solves the 1-2D-JBS
problem optimally. In a preprocessing step we find all empty disks
formed by base stations from B and users from U . If there is some
user without an empty disk then the algorithm stops because there is
no feasible assignment that would schedule the users from U in one
round. For every user the algorithm picks an arbitrary empty disk (we
know that every base station produces at most one empty disk 3 ) and
we know from Observation 5.20 that this empty disk cannot conflict
with the empty disks selected for the other users. When all users have
their empty disks the algorithm stops and outputs the assignment.
Algorithm A1-round has polynomial running time. Using standard
techniques from computational geometry, e.g. [23], one can compute
a Voronoi diagram for the user points in O(n log n) time and then a
point location data structure so that the closest user of a base station
(the preprocessing step of A1-round ) can be determined in O(log n)
time. Thus the running-time of A1-round is O((m + n) log n).
Lemma 5.21 The problem of deciding whether all users in a given

2D-JBS instance can be scheduled in one round can be solved in time
O((n + m) log n), where m is the number of base stations and n is
the number of users.
Corollary 5.22 Given the sets U1 , . . . , Ur of users scheduled in the

rounds 1, . . . , r in an optimal solution, the problem of assigning base
3 There is no empty disk at b if there are 2 or more closest users at the same distance
from b.
5.3. 2D-JBS 143
Figure 5.3.7: A cycle of length 5 in the conflict graph of interference

disks (left). It is not clear, however, whether an optimal solution to
the selection problem will ever yield such a conflict graph; a different
selection for this instance yields a conflict graph with five isolated
vertices (right).
stations to the users such that we obtain a valid schedule of users Ui

in round i can be solved in O(r (n + m) log n) time.
5.3.3 Approximation Algorithms

We have seen in Section 5.3.1 that the decision version of 2D-JBS is
N P-complete. Hence, the best we can do is to find good approxi-
mation algorithms. In this section, we analyze greedy algorithms and
show tight bounds or just lower bounds on their approximation ra-
tio. The linear programming relaxation technique presented for the
1D-JBS problem in Section 5.2.5 doesnt lead directly to an approx-
imation algorithm, since the conflict graph of a set of interference
disks is not perfect. (The conflict graph of interference disks in the
plane can have odd cycles, see Figure 5.3.7.)
Bounded Geometric Constraints
Here, we consider a constrained version of the 2D-JBS problem. In

the real life application of mobile communication networks it is often
the case that the maximum reach of a cell is limited by the maximum
transmitting power. It is also common sense to consider that base
stations cannot be placed arbitrarily but a certain minimum distance
between them has to be maintained. These are the two geometric

constraints that we use in this section. Namely, the base stations are
at least a distance from each other and have limited power to serve a
user, i.e., every base station can serve only users that are at most Rmax
distance away from it. To make sure that under these constraints a
feasible solution exists (i.e. all users can be served) we limit ourselves
to instances where every user can be reached by at least one base
station. We present a simple algorithm achieving an approximation
ratio which only depends on the parameters and Rmax .
Consider the following greedy approach A2Dappx : In the current
round the algorithm repeatedly picks an arbitrary user base-station
pair (u, b), where u is an unserved user, such that the transmission
from b to u can be added to this round without creating a conflict.
If no such user base-station pair exists, the next round starts. The
algorithm terminates when all users have been served.
The approximation ratio achieved by A2Dappx is given in the
following analysis. Assume that the algorithm schedules the users
in k rounds. Let u be a user served in round k, and let b be the
base station serving u. Since u was not served in the previous rounds
1, 2, . . . , k 1, we know that in each of these rounds, at least one of
the following is true:
b serves another user u = u.
u is contained in an interference disk d(b , u ) for some user

u = u that is served in that round.
b cannot transmit to u because the disk d(b, u) contains another

user u that is served in that round.
In any of these cases, a user u is served, and the distance between

u and u is at most 2Rmax (since every interference disk has radius
at most Rmax ). Therefore, the disk with radius 2Rmax centered at u
contains at least k users (including u). If B is the set of base stations
that serve these k users in the optimal solution, these base stations
must be located in a disk with radius 3Rmax centered at u. Since
any two base stations are separated by a distance of , we know that
disks with radius /2 centered at base stations are interior-disjoint.
Furthermore, the disks with radius /2 centered at the base stations
in B are all contained in a disk with radius 3Rmax + /2 centered
5.3. 2D-JBS 145
at u. Therefore, the following inequality holds
(3Rmax + /2)2 (6Rmax + )2

|B | 2
= .
(/2) 2
Hence the optimal solution needs at least k/|B | rounds. This yields
the following theorem.
Theorem 5.23 There exists an approximation algorithm with approx-

imation ratio ( 6Rmax

+ 2
) for 2D-JBS in the setting where any two
base stations are at least away from each other and every base
station can serve only users within distance at most Rmax from it.
General 2D-JBS
When not too much is known about the structure of the problem one
way is to use some greedy strategies and analyze their worst case
behavior. For our 2D-JBS problem we first looked at the greedy al-
gorithm that selects for every unserved user the smallest disk that can
serve the user. The intuition behind this greedy choice is that by us-
ing smaller disks fewer users are blocked and hence more users can
be served in the same round which hopefully leads to fewer rounds.
Even though we couldnt prove a tight bound on the approximation
ratio achieved by this algorithm we found a lower bound construction.
This lower bound construction is presented here and is interesting be-
cause two other greedy algorithms are fooled by this construction.
The greedy algorithms that we present proceed round by round
and in each round decide the subset of disks to be used based on
certain greedy rules.
maximum-independent-set, Amis : In every round this algorithm

schedules the maximum possible subset of users not served
in previous rounds (i.e., it picks a maximum independent set
in the conflict graph of all interference disks corresponding to
user base-station pairs involving unserved users).
smallest-disk-first, Asdf : In every round this algorithm picks as next

disk the one with the smallest radius, from the disks involving
unserved users.
b1 u 1 b0 un bn
u2
b2
. . .
Figure 5.3.8: (n) lower bound construction for Asdf .
fewest-users-in-disk, Alb : In every round this algorithm picks as

next disk the one with the fewest unserved users in it (i.e. the
least blocking disk), from the disks involving unserved users.
Maximum independent set is N P-hard in general graphs and we

dont know if it gets easier in our interference disk graphs. Still it
is interesting to see how does algorithm Amis behave compared to
the other two greedy strategies.
For algorithm Asdf , the simple instance from Figure 5.3.8 shows
that this is not better than an (n) approximation. This construction
has one base station b0 in the middle and n users on a circle centered
at b0 . There are n outer base stations b1 , . . . , bn lying on a halfline
determined by b0 and ui . The construction is done such that the dis-
tance from bi to ui is greater than the distance from b0 to ui . For
this instance algorithm Asdf would use n different rounds to serve
the n users using the middle base station b0 . An optimum algorithm
can serve the users in one time step by assigning ui to base station
bi . However, in this instance all users are placed on a circle around
the base station b0 . As such a configuration seems to be a rare case
in practice, this leads us to consider instances of 2D-JBS in general
position, defined as follows.
Definition 5.24 A set of pairs of points (U, B) R2 R2 are in

general position if no two points from U lie on a circle centered at
some point in B.
For points in general position, the instance of Figure 5.3.9 was

shown to be an (log n) lower bound construction for all three pre-
5.3. 2D-JBS 147
Td
b0
1
2
3 d
u0,1 u0,2 u0,4 u0,2d1

b1 b2 b4 ... b2d1
u2,3 u4,5 u4,6
b3 b5 b6
u6,7
Td1 b7 Td1
Wd1 Wd1 Wd1
Wd
Figure 5.3.9: Outline of the lower bound construction for greedy

algorithms Amis , Asdf and Alb
viously mentioned greedy algorithms in [30]. Here, we give just an

outline of the analysis from [30]. The arrangement of users and base
stations in this construction can be viewed as a tree, where the edges
of the tree are indicated by solid and dashed lines in the figure. The
dashed lines represent a distance , while the solid lines represent
much shorter distances i . The structure of the tree is such
that, after contracting dashed edges, a binomial tree is obtained. The
base stations in the figure are labeled b0 , b1 , . . . in a lexicographically
ordered depth-first search traversal of the tree. Users are vertices of
degree 2 and are adjacent to two base stations; the convention is to la-
bel a user adjacent to bi and bj with ui,j . The aim of the construction
is to force the greedy algorithms use b0 (the base station in the root of
the tree) to serve the d users u0,1 , u0,2 , u0,4 , . . . , u0,2i , . . . , u0,2d1 ,
the children of b0 , in d consecutive rounds, whereas an optimum al-
gorithm would serve them in one round by using the d base stations
b1 , b2 , b4 , . . . , b2i , . . . , b2d1 .
The tree is constructed in such a way that the greedy algorithms
pick the disks formed by base stations and users at distance i in the
i-th round, 1 i d. An optimal algorithm can serve all users on
some level in one round by using the base stations from below, at
the expense of blocking all users on level + 1. Thus, it can serve
all users in two rounds by serving the odd levels in one round and the
even levels in the other. Consequently, the approximation ratio of the
greedy algorithms is (d). The number nd of users in the tree Td can
be calculated by solving the simple recursion nd = 2nd1 + 1 (which
follows from the recursive construction of the tree), where n1 = 1.
This gives n = nd = 2d 1 users and thus d = log (n + 1).
We formulate the lower bound for these greedy algorithms in the
following theorem (the proof can be found in [30]).
Theorem 5.25 There exist instances (U, B) of 2D-JBS in general po-

sition for which the greedy algorithms Amis , Asdf and Alb have ap-
proximation ratio (log n), where n = |U |.
Note that algorithm Amis , which maximizes the number of served

users in every round, achieves approximation ratio O(log n). This can
be shown by applying the standard analysis of the greedy set covering
algorithm.

In this chapter we analyzed the 1D- and 2D-JBS problems that arise in
the context of coordinated scheduling in packet data systems. These
problems can be split into a selection and a coloring problem. In the
one-dimensional case, we have shown that the coloring problem leads
to the class of arrow graphs, for which we have discussed its relation
to other graph classes and algorithms. For the selection problem we
proposed an approach based on LP relaxation with rounding. For the
2D-problem, we have shown its NP-completeness.
The following problems remain still open:
Is the 1D-JBS problem N P-complete or is there a polynomial

time algorithm that solves it?
Are there constant approximation algorithms for the uncon-

strained 2D-JBS problem?
Bibliography
[1] J. Adamek. Foundation of Coding. Wiley, 1991.
[2] F. Adashi, M. Sawahashi, and K. Okawa. Tree structured gen-

eration of orthogonal spreading codes with different length for
forward link of DS-CDMA mobile radio. Electronic Letters,
33(1):2728, January 1997.
[3] F. S. Al-Khaled. Optimal radio channel assignment through the

new binary dynamic simulated annealing algorithm. Interna-
tional Journal of Communication Systems, (11):327336, 1998.
[4] E. Amaldi, A. Capone, and F. Malucelli. Discrete models

and algorithms for the capacitated location problems arising in
UMTS network planning. Proceedings of the 5th international
workshop on Discrete algorithms and methods for mobile com-
puting and communications, pages 18, 2001.
[5] R. Assarut, M. G. Husada, U. Yamamoto, and Y. Onozato.

Data rate improvement with dynamic reassignment of spreading
codes for DS-CDMA. Computer Communications, (25):1575
1583, 2002.
[6] R. Assarut, K. Kawanishi, R. Deshpande, U. Yamamoto, and

Y. Onozato. Performance evaluation of orthogonal variable-
spreading-factor code assignment schemes in W-CDMA. ICC
2002 conference, 2002.
[7] G. Ausiello, P. Crescenzi, G. Gambosi, V. Kann, A. Marchetti-

Spaccamela, and M. Protasi. Complexity and Approximation.
Springer, 1991.
151
152 Bibliography
[8] D. Beckmann and U. Killat. Frequency planning with respect to

interference minimization in cellular radio networks. Technical
report, Vienna, Tech. Rep. COST259, 1999.
[9] D. Beckmann and U. Killat. A new strategy for the application
of genetic algorithms to the channel-assignment problem. IEEE
Transactions on Vehicular Technology, 48(4):12611269, 1999.
[10] J. L. Bentley. Multidimensional divide-and-conquer. Commu-
nications of the ACM, 23(4):214229, 1980.
[11] M. Blum, R.W. Floyd, V. Pratt, R.L. Rivest, and R.E. Tarjan.
Time bounds for selection. Journal of Computer and System
Sciences, 7, 1973.
[12] A. Brandstadt, V.B. Le, and J.P. Spinrad. Graph classes: A sur-
vey. SIAM Monographs on Discrete Mathematics and Applica-
tions. Society for Industrial and Applied Mathematics, Philadel-
phia, PA, 1999.
[13] A.L. Buchsbaum and M.T. Goodrich. Three-Dimensional Lay-
ers of Maxima. In Proceedings of the 10th Annual European
Symposium on Algorithms (ESA02), volume 2461, pages 257
269. Springer-Verlag, 2002.
[14] H. Cam. Nonblocking OVSF codes and enhancing network ca-
pacity for 3G wireless and beyond systems. Intrenational Con-
ference on Third Generation Wireless and Beyond, pages 148
153, Mai 2002.
[15] J.-C. Chen and W.-S. E. Chen. Implementation of an efficient
channelization code assignment algorithm in 3G WCDMA.
2003.
[16] W. T. Chen and S. H. Fang. An efficient channelization code
assignment approach for W-CDMA. IEEE Conference on Wire-
less LANs and Home Networks, 2002.
[17] W. T. Chen, Y. P. Wu, and H. C. Hsiao. A novel code assign-
ment scheme for W-CDMA systems. Proc. of the 54th IEEE
Vehicular Technology Society Conference, 2:11821186, 2001.
[18] J. Chuzhoy and S. Naor. New hardness results for conges-
tion minimization and machine scheduling. In Proceedings of
Bibliography 153
the 36th Annual ACM Symposium on the Theory of Computing

(STOC04), pages 2834, 2004.
[19] M. Cielibak, T. Erlebach, F. Hennecke, B. Weber, and P. Wid-

mayer. Scheduling jobs on a minimum number of machines. In
Proceedings of the 3rd IFIP International Conference on Theo-
retical Computer Science, pages 217230. Kluwer, 2004.
[20] S.A. Cook. The complexity of theorem-proving procedures.

Proceedings of the 3rd Annual ACM Symposium on the Theory
of Computing (STOC71), pages 151158, 1971.
[21] S. Das, H. Viswanathan, and G. Rittenhouse. Dynamic load bal-

ancing through coordinated scheduling in packet data systems.
In Proceedings of Infocom03, 2003.
[22] L. Davis. Handbook of Genetic Algorithms. New York: Van

Nostrand Reinhold, 1991.
[23] M. de Berg, M. van Kreveld, M. Overmars, and

O. Schwarzkopf. Computational Geometry Algorithms
and Applications. Springer, 2000.
[24] K. Deb, S. Agrawal, A. Pratap, and T. Meyarivan. A fast elitist

non-dominated sorting genetic algorithm for multi-objective op-
timization: NSGA-II. in Parallel Problem Solving from Nature
PPSN VI, pages 849858, 2000.
[25] K. Deb, A. Pratab, S. Agarwal, and T. Meyarivan. A fast and

elitist multiobjective genetic algorithm: NSGA-II. IEEE Trans-
actions on Evolutionary Computation, 6:182197, April 2002.
[26] D.P. Dobkin and H. Edelsbrunner. Space searching for inter-

secting objects. Journal of Algorithms, 8(5):348361, 1987.
[27] M. Dorigo and T. Stutzle. Ant Colony Optimization. The MIT

Press, 2004.
[28] T. Erlebach, R. Jacob, M. Mihalak, M. Nunkesser, G. Szabo, and

P. Widmayer. An algorithmic view on OVSF code assignment.
TIK-Report 173, Computer Engineering and Networks Labora-
tory (TIK), ETH Zurich, August 2003. Available electronically
at ftp://ftp.tik.ee.ethz.ch/pub/publications/TIK-Report173.pdf.
154 Bibliography
[29] T. Erlebach, R. Jacob, M. Mihalak, M. Nunkesser, G. Szabo, and

P. Widmayer. An algorithmic view on OVSF code assignment.
in Proc. of the 21st Annual Symposium on Theoretical Aspects
of Computer Science, 2004.
[30] T. Erlebach, R. Jacob, M. Mihalak, M. Nunkesser, G. Szabo,

and P. Widmayer. Joint base station scheduling. Technical Re-
port 461, ETH Zrich Institute of Theoretical Computer Science,
2004.
[31] T. Erlebach, R. Jacob, M. Mihalak, M. Nunkesser, G. Szabo,

and P. Widmayer. Joint Base Station Scheduling. in Proc. of
the 2nd International Workshop on Approximation and Online
Algorithms, 2004.
[32] T. Erlebach and F.C.R. Spieksma. Interval selection: Applica-

tions, algorithms, and lower bounds. Algorithmica, 46:2753,
2001.
[33] R. Fantacci and S. Nannicini. Multiple access protocol for in-

tegration of variable bit rate multimedia traffic in UMTS/IMT-
2000 based on wideband CDMA. IEEE Journal on Selected
Areas in Communications, 18(8):14411454, August 2000.
[34] S. Felsner, R. Muller, and L. Wernisch. Trapezoid graphs and

generalizations, geometry and algorithms. Discrete Applied
Mathematics, 74:1332, 1997.
[35] M. Fischetti, C. Lepschy, G. Minerva, G. Romanin-Jacur, and

E. Toto. Frequency assignment in mobile radio systems using
branch-and-cut techniques. European Journal of Operational
Research, 123:241255, 2000.
[36] L. C. P. Floriani and G. R. Mateus. An optimization model for

the bst location problem in outdoor cellular and pcs systems.
in Proceedings of the 15th International Teletraffic Congress,
1997.
[37] C. M. Fonseca and P. J. Fleming. Genetic algorithms for mul-

tiobjective optimization: Formulation, discussion and general-
ization. in Proc. of the Fifth Int. Conf. on Genetic Algorithms,
pages 416423, 1993.
Bibliography 155
[38] C. E. Fossa Jr. Dynamic Code Sharing Algorithms for IP Qual-

ity of Service in Wideband CDMA 3G Wireless Networks. PhD
thesis, Virginia Polytechnic Institute and State University, April
2002.
[39] C. E. Fossa Jr and N. J. Davis IV. Dynamic code assignment im-

proves channel utilization for bursty traffic in 3G wireless net-
works. IEEE International Communications Conference, 2002.
[40] G.N. Frederickson and S. Rodger. A new approach to the dy-

namic maintenance of maximal points in a plane. Discrete Com-
putational Geometry, 5(4):365374, 1990.
[41] M. Galota, C. Glasser, S. Reith, and H. Vollmer. A polynomial-

time approximation scheme for base station positioning in
UMTS networks. in Proceedings 5th Discrete Algorithms and
Methods for Mobile Computing and Communications, pages
5259, 2000.
[42] M. R. Garey and D. S. Johnson. Computers and Intractability.

Freeman, 1979.
[43] C. Glasser, S. Reith, and H. Vollmer. The complexity of base

station positioning in cellular networks. in ICALP Satellite
Workshops, pages 167178, 2000.
[44] A. Graf, M. Stumpf, and G. Weienfels. On coloring unit disk

graphs. Algorithmica, 20(3):277293, March 1998.
[45] M. Grotschel, L. Lovasz, and A. Schrijver. The ellipsoid

method and its consequences in combinatorial optimization.
Combinatorica, 1:169197, 1981.
[46] J.M. Hernando and F. Perez-Fontan. Introduction to Mo-

bile Communications Engineering. Artech House Publishers,
Boston/London, 1999.
[47] H. Holma and A. Toskala. WCDMA for UMTS. Wiley, 2001.
[48] J. Horn, N. Nafpliotis, and D. E. Goldberg. A niched pareto

algorithm for multiobjective optimization. in Proc. of the First
IEEE Conf. on Evolutionary Computation, 1:8287, 1994.
156 Bibliography
[49] R. Janardan. On the Dynamic Maintenance of Maximal Points

in the Plane. Information Processing Letters, 40(2):5964,
1991.
[50] B. Jaumard, O. Marcotte, and C. Meyer. Mathematical mod-

els and exact methods for channel assignment in cellular net-
works. in Telecommunications Network Planning, chapter 13,
pages 239255, 1999.
[51] M.T. Jensen. Reducing the Run-Time Complexity of Multiob-

jective EAs: The NSGA-II and Other Algorithms. IEEE Trans-
actions on Evolutionary Computation, 7(5):503515, October
2003.
[52] J. Kalvenes and R. Gupta. Hierarchical cellular network design

with channel allocation. Informs Select Proceedings of the 2000
Telecommunications Conference, 2000.
[53] B. Kalyanasundaram and K. Pruhs. Speed is as powerful as

clairvoyance [scheduling problems]. Proceedings of the 36th
IEEE Symposium on Foundations of Computer Science, pages
214221, 1995.
[54] B. Kalyanasundaram and K. Pruhs. Speed is as powerful as

clairvoyance. J. ACM, 47(4):617643, 2000.
[55] A. C. Kam, T. Minn, and K.-Y. Siu. Supporting rate guarantee

and fair access for bursty data traffic in W-CDMA. IEEE Jour-
nal on Selected Areas in Communications, 19(11):21212130,
November 2001.
[56] S. Kapoor. Dynamic Maintenance of Maxima of 2-d Point Sets.

SIAM J. Comput., 29(6):18581877, 2000.
[57] R.M. Karp. Reducibility among combinatorial problems. in

Complexity of Computer Computations, pages 85103, 1972.
[58] L.G. Khachiyan. A polynomial algorithm in linear program-

ming. Doklady Akademii Nauk SSSR, 244:10931096, 1979.
[59] H.T. Kung, F. Luccio, and F.P. Preparata. On finding the max-
ima of a set of vectors. Journal of the ACM, 22(4):469476,
October 1975.
Bibliography 157
[60] J. Laiho, A. Wacker, and T. Novosad. Radio Network Planning

and Optimisation for UMTS. Wiley, New York, 2002.
[61] L.A. Levin. Universal Sorting Problems. Problems of Informa-

tion Transmission, 9:265266, 1973.
[62] K. Mehlhorn and S. Naher. Dynamic Fractional Cascading. Al-

gorithmica, 5:215241, 1990.
[63] K. Mehlhorn and S. Naher. The LEDA platform of combinato-

rial and geometric computing. 1999.
[64] T. Minn and K. Y. Siu. Dynamic assignment of orthogonal

variable-spreading-factor codes in W-CDMA. IEEE Journal on
selected areas in communications, 18(8):14291440, 2000.
[65] L. Monier. Combinatorial Solutions of Multidimensional

Divide-and-Conquer Recurrences. Journal of Algorithms,
1:6074, 1980.
[66] M.H. Overmars and J. Van Leeuwen. Maintenance of Configu-

rations in the Plane. Journal of Computer and System Sciences,
23:166204, 1981.
[67] C.H. Papadimitriou. Computational Complexity. Addison-

Wesley, 1994.
[68] V. Pareto. Cours deconomie politique. 1896.
[69] B. J. Ritzel, J. W. Eheart, and S. Ranjithan. Using genetic al-

gorithms to solve a multiple objective groundwater pollution
containment problem. Water Resources Research, 30(5):1589
1603, 1994.
[70] P. Ross, D. Corne, and H.-L. Fang. Improving evolutionary

timetabling with delta evaluation and directed mutation. in Par-
allel Problem Solving from Nature PPSN III, LNCS 866:556
565, 1994.
[71] A. N. Rouskas and D. N. Skoutas. OVSF codes assignment

and reassignment at the forward link of W-CDMA 3G systems.
PIMRC 2002, 2002.
158 Bibliography
[72] J. D. Schaffer. Multiple objective optimization with vector eval-

uated genetic algorithms. in Proc. of the First Int. Conf. on Ge-
netic Algorithms, pages 93100, 1985.
[73] F.C.R. Spieksma. On the approximability of an interval

scheduling problem. Journal of Scheduling, 2:215227, 1999.
[74] J.P. Spinrad. Efficient Graph Representations, volume 19 of

Field Institute Monographs. AMS, 2003.
[75] N. Srinivas and K. Deb. Multiobjective optimization using non-

dominated sorting in genetic algorithms. Evolutionary Compu-
tation, 2(3):221248, 1995.
[76] G.L. Stuber. Principels of Mobile Communication. Kluwer

Academic Publishers, Boston, 1996.
[77] G. Syswerda and J. Palmucci. The application of genetic algo-

rithms to resource scheduling. in Proc. of the Fourth Int. Conf.
on Genetic Algorithms, pages 502508, 1991.
[78] M. Tomamichel. Algorithmische Aspekte von OVSF Code

Assignment mit Schwerpunkt auf Offline Code Assignmnent.
Semester thesis, Computer Engineering and Networks Labora-
tory (TIK), ETH Zurich, 2004.
[79] K. Tutschku, T. Leskien, and P. Tran-Gia. Traffic estimation

and characterization for the design of mobile communication
networks. Technical report, University of Wurzburg Institute of
Computer Science, 1997.
[80] K. Tutschku, R. Mathar, and T. Niessen. Interference minimiza-

tion in wireless communciation systems by optimal cell site se-
lection. in Proceedings EPMCC99, pages 208213, 1999.
[81] P. van Emde Boas, R. Kaas, and E. Zijlstra. Design and Imple-
mentation of an Efficient Priority Queue. Mathematical Systems
Theory, 10:99127, 1977.
[82] J. van Leeuwen. Handbook of Theoretical Computer Science.

Elsevier Science Publisher, Amsterdam, 1990.
[83] D. A. Van Veldhuizen and G. B. Lamont. Multiobjective opti-

mization with messy genetic algorithms. in Proceedings of the
Bibliography 159
2000 ACM Symposium on Applied Computing, pages 470476,

2000.
[84] V.V. Vazirani. Approximation Algorithms. Springer, 2001.
[85] N. Weicker. Qualitative No Free Lunch Aussagen fur Evolu-

tionare Algorithmen. Gottingen: Cuvillier, 2001.
[86] N. Weicker, G. Szabo, K. Weicker, and P. Widmayer. Evolu-

tionary Multiobjective Optimization for Base Station Transmit-
ter Placement with Frequency Assignment. IEEE Transactions
on Evolutionary Computation, 7(2):189203, 2003.
[87] D. West. Introduction to Graph Theory. Prentice Hall, 2nd

edition, 2001.
[88] D. H. Wolpert and W. G. Macready. No free lunch theorems

for optimization. IEEE Trans. on Evolutionary Computation,
1(1):6782, 1997.
[89] F.F. Yao. On finding the maximal elements in a set of plane vec-
tors. Technical report, Computer Science Dep. Rep., University
of Illinois at Urbana-Champaign, 1974.
[90] T. Yu and P. Bentley. Methods to evolve legal phenotypes.

in Parallel Problem Solving from Nature PPSN V, LNCS
1498:280291, 1998.
[91] X. Zhou and T. Nishizeki. Efficient algorithms for weighted

colorings of series-parallel graphs. in 12th International Sym-
posium on Algorithms and Computation, pages 514524, 2001.
[92] E. Zitzler, M. Laumanns, and L. Thiele. SPEA2: Improving the

strength pareto evolutionary algorithm for multiobjective opti-
mization. in Proceedings of Evolutionary Methods for Design,
Optimisation and Control, 2002.
[93] E. Zitzler and L. Thiele. Multiobjective evolutionary algo-

rithms: A comparative case study and the strength Pareto
approach. IEEE Transactions on Evolutionary Computation,
3(4):257271, 1999.
160 Bibliography
[94] E. Zitzler and L. Thiele. Multiobjective evolutionary algo-

rithms: A comparative case study and the strength pareto ap-
proach. IEEE Transactions on Evolutionary Computation,
3:257271, November 1999.
Curriculum Vitae
Gabor Vilmos Szabo
born on December 19, 1976 in Zalau, Romania
19911995 High school in Zalau, Romania
19952000 Studies at the Technical University of Cluj-Napoca,

Romania
Computer Science
Degree: Bachelor in Computer Science
20002005 PhD student at Swiss Federal Institute of Technol-

ogy, Switzerland
Theoretical Computer Science

Gabor Szabo - Diss - ETH - 16207 PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Gabor Szabo - Diss - ETH - 16207 PDF

Uploaded by

Copyright:

Available Formats

DISS. ETH No.

A dissertation submitted to the

accepted on the recommendation of

of codes to serve a new request. We show that the problem is N P-

Neuzuweisungen moglichst klein halten. Wir betrachten das Ein-

2 Base Station Placement with Frequency Assignment 15

2.5 Conclusions and Open Problems . . . . . . . . . . . 39

3 Maxima Peeling in d-Dimensional Space 49

4 OVSF Code Assignment 75

4.4.3 Minimizing the Number of Blocked Codes . 102

5 Joint Base Station Scheduling 109

In one way or another mobile phones have changed everyones life.

1.1 GSM and UMTS System Planning and

cisely stated network design objectives and requirements. There ex-

Base Station Transmitter (BST) location problem. The RF de-

Frequency Channel Assignment (FCA) problem. Since the avail-

Network deployment objectives. The network deployment ob-

The conventional design procedure for cellular systems is based

analytical approach consists of four phases: radio network definition,

aration inside one cell is achieved by assigning orthogonal spreading

1.2 Short Theory of Algorithms and Com-

Definition 1.1 A problem D is called a decision problem if the set

From a practical point of view, optimization problems are more im-

Definition 1.2 An optimization problem is characterized by a quad-

I is the set of instances of ;

S is a function that associates to any input instance x I the

m is the measure (objective) function, defined for pairs (x, y)

g {M IN, M AX} specifies whether is a minimization or

Notions from Complexity Theory

In this thesis we are interested in the complexity classes P and

A fundamental problem in theoretical computer science is whether

Definition 1.3 Let N P, we say that is N P-complete if any

Definition 1.4 Given an optimization problem and an approxima-

In this thesis we provide approximation algorithms with guaran-

Definition 1.5 A request-answer game is defined by (R, A, C), where

answer sets and C = c1 , c2 , . . . is a sequence of cost functions with

In this thesis we are interested only in deterministic online algorithms

Definition 1.6 A deterministic online algorithm ALG for the request-

An optimal offline algorithm is an algorithm that has all the knowl-

Definition 1.7 Let c 1 be a real number. A deterministic online

One important observation is that we impose no restriction on the

1.3 Summary of Results

ter 2); maintaining the layers of maxima in d-dimensional space (Chap-

In Chapter 2 we propose a new solution to the problem of posi-

The evolutionary algorithm used in Chapter 2 raised an interesting

tion 3.3 we present a divide-and-conquer approach similar to the one

The natural next step after analyzing GSM network optimization

Another interesting optimization problem that arises in UMTS

Base Station Placement

number of channels. For a good quality of service, network providers

2.1.1 Related Work

sign issues are of major importance concerning the evolutionary al-

2.1.2 Model and Notation

the cost for the transmitters

We define formally the parameters of the problem as follows.

The co-channel interference occurs between neighboring cells

The adjacent-channel interference appears inside one or be-

Figure 2.1.1: Example for co-channel and adjacent-channel interfer-

The set of all feasible solutions FS with respect to a set of demand

The cost of a feasible solution S FS is the sum of the costs of its

2.1.3 Summary of Results

to handle multiple objectives. The concrete realization of our evo-

2.2 Design Criteria

l(p) := max {1, max {1 + l(q) | q S q p}}.