Parameterized Complexity of

Geometric Problems

PANOS GIANNOPOULOS1,*, CHRISTIAN KNAUER2 AND SUE WHITESIDES3

1Institut fur Informatik, Humboldt-Universitat zu Berlin, Unter den Linden 6, 10099 Berlin, Germany2Institut fur Informatik, Freie Universitat Berlin, Takustraße 9, D–14195 Berlin, Germany

3School of Computer Science, McGill University, 3480 University Street, Montreal, Canada H3A 2A7

*Corresponding author: panos@informatik.hu-berlin.de

This paper surveys parameterized complexity results for hard geometric algorithmic problems.

It includes fixed-parameter tractable problems in graph drawing, geometric graphs, geometric

covering and several other areas, together with an overview of the algorithmic techniques used.

Fixed-parameter intractability results are surveyed as well. Finally, we give some directions for

future research.

Keywords: Computational geometry, graph drawing, Parameterized algorithms

Received 5 February 2007; revised 31 March 2007

1. INTRODUCTION

This paper surveys parameterized complexity results for

NP-hard geometric problems. Geometric problems arise fre-

quently in application domains as diverse as computer

graphics [1], computer vision [2–4], VLSI design [5],

geographic information systems [6, 7], graph drawing [8]

and robotics [9, 10], and typically involve (sets of) geometric

objects, such as, points, line segments, balls or polytopes,

which usually lie in some metric space. Designing efficient

algorithms and data structures for such problems is the main

focus in the field of computational geometry [11–13].

Many geometric problems can be formulated as combina-

torial optimization problems where the objective is to maxi-

mize or minimize a function subject to constraints induced

by a given collection of geometric objects; by exploiting the

geometric nature of such problems, one can obtain faster

and simpler algorithms. Geometric optimization has been a

topic of extensive research, and many general techniques

have been developed that yield efficient polynomial-time

algorithms for a wide range of problems (see the excellent

survey by Agarwal and Sharir [14]).

1.1. Polynomial-time approximation schemes

In order to cope with NP-hard geometric optimization

problems, researchers have, so far, mainly resorted to the tra-

ditional toolkit of approximation algorithms. A polynomial-

time approximation scheme (PTAS) for a minimization

problem is an algorithm, or rather a sequence of algorithms,

which, given any e . 0 and any problem instance of size n,

produces a solution for the problem with cost at most (1 þ

e) times the cost of an optimum solution in O(nf(1/e)) time,

where f is an arbitrary computable function (for maximization

problems, the cost of the solution produced is at least (1 2 e)

times that of an optimum solution). A PTAS is called effici-

ent (EPTAS), if it is uniformly polynomial, i.e., it runs in

O(f(1/e) . nc) time for every e, where c is a constant indepen-

dent of e. The ultimate approximation scheme is an EPTAS

where f is polynomial; such a scheme is called fully PTAS

(FPTAS).

PTASs have been found for many important geometric pro-

blems (see the surveys by Bern and Eppstein [15] and Arora

[16]). While some of these schemes are efficient [Euclidean

traveling salesman problem (TSP) problem [17], minimum

k-median problem [18]], others exhibit prohibitively high-

running times even for moderate error values [19]. Moreover,

there are also quite a few problems for which no PTAS is

known, e.g. minimum weight triangulation (MWT) [20], or

likely to exist (under standard complexity theoretic assump-

tions), e.g. minimum k-center problem (when k is part of the

input) [21, 22].

1.2. Parameterized complexity

Parameterized complexity theory offers an alternative frame-

work for the study of hard algorithmic problems by measuring

their complexity in terms of one or more parameters, explicitly

or implicitly given by their underlying structure, in addition to

THE COMPUTER JOURNAL, 2007

# The Author 2007. Published by Oxford University Press on behalf of The British Computer Society. All rights reserved.For Permissions, please email: journals.permissions@oxfordjournals.org

doi:10.1093/comjnl/bxm053

The Computer Journal Advance Access published July 27, 2007

the problem input size. The main idea is to devise exponential-

time exact—as opposed to approximation algorithms for

NP-hard problems, confining exponentiality to the parameters.

In concrete applications, such parameters are hoped to take

relatively small values, thus, resulting in affordable algori-

thms. For an introduction to the field of parameterized com-

plexity theory, we refer the reader to the recent textbooks by

Flum and Grohe [23] and Niedermeier [24], in addition to

the first, classic work of Downey and Fellows [25]. We

review some basic definitions here.

A problem with input instance of size n and with a non-

negative integer parameter k is fixed-parameter tractable

(FPT) if it can be solved by an algorithm that runs in

O(f(k) . nc) time, where f is a computable function depending

only on k and c is a constant independent of k. The class of

all FPT problems is the parameterized complexity analog

of P. Parameterized complexity theory provides a set of

general algorithmic techniques for proving fixed-parameter

tractability, ranging from bounded search trees and kerneliza-

tion methods to color coding and dynamic programming on

tree decompositions. Such techniques have successfully been

used for a variety of parameterized algorithmic problems in

graph theory, logic and computational biology.

Parameterized complexity theory also provides a frame-

work for establishing fixed-parameter intractability. For this

purpose, a whole new (infinite) hierarchy of complexity

classes has been introduced, the ‘W-hierarchy’, with FPT

being its lowest class, and hardness is sought via suitable

reductions, which preserve fixed-parameter tractability

between parameterized problems. Hardness for some level

of the hierarchy can be thought as the parameterized complex-

ity analog of NP-hardness, and, as in classical complexity

theory, intractability results are conditional and, thus, serve

as relative lower bounds. The working assumption for para-

meterized complexity is that all levels of the W-hierarchy

are pairwise distinct. For example, a problem that is

W[1]-hard for some parameterization is not FPT for this para-

meterization unless FPT ¼ W[1].

Every optimization problem has a standard parameteriza-

tion, where the parameter is just an upper or lower bound on

the value of the objective function, that is, it measures the

size or the quality of the solution given by the objective func-

tion. If an optimization problem has an EPTAS, then its stan-

dard parameterization is in FPT [26–28]. Hence, by showing

that the standard parameterization of an optimization problem

is hard for some level of the W-hierarchy, we provide strong

evidence that this optimization problem does not admit an

EPTAS. The survey by Marx [29] discusses many more

aspects of the interplay between the theories of parameterized

complexity and approximation algorithms. While most

tractability and intractability results involve standard parame-

terizations of optimization problems, one strength of parame-

terized complexity theory lies in its ability to accommodate a

variety of other types of problems as well as different

parameterizations. For example, finding an optimal vertex

cover in a graph is in FPT when parameterized by the size

of the cover (standard parameterization), and also when para-

meterized by the tree width of the graph.

Geometric problems often involve a variety of natural para-

meters that measure certain properties of the input objects.

However, only a small number of NP-hard geometric pro-

blems have been studied within the framework of parameter-

ized complexity theory so far. The field is still in its infancy

and the results are rather scattered. We believe that this is

mainly due to different current research foci of the commu-

nities involved, rather than the limited applicability of para-

meterized complexity to geometric problems. This is well

illustrated with the example of the MWT problem (see also

Section 2.5.1): given a set of n points in the plane, one asks

for a triangulation with the minimum total length of edges.

This is a well-known problem in computational geometry

whose complexity status was unknown for more than three

decades, until it was recently proved to be NP-hard and not

to admit an FPTAS [30]. As already mentioned earlier, no

PTAS is known for this problem. However, the problem is

FPT when parameterized with the number k of points in the

interior of the convex hull of the input points. The first

known such algorithm runs in O(6kn5 log n) time [31]; succes-

sive improvements brought the running time down to O(4kkn4)

[32], O(2kkn3þ n3) [33] and O(2c

ffiffiffikp

log kk2n3) [34].

This paper is organized as follows. Section 2 presents FPT

geometric problems, while Section 3 presents intractability

results. We conclude with a few general research directions

in Section 4.

2. FPT GEOMETRIC PROBLEMS

2.1. A retrospective

Using parameters in order to achieve faster algorithms for geo-

metric problems that are nevertheless in P has always been a

common practice. Typical parameters for this purpose

include the number of (non)convex corners, the diameter of

a point set or the minimum inter-point distance in a point

set, and measures of how ‘slim’ or ‘fat’ the objects are. In a

few cases, special attention has been given to the actual depen-

dence on parameters that can take small values in practice.

One such famous example is Megiddo’s algorithm [35] for

linear programming in Rd with n constraints, where d, i.e.

the number of variables, is the parameter, and which runs in

O(22d

n) time1; the running time was later substantially

improved to dO(d)n by Dyer and Frieze [36], Chazelle and

Matousek [37], and to O(d2n þ eO(ffiffiffidp

In dÞ) (randomized) by

1When d is bounded, linear programming can be solved in strongly poly-

nomial time, i.e. time that depends only on n and not on the binary represen-

tation of the input; when d is unbounded, only weakly polynomial time

algorithms are known.

Page 2 of 13 P. GIANNOPOULOS

THE COMPUTER JOURNAL, 2007

Matousek et al. [38] using some quite advanced techniques

from computational geometry.

What about NP-hard geometric problems? After identifying

a problem as such, much effort is often put into getting fast

approximations, while many times little or nothing is said

about solving the problem exactly even by the trivial brute

force exponential algorithm. In the course of writing this

survey, we were able to spot a couple of early algorithms

which can now be seen as being in FPT.

One such interesting example is the following. Deineko and

Woeginger [39] gave an O(kln2)-time dynamic programming-

based algorithm for the convex-hull-and-l-line Euclidean TSP,

where k points lie on l almost parallel line segments in the

interior of the convex hull of a total of n points, such that

the supporting lines of all these segments intersect the hull

into two common edges. Thus, this problem is in FPT when

parameterized with respect to the number of points k and the

number of lines l. This result has been recalled much later

by Deineko et al. [40] who again used dynamic programming

to give an O(2kk2n)-time algorithm for a more general TSP

problem where k is the number of points in the interior of

the convex hull, but with no restriction on their positions

(see Section 2.5.3).

There are several NP-hard problems where important

classes of input instances are directly characterized by a par-

ticular parameter. For some of these problems, researchers

have been able to give algorithms whose running time is

some polynomial the degree of which is independent of the

parameter, which is considered a constant. However, some-

times such constants are not mentioned explicitly, and some-

times they can be of rather ‘astronomical’ value. This

situation is well depicted in the following two problems

drawn from computational topology; such problems arise fre-

quently in applications where one needs to examine topo-

logical as well as geometric properties of the input objects.

Mohar [41] presented a linear time algorithm for the follow-

ing problem: given an arbitrary fixed surface S, i.e. of fixed

genus, and a graph G, can G be embedded in S? The algori-

thm assumes the standard RAM with uniform cost measure

(for a discussion on models of computation see the next para-

graph), and thus, the problem is FPT with respect to the

genus of the surface S. Unfortunately, the actual dependence

on the genus is nowhere to be seen. On the other hand,

Chambers et al. [42] recently showed that the problem of

finding the shortest splitting cycle on a combinatorial

surface is not only NP-hard, but also FPT with respect to

the genus of the surface. The dependence on the genus is

given and the algorithm runs in gO(g)n2 log n time (see

Section 2.6). This is probably the first time that ‘fixed-

parameter tractability’ appeared in an article in a major

computational geometry conference.

It is reasonable to believe that many more FPT problems

could be found scattered in the literature. Even if the algori-

thms seem to be trivial, one can gain valuable insight by

asking the following questions: Which properties made the

problem tractable? Which parameters were used? Were the

results obtained using techniques that are now considered

standard in parameterized complexity, or by some different

approach? In the latter case, can the results be improved by

using the standard techniques? At this point the reader

should be cautious: many results in computational geometry

assume real RAM, a much stronger model of computation

than the standard RAM adopted in parameterized complexity

theory. Extending parameterized complexity theory to accom-

modate other models of computation is a current research issue

and one should be careful before claiming (in)tractability of

geometric problems.

2.2. Independent set on geometric intersection graphs

We start with a few definitions that will be needed in other

sections as well. A topological graph G(V, E) is a graph

embedded in the plane such that any two edges intersect in

at most a finite number of points. A geometric graph is a

topological graph where the edges are straight-line segments.

The intersection graph of a set of geometric objects S is a

graph G(V, E), with a one-to-one mapping from S to V, and

with two vertices being connected if and only if the corres-

ponding two objects intersect. When embedded in the

plane, such a graph need not necessarily be a geometric

graph.

2.2.1. Independent set on disk graphs

Consider the following problem: given a collection of n disks

in the plane with bounded radius ratio and l-precision, i.e. all

disks have radius in the range [1, s] and all centers are pair-

wise at least l . 0 apart, is there a set of k non-intersecting

disks? Basically, the bounded radius property says that no

disk has arbitrarily small radius, while the l-precision prop-

erty asserts that no two centers are arbitrarily close. For

fixed s and l, Alber and Fiala [43] gave an 2O(ffiffiffikp

)þ

nO(1)-time algorithm for this problem. Their algorithm is

based on kernelization.

2.2.1.1. Kernelization. The main idea of kernelization is

to pre-process the input instance in order to reduce its size

by removing its ‘easy’ parts before actually trying to solve

the problem. This can lead to considerable speedups. Of

course this idea is nothing new, but kernelization systematizes

pre-processing (see the survey by Niedermeier [44]). For-

mally, let L be a parameterized problem, i.e. L consists of

pairs (I, k), where I is the problem instance and k is the para-

meter. A polynomial time computable function K: (I, k)!

(I0, k0) is a problem kernel reduction if there is a computable

function g: N! N such that (i) (I, k) [ L if and only if (I0,

k0) [ L, and (ii) jI0j� g(k0) and k0 � k. The instance (I0, k0) is

called the problem kernel with g(k0) being its size. It has

PARAMETERIZED COMPLEXITY OF GEOMETRIC PROBLEMS Page 3 of 13

THE COMPUTER JOURNAL, 2007

been shown that a parameterized problem is in FPT if and only

if it admits a reduction to a problem kernel.

THEOREM 2.1. Independent set on disk graphs with

bounded radius ratio s and l-precision admits a reduction

to a linear problem kernel.

Proof. For a collection of disks D ¼ fD1, . . . , Dng in the

plane, let GD ¼ (VD, ED) be the intersection graph of D, i.e.

VD ¼ fv1, . . . ,vng and ED ¼ fvivjjDi > Dj = ;g. A disk

graph GD is given together with its representation, i.e. the col-

lection of disksD, and a natural embedding in the plane with vi

lying at the center of Di (see Fig. 1). Also, let m(GD) ¼

m(D) ¼ m(< D) be the space covered by the union of disks

in D, where m( . ) is the standard Lebesgue measure.

First, the problem is reduced to a ‘geometric’ problem

kernel, where the size of the kernel is bounded by O(k),

when measured by m( . ). This is done by a simple volume

argument, which uses the property of bounded radius ratio.

First, if m(D) . 9ps2k, then a greedy algorithm can easily

select k pairwise disjoint disks, since the disks representing

the neighbors of any vertex v [ VD can occupy an area of at

most 9ps2. Second, when m(D) , pk, there is no set of k dis-

joint disks since any such set needs space of at least pk. Other-

wise, pk � m(GD) � 9p s2k and the input graph GD is

basically the kernel. It can be computed in nO(1) time, which

is needed to compute m(GD).

Next, using the l-precision property, the geometric problem

kernel is converted to a proper problem kernel by bounding the

size of its vertex set jVDj by m(GD). This is done in the follow-

ing way: when l � 2 then we have that m(GD) � (p/4)l2jVDj

since the disks with radius l/2 around all centers of disks in Dare pairwise disjoint and contained in the area covered by the

original disks; when l . 2 then of course m(GD) � pjVDj. In

both cases, this leads to a problem kernel of size ck, where c is

a constant depending on s and/or l. A

Since the problem admits a problem kernel, it is in FPT:

trivially checking all possible k subsets of the kernel for inde-

pendence leads to an O(kO(k)þ nO(1))-time algorithm. A faster

algorithm can be obtained using graph separators.

2.2.1.2. Graph separators. A vertex separator VS # V of

an undirected graph G(V, E) separates V into two parts VA,

VB for which (i) VA < VS < VB ¼ V and (ii) no edge in E con-

nects a vertex of VA to a vertex of VB. The triple (VA, VS, VB) is

called a separation of G. For a function f : N! Rþ and a

graph class G, an f( . )-vertex separator theorem on G for

the measure j . j and some constants a , 1, b . 0 is a

theorem asserting that for any G [ G there is a separation

(VA, VS, VB) of G such that (i) jG[VS]j � b . f(jGj) and (ii)

jG[VA]j, jG[VB]j � a . jGj, where G[X] denotes the subgraph

of G induced by the set X # V.

Alber and Fiala [43] gave affiffi�p

-separator theorem for the

counting measure (with constants a ¼ 3/4 and b ¼ O(s/l))

on the class of disk graphs with bounded radius ratio and

l-precision. Moreover, Alber et al. [45] proved that the para-

meterized independent set problem (as well as other ‘glue-

able’ graph problems) on a graph class G that admits affiffi�p

-separator theorem for the counting measure can be

solved in O(2ffiffiffikp

þ TK (n, k)) if it has a linear size problem

kernel that can be constructed in TK (n, k) time. Combining

these two ideas with the problem kernel described earlier

leads to an O(2ffiffiffikp

þ nO(1))-time algorithm.

2.2.2. Independent set on segment graphs

Marx [46] showed that the independent set problem on

segment graphs is in FPT when parameterized with the

number of the different directions of the segments: given a

set of n segments with at most d different directions, one

can decide whether there are k pairwise disjoint segments in

2O(k2d2 log d) n log n time. For the same problem, Kara and

Kratochvıl [47] gave a faster algorithm, which runs in

O(d2kk9dkþ2þ n2

þ k3dmn) time, where m is the number of

the edges of the segment graph, and which works also

in the case where only the intersection graph is given (not

the segments themselves). Both algorithms are based on

kernelization.

2.3. Graph drawing problems

We begin with an illustrative example showing the application

of kernelization and bounded search tree techniques to

a problem in layered graph drawing, namely, 2-layer

planarization.

A 2-layer drawing of a bipartite graph is one that positions

the vertices on two parallel lines and draws edges as straight

line segments between endpoints. The endpoints of an edge

must lie on different layers. A graph is said to be biplanar if

it has a 2-layer drawing without edge crossings, and a subset

E0(G) of the edges of a graph G is said to be a biplanarizing

set if its removal from G results in a biplanar graph.

The 2-layer planarization problem is as follows: given a

graph G (not necessarily bipartite) and a positive integer k,

does G have a biplanarizing set of size at most k?FIGURE 1. A disk graph with a straight-line embedding in the

plane.

Page 4 of 13 P. GIANNOPOULOS

THE COMPUTER JOURNAL, 2007

For the related 1-layer planarization problem, an ordered

assignment of vertices to the top layer is given, and one asks

if it is possible to remove at most k edges so that the vertices

on the second layer can be ordered so that no edges cross.

Dujmovic et al. [48] showed that both problems are in FPT

and gave an O(3kjGj)-time algorithm for the 1-layer planariza-

tion problem and an O(k6kþ jGj)-time one for the 2-layer pla-

narization problem. We describe the main ideas of their

2-layer planarization algorithm in the following four sections.

2.3.1. Forbidden subgraphs

Clearly, cycles cannot be drawn on two layers without edge

crossings. Another graph with this property is the 2-claw.

This consists of a vertex v of degree 3 (the center of the

2-claw), to which are attached three neighbors of degree 2;

each of these in turn is joined to a leaf node. Thus, there are

six nodes in addition to the center, v. It is easy to see that if

a graph contains a 2-claw as a subgraph (not necessarily

induced), then it cannot be drawn on two layers without

edge crossings (see Fig. 2).

In fact, it can be shown that the absence of cycles and

2-claws characterizes biplanar graphs: G is biplanar if and

only if it contains no cycles and no 2-claws.

A wreath of G is a connected component consisting of a

cycle with some leaves attached. A pendant wreath of G is

similar to a wreath, except that it contains a unique ‘attach-

ment’ vertex w that is connected to one or more non-leaf ver-

tices of G that do not lie on the cycle of the pendant wreath.

Thus, w is a cut vertex for G.

First, as a prelude to kernelization, wreaths and pendant

wreaths will be destroyed by choosing certain edges from

them to go into a biplanarizing set. This will reduce the

initial budget, k. Then, the remaining graph will be shrunk

to a kernel, without affecting the presence of 2-claws and

cycles.

2.3.2. Destroying wreaths and pendant wreaths

To destroy wreaths and pendant wreaths, one can choose a set

of edges, one from each wreath and pendant wreath, for

removal from G. It can be shown that it is possible to do

this so that only one edge is removed from each wreath or

pendant wreath, and so that the set of edges removed is con-

tained in at least one biplanarizing set for G of minimum

size. (A pendant wreath whose cycle has three nodes will con-

tribute the cycle edge not incident to its attachment vertex; a

pendant wreath whose cycle has length .3 will contribute a

cycle edge adjacent to its attachment vertex.) With these

edges removed from G, and the budget k reduced accordingly

to k0, one proceeds to the kernelization step, knowing that the

graph no longer contains wreaths or pendant wreaths.

2.3.3. Shrinking the graph to a kernel

A convenient fact for generating a kernel for this problem is

the following: there is always a biplanarization set of

minimum size that contains no leaf edges (we omit the

proof). This means that we can first simplify the graph by

replacing all the leaf edges at a vertex v of degree .1 by a

single leaf edge. This single edge may belong to a 2-claw. If

so, the original graph may have had many 2-claws, containing

various of the leaf edges attached to v. However, according to

the fact above, there is a biplanarization set of minimum size

that destroys all such 2-claws by removal of some non-leaf

edge. Thus, retaining a single leaf edge at v represents the

possibility that v may belong to a 2-claw in which v is adjacent

to the center.

Once the leaf edges are amalgamated in this way, one pro-

ceeds to shrinking long caterpillar paths. A caterpillar path is

an induced subgraph consisting of a path with leaf edges pos-

sibly attached to some interior nodes of the path. One or both

endpoints of the path, but no intermediate path nodes, may

be joined to other nodes of the graph. Note that an internal

node on a caterpillar path cannot serve as the center of a

2-claw, so 2-claws can only touch nodes within distance 2

from the end of a caterpillar path. For this reason, leaves

attached to interior points at distance 2 or more from the

path endpoints can be removed without affecting the presence

of 2-claws. Finally, the path, stripped of these leaves, can be

shortened without affecting the presence of 2-claws and

cycles (see Fig. 3).

Finally, it can be shown that either this reduced graph does

not have a biplanarizing set of size within the remaining

budget, in which case an algorithm looking for a biplanarizing

set can terminate, or it has at most 20k edges, in which case it

may be worthwhile to continue the search. Any small biplanari-

zing set for the reduced graph (together with the edges chosen

to destroy wreath components and pendant wreaths) points

out a corresponding biplanarizing set for the original graph.

At this point, one could simply test each of the 20kk0

� �sets of

k0 edges to see if one of them is a biplanarizing set for GFIGURE 2. Two forbidden subgraphs of biplanar graphs: a 2-claw

and a cycle.

PARAMETERIZED COMPLEXITY OF GEOMETRIC PROBLEMS Page 5 of 13

THE COMPUTER JOURNAL, 2007

(here, k0 is k reduced by the number of edges chosen to destroy

wreaths and pendant wreaths). With more care, one can obtain

an algorithm based on these kernelization ideas having

running time in O(ffiffiffikp

. 17kþjGj).

2.3.4. Bounded search tree approach

Further improvement is possible by applying a bounded search

tree approach to the shrunken, kernel graph. Rather than

testing the sets of k0 edges in a brute force manner, one

creates a search tree whose nodes correspond to subgraphs

of the kernel graph, together with associated budgets

reduced by the node’s depth in the search tree. At each internal

tree node, one looks for a vertex v of the subgraph of the kernel

graph associated with this tree node such that v has at least

three non-leaf neighbors. Then exploring the current subgraph

of the kernel graph from this vertex, one easily finds either a

2-claw with center v or a cycle of length 3 or 4 containing v

(see Fig. 4).

Let C denote the edges of the 2-claw or cycle found. Now,

one creates jCj children for the search tree node, one for each

of the edges in C, since this cycle or 2-claw must be destroyed

in order to biplanarize the graph. The graph at a child node is

the graph at the parent, with an edge of C removed, and the

budget at the child node is one less than that for the parent.

This search tree can have depth no greater than k0 � k,

where k0 is the budget for the kernel graph. Since each internal

node has at most six children, this gives a search tree of size at

most 6k and a running time in O(k . 6kþ jGj).

THEOREM 2.2. Given a graph G and an integer k . 0,

the 2-layer planarization problem on G can be solved in

O(k . 6kþ jGj) time.

2.3.5. Experimental results

Experiments of Suderman and Whitesides [49] with an

implementation based on the approach given above, after

further refinements and additions, gave promising results.

The implementation could find optimum solutions provided

the biplanarizing set had size at most about k ¼ 18, compar-

able to results based on integer linear programming appro-

aches. The running time was reduced to O(6kþ jGj) by

detecting a forbidden subgraph (if one exists) at each node

in the search tree in constant time.

2.3.6. 1- and 2-layer minimization

The 2-layer minimization problem is defined as follows: given

a bipartite graph G, and an integer k, does G admit a 2-layer

drawing with at most k edge crossings? Again, if a permutation

of the vertices in one layer is fixed, then the problem becomes

that of 1-layer minimization. The latter can be solved in

O(1.4656kþ kn2) time [50], an improvement over the earlier

O(fkn2)-time algorithm by Dujmovic and Whitesides [51],

where f is the golden ratio. For the 2-layer minimization

problem, the fastest algorithm runs in O(232(2þ2k)3

n) time [52].

2.3.7. h-layer problems

The 1- and 2- layer problems can be viewed as special cases of

h-layer problems. A well-known approach for drawing certain

types of graphs, particularly directed acyclic graphs, is to

assign each node to one of h layers, and then to seek permu-

tations of the nodes within each layer that reduce the

number of crossing points (giving a layered crossing minimiza-

tion problem), or that attribute the crossings to a small number

of edges whose removal leaves the drawing crossing free

(giving a layered planarization problem). In particular, the

‘Sugiyama method’, due to Sugiyama et al. [53], fixes a per-

mutation of the nodes assigned to the top layer, then seeks a

good permutation for layer 2 with respect to layer 1, etc. It

sweeps up and down the h layers, adjusting the permutation

of the current layer at each step. While node assignment to

FIGURE 4. A vertex that has three non-leaf neighbors is either the

center of a 2-claw or lies on a cycle of length 3 or 4.

FIGURE 3. Shrinking a long path while preserving 2-claws and

cycles.

Page 6 of 13 P. GIANNOPOULOS

THE COMPUTER JOURNAL, 2007

layers is typically done in a separate, preceding step, it is of

course possible to ask for the layer assignments and the per-

mutations within each layer to be specified all at once.

Dujmovic et al. [52] showed that various h-layer problems

are in FPT, where h is an additional parameter. The running

times are in O(232(hþ2k)3

n) and are rather impractical.

2.3.8. General crossing minimization

The crossing number of a graph is the minimum possible

number of edge crossings when the graph is drawn nicely in

the plane. Here the edges need not be drawn straight, but the

drawing must satisfy the usual, expected properties. For

example, for each pair of distinct edges of the graph, the corres-

ponding curves must intersect in at most one interior point.

In answer to a question from the book by Downey and

Fellows, Grohe [54] found an algorithm with running time

in O(f(k) . n2) to test whether the input graph has crossing

number at most k.

2.4. Configurations with few crossings in geometricgraphs

Knauer et al. [55] studied the following problem: given a

graph G ¼ (V, E) together with an embedding E in the plane,

compute a certain subgraph of G with the minimum number

of crossings in the embedding E. A crossing is defined as a

pair of edges that intersect at a common point. They con-

sidered subgraphs such as spanning trees, fixed source and

target paths (s-t paths), cycles, matchings (with given cardi-

nality), and k-factors, i.e. k-regular spanning subgraphs for

k [ f1, 2g. They showed that all these problems are in FPT

when parameterized with the number of crossings in the

embedding E of the input graph G.

To illustrate the approach, we show that the problem of

deciding if G has a spanning tree without crossings (in the

embedding E) is in FPT when parameterized with the

number of crossings k in the embedding E: since G has a

crossing-free spanning tree if and only if it has a crossing-free

planar spanning graph it is sufficient to examine all maximal

crossing-free subgraphs of G and test if one of them is

connected. This can be done as follows.

(i) Remove all edges X that participate in a crossing from

G. The resulting graph G0 is crossing-free.

(ii) For all maximal crossing-free subsets, H of edges from

X check if the graph G0 < H is connected.

It can easily be shown that the number of maximal crossing-

free subsets of edges from X is 2k, so the algorithm runs in

O((m þ n) þ 2kn) time.

Note that this problem admits a kernel of size O(k): if G0 has

more than k þ 1 connected components, we can immediately

conclude that we cannot add k edges to make it connected,

so in the second step we can actually shrink the connected

components of G0 to a single vertex and therefore only have

to consider a graph G00 with O(k) edges and vertices in the

connectivity test.Again G00 < X has at most 2k crossing-free

subgraphs and so the algorithm runs in O((m þ n) þ k2k) time.

2.5. Triangulations, convex partitions, TSP, and

‘distance from triviality’

This section deals with optimization problems on planar point

sets, parameterized with the the number of inner points, i.e.

points in the interior of the convex hull. This is a quite

novel parameterization, which follows the general idea of

‘distance from triviality’ [56]: some problems are solvable

in polynomial time when the points are in convex position,

and hence, the number of inner points as a parameter inter-

polates from triviality when there is no inner point to intract-

ability in the general case.

2.5.1. Minimum weight triangulation

An MWT of a point set is a triangulation with the minimum

total length of edges. The problem was only recently shown

to be NP-hard by Mulzer and Rote [30].

For a set P of n points in the plane, with k inner points,

Hoffmann and Okamoto [31] gave an O(6kn5 log n)-time

algorithm to compute an MWT of P. This approach was

later improved by Spillner [33] and Borgelt et al. [32] to run

in time O(2kkn3þ n3) and O(4kkn4), respectively. A further

improvement was recently obtained by Knauer and Spillner

[34], whose algorithm runs in O(2cffiffiffikp

log kk2n3) time and

uses techniques based on small graph separators.

The underlying approach of all these algorithms is simple:

they perform an exhaustive search among all triangulations

of P and keep track of the one with minimum total length

encountered so far. We will now illustrate the basic idea

common to all these algorithms in some more detail.

A partition of P is a set of non-crossing line segments with

endpoints in P (these segments are called edges); all partitions

contain the edges from the boundary of the convex hull C(P)

of P. Such a set of edges E induces a partition R(E) of C(P)\E

into finitely many maximal connected regions. A triangulation

of P is a partition where all the regions are empty triangles (see

Fig. 5 for an example of a partition of a set of points into three

regions).

The search starts with an arbitrary edge e of the convex hull

of P. For every triangulation of P, there is a unique triangle t

that has e in the boundary (see Fig. 6a for an example). The

algorithm now branches on the set of empty triangles with ver-

tices in P and e in the boundary. The edges of C(P) together

with the edges of t form a partition E of P.

In general, we have a partition E of P and for one of the

regions in E a particular triangulation is fixed. This region is

called fixed and all other regions open. The goal is to

compute MWTs for all open regions in E.

The algorithm maintains the following invariant: every

open region R is a topological disk with possibly some

PARAMETERIZED COMPLEXITY OF GEOMETRIC PROBLEMS Page 7 of 13

THE COMPUTER JOURNAL, 2007

points of P in its interior, and the part of the boundary of R that

is contained in the interior of the convex hull C(P) of P is con-

nected. Figure 6b shows an example after several branching

steps.

In order to find the MWT of an open region R (while main-

taining the invariant), we select an edge e that is part of the

boundary of R but not an edge of C(P). Then we branch on

the set of empty triangles with vertices in P that are contained

in R and that have edge e in the boundary.

So, the open regions that we encounter during our search for

an MWT can be viewed as the subproblems we have to deal

with. Note that an open region is defined by the part of its

boundary that is contained in the interior of C(P). This part

is connected and therefore forms a simple (possibly closed)

polygonal path; all vertices of this polygonal path are inner

points, except at most two that are outer points.

Since the exhaustive search repeatedly runs into the same sub-

problems, one can employ dynamic programming, i.e. store

MWTs for subproblems, once computed, in a table where they

can be looked up (in constant time). The total number of sub-

problems encountered by the algorithm is bounded by the

number of polygonal paths that define the open regions encoun-

tered as subproblems. By a result of Sharir and Welzl [57], the

number of crossing-free polygonal paths on l � k vertices is

O(dl) for some constant d , 87. Thus, the number of subpro-

blems can be bounded by O(88k n2). A subproblem can easily

be processed as outlined above: after selecting edge e we have

to consider at most n triangles. For each of these triangles, we

must check whether the triangle is empty. This can easily be

done in O(k) time for each triangle. Hence, we can process a sub-

problem in O(kn) time and thus obtain a running time of

O(88k kn3).

Hoffmann and Okamoto [31] obtained a much faster algori-

thm result based on the observation that it is sufficient to con-

sider subproblems that are defined by polygonal paths that are

monotone with respect to the x-axis: the number of these

x-monotone paths is in O(2k n2). Employing some additional

arguments of a geometric flavor Spillner [33] and Borgelt

et al. [32] improved the running time to O(2kkn3þ n3) and

O(4kkn4), respectively.

In order to give a better upper bound on the number of ver-

tices of the polygonal paths that define subproblems, Knauer

and Spillner [34] used techniques based on small graph separa-

tors. Since for MWT no reduction to a problem kernel is

known, the general approach by Alber and Fiala [43] that

reduces the input to a linear size problem kernel and then

applies the separator result to this problem kernel, (cf.,

Section 2.2) does not work here. The main result of Knauer

and Spillner is that in the dynamic programming algorithm

for MWT outlined above, it is sufficient to consider only

subproblems defined by crossing-free polygonal paths with

O(ffiffiffikp

) vertices.

THEOREM 2.3. Given a set P of points in the plane, k

of which in the interior of the convex hull of P, an MWT

of P can be found in O(2cffiffiffikp

log kk2n3) time.

2.5.2. Minimum (weight) convex partition

A convex partition of a planar point set P is a set of non-

crossing straight line segments (edges) with endpoints in P

that partition its convex hull into a set of empty convex

regions. A region is empty if it contains no points of P in its

interior. In the minimum convex partition problem (MCP),

the task is to compute a convex partition having a minimum

number of regions, whereas in the minimum weight convex

partition problem (MWCP), the task is to compute a convex

partition of minimum total edge length.

For the MCP problem, Hoffmann and Okamoto [31] and

Spillner [58] gave algorithms that run in O(k6k25 216kn) and

O(2kk3n3þ n log n) time, respectively; k is again the

number of points in the interior of the convex hull of P.

For the MWCP problem, Spillner also gave an algorithm

with the same time bound as above, which is actually better

than the more recent one of O(213k k4k28n3) by Borgelt

et al. [32] for the same problem.

2.5.3. Euclidean TSP

For the planar Euclidean TSP on n points, with the number of

inner points k as a parameter, Deineko et al. [40] gave an

algorithm that runs in O(k!kn) time and O(k) space, and one

that runs in O(2kk2n) time and O(2kkn) space.

FIGURE 5. Partition of a point set into the set R(E)¼ fR1, R2, R3g of

three regions.

FIGURE 6. Exhaustively searching for an MWT.

Page 8 of 13 P. GIANNOPOULOS

THE COMPUTER JOURNAL, 2007

2.6. Graphs on surfaces

2.6.1. Shortest splitting cycle on a surface

Let M be a compact, connected and orientable surface without

boundary. A combinatorial surface is an abstract surface M

together with a weighted undirected graph G(M), embedded

on M so that it cuts M into topological disks. A path on M is

only allowed to be a walk in G, and its length is the sum of

the weights of the edges traversed by the path, counted with

multiplicity. A cycle on M is called a splitting cycle if it is

simple, non-contractible and separates M. The complexity of

a combinatorial surface G(M) is the total number of vertices,

edges, and faces of G. For an introduction to topology of

surfaces, see, for example, Kinsey [59]. For more details on

combinatorial topology and topological graph theory, see

Gross and Tucker [60], Mohar and Thomassen [61], and

Hatcher [62].

Chambers et al. [42] proved that finding a shortest splitting

cycle on a combinatorial surface is NP-hard and gave an algori-

thm that computes a shortest splitting cycle in gO(g)n2 log n

time, where g is the genus of the surface and n is the comple-

xity of the surface.

2.6.2. Embedding a graph on a surface

Given an arbitrary fixed surface S, i.e. of fixed genus, and a

graph G, can G be embedded in S? Mohar [41] showed

that this problem is in FPT with respect to the genus of the

surface by giving an algorithm that runs in time linear

in the size of the graph. However, the actual dependence on

the genus is not given. It would be interesting to determine

the exact running time of the algorithm, with the genus con-

sidered as a parameter, and to see whether it can be improved.

2.7. Geometric covering

Langerman and Morin [63] studied an abstract NP-hard cover-

ing problem that models a number of concrete geometric (as

well as purely combinatorial) covering problems. For the

sake of simplicity we will not describe their result in its full

generality. Instead, we illustrate the underlying ideas with

the following simple geometric covering problem: decide if

a set P of n points in the plane can be covered by k lines.

The problem is in FPT when parameterized with k. To see

this, consider the following bounded search tree algorithm:

every node of the tree contains k bins (each bin corresponds

to a line), and each bin has room for two points. A bin is

called open if it contains less than two points, and closed

otherwise. Each closed bin defines a unique line (the one

through the bin’s points) and therefore covers some (at least

two) of the points of P. In the root of the search tree, all

bins are open. The search processes the points of P in some

fixed order. To advance the search down the tree from a

node v one proceeds as follows: the children of v correspond

to all possible ways of assigning the next point of P to the

open bins of v. If we take the next point of P and put it in

an open bin b, we create a new child u of v. If b is now

closed in u, all remaining points from P that are covered by

b are removed. If all bins of a vertex are closed, then the

search stops. In that case it can be checked in O(kn) time if

the bins cover all the points. The depth of this search tree is

2k, and the degree of each vertex is at most k, so the total

size of the tree is O(k2k), and therefore the algorithm runs in

O(k2kþ1n) time.

The problem admits a kernel of quadratic size: to this end,

we consider the set L of O(n2) lines defined by all pairs of

points in P and the set F # L of these lines that contain

more than k þ 1 points. Each line of F has to be part of each

cover of P with at most k lines, so if jFj . k, then the points

in P cannot be covered with k lines. If jFj � k we delete the

points of P covered by the lines of F. We call the resulting

point set P0 and we set k0 ¼ k 2 jFj. Each line in L\F covers

at most k points of P0, so if jP0j .kk0, the set P0 cannot be

covered with k0 lines (and thus P cannot be covered with k

lines). In case jP0j� kk0 � k2, we can check if P0 can be

covered with k0 lines in O(k2kþ2) time using the search tree

method sketched above. The total runtime of the algorithm

is therefore O(n2þ k2kþ2).

The problems considered in [63] are parameterized with the

number of sets allowed in the covering, denoted by k, and the

combinatorial dimension of the problem, denoted by d. For

the geometric problems (as above), the latter parameter is

directly related to the dimension of the underlying Euclidean

space. Among others, the following two geometric covering

problems fit into the general framework.

2.7.1. Covering points with hyperplanes and its dual

problem

Given a set of n points in Rd, is there a set of k hyperplanes

such that each point of S lies on at least one hyperplane?

The dual problem is the following: given a set of n hyper-

planes in Rd, is there a set of k points such that each hyper-

plane in S contains at least one of the points? In both

problems, the combinatorial dimension equals the geometric

dimension d.

2.7.2. Covering points with spheres. Given a set of n

points in Rd, is there a set of k hyperspheres such that each

point in S lies on the surface of at least one of the hyper-

spheres? In this problem, the combinatorial dimension is

equal to d þ 1. Note that this problem becomes W[1]-hard

when the points can lie in the interior of the spheres (see

Section 3.3.2).

Both problems can be solved with a deterministic algorithm

that runs in O(kdkn) time and a randomized Monte–Carlo one

that runs in O(kd(kþ1)þ c2dkd(dþ1)/2eb(dþ1)/2cn log n) time and

succeeds with probability at least 12n2c, where c . 0 is

some constant.

PARAMETERIZED COMPLEXITY OF GEOMETRIC PROBLEMS Page 9 of 13

THE COMPUTER JOURNAL, 2007

3. FIXED-PARAMETER INTRACTABLEGEOMETRIC PROBLEMS

This section reviews hardness results for parameterized geo-

metric problems. Most of these results are based on reductions

from the standard parameterization of the clique problem, or

k-clique, which is W[1]-complete [64]: given a graph G

and a parameter k . 0, is there a clique of size k in G?

Of course, k-independent set on general graphs is also

W[1]-complete [64].

3.1. Visibility independence and domination problems

Consider the following visibility problem: given a set S of line

segments in the plane and a set P of points, decide if there is a

set U , P of k points that mutually cannot see each other

when visibility is blocked by the segments in S. That is, if

Gvis ¼ (P, Evis) denotes the visibility graph of P with respect

to S, i.e. fp, q g [ Evis if and only if pq > S ¼ ;, we ask if

Gvis contains an independent set of size k.

This problem is easily seen to be W[1]-hard since each

graph G ¼ (V, E) can be realized as a visibility graph Gvis.

Assume that V ¼ f1, . . . , ng and let P ¼ fp1, . . . , png be the

vertices of a regular n-gon.

We surround each pi by a small axis-aligned square Bi (con-

sisting of four segments) that initially blocks all visibility to

the remaining points. For each edge fi, j g [ E, we remove

a small segment bij from the boundary of Bi and a small

segment bji from the boundary of Bj such that pipj >(Bi < Bj) ¼ ;, i.e. pi and pj can see each other now. The seg-

ments bij and bji are chosen in such a way that prps > (bij <bji) ¼ ; for all r, s [ f1, . . . , ng\fi, jg, i.e. removing these seg-

ments does not allow any other new pair of points to see each

other. The set S consists of the segments forming the bound-

aries of the Bis after all edges have been considered (see

Fig. 7 for an illustration of the construction).

It can be shown that the reduction can be computed in poly-

nomial time. This implies that the independence problem in

visibility graphs is W[1]-hard.

Using the same approach and reducing from k-dominating

set in general graphs, which is W[2]-complete [65], one can

show that the following problem is W[2]-hard: decide if

there is a set D , P of k points that see all the points in P\D

(again, visibility is blocked by the segments in S), i.e. we

ask if Gvis contains a dominating set of size k.

Note that if the coordinates of P and the endpoints of S are

rational numbers, the problems are clearly in W[1] and W[2],

respectively.

3.2. Geometric intersection graphs

3.2.1. Independent set on intersection graphs

Finding an independent set of size k in the intersection graph

of unit disks and axis-parallel unit squares in the plane is

W[1]-hard [66]. The reduction is from k-clique. Note that the

problem is in W[1], and hence W[1]-complete, since the

same problem is W[1]-complete for general graphs. Marx

[46] has recently generalized his reductions and showed that

the independent set problem on intersection graphs of unit

line segments with an arbitrary number of directions is

W[1]-complete as well; note that, as mentioned in Section

2.2.2, the problem is in FPT when parameterized with the

maximum number of directions.

3.2.2. Dominating set on intersection graphs

Given an intersection graph G, the task is to find a set S of k

vertices such that each vertex of the graph is either in S or is

a neighbor of a member of S. Marx [46] proved the following:

dominating set is W[1]-hard for intersection graphs of axis-

parallel unit squares, axis parallel line segments and unit

disks in the plane. As mentioned above, dominating set is

W[2]-complete for general graphs, but is in W[1], and hence

W[1]-complete, for axis-parallel unit square graphs and axis-

parallel line segment graphs [46]. It is an open problem

whether the problem is in W[1] for unit disk graphs as well.

3.3. Other problems

3.3.1. Robot motion planning

Let a (rational) polyhedron be specified by a finite union of

convex polyhedra in three-dimensional Euclidean space,

each defined by a finite set of linear inequalities with rational

coefficients. The three-dimensional Euclidean generalized

mover’s problem can be defined as follows.

Input: A finite set O of obstacle rational polyhedra, an

object to be moved given as a finite set P of rational polyhedra

which are freely linked at distinguished linkage vertices such

that P has k degrees of freedom of movement, and initial and

final rational positions pI and pF of P in three-dimensional

Euclidean Space.

Question: Is there a legal movement of P from pI to pF, i.e. is

there a continuous sequence of simultaneous translations and

rotations of the polyhedra of P such that at each point in

time each polyhedron of P intersects no obstacle of O and

furthermore it intersects no other polyhedron of P except at

its specified linkage vertices?FIGURE 7. Realization of an abstract graph as a visibility graph.

The lines of sight (dashed) correspond to the edges.

Page 10 of 13 P. GIANNOPOULOS

THE COMPUTER JOURNAL, 2007

Reif [67] proved that the three-dimensional Euclidean gene-

ralized mover’s problem is PSPACE-hard. Cesati and

Wareham [68] adapted Reif’s proof and showed that the

problem is W[SAT]-hard when parameterized with the

number of degrees of freedom k.

3.3.2. Geometric covering

Deciding whether a given set P of points in the plane can be

covered by k unit squares is W[1]-hard [66]. The reduction

is from k-clique; according to D. Marx (Personal Communi-

cation), the reduction carries over to covering with unit

disks in the plane as well.

We observe here that this result holds also for the ‘dual’

problem of k-piercing [69]: for a given set S of squares in

the plane, decide whether there exists a set of k-piercing

points, such that every square of S is intersected by at least

one of the k points. This can be easily seen via the following

standard reduction from the k-covering to the k-piercing

problem: place a unit square around each point of P, such

that the square is centered at the point. This set of squares

can be pierced by k points if and only if P can be covered

by k unit disks. This is actually an FPT-reduction, and hence

k-piercing is W[1]-hard as well.

3.3.3. Shape matching

Given two point sets A, B [ Rd, with jAj ¼ m , jBj ¼ n,

deciding whether A is congruent, i.e. equal up to translations

and rotations, to a subset of B (point subset congruence

problem) is W[1]-hard with respect to the dimension d [70].

The reduction is from k-clique, and the parameter d is linear

in the size of the clique k. The latter implies that an O(mno(d))-

time algorithm for this problem exists only if k-clique can be

solved in O(no(k))-time, which in turn implies that SNP ,DTIME(2o(n)) [71]. This example shows that the actual depen-

dence of the parameters in a parameterized reduction is

important for getting tight lower bounds.

The above hardness result generalizes to any pointset dis-

tance D for which D(A, B) ¼ 0$A , B; this is a desired prop-

erty for any distance that is used to find small patterns in larger

ones, e.g. directed Hausdorff distance, Earth mover’s distance.

Since mini D(i(A), B) ¼ 0 ,i0(A) , B for some isometry i0,

the problem of minimizing D under isometries, when d is

part of the input, is not in FPT, unless FPT ¼ W[1].

4. RESEARCH DIRECTIONS

We have reviewed parameterized complexity results for geo-

metric problems. There are numerous issues open for further

research, several of which are summarized in the following.

(i) Investigate the parameterized complexity of high-

dimensional geometric problems with respect to their

dimension. This approach could prove to be useful

for proving lower bounds even for problems with no

direct formulation as decision problems, e.g. nearest

neighbors search problems [72].

(ii) Investigate the parameterized complexity of compu-

tational topology problems with respect to the genus

of the input surface; see, for example, Chambers

et al. [42] for a few open problems of this type.

(iii) Find alternative parameterizations based on the

‘distance from triviality’ approach, especially for

geometric problems for which no PTAS is known, as

it was done for the MWT problem.

(iv) Are there parameterized geometric problems that have

an implicit graph structure where the tree width can be

used a parameter?

(v) Investigate the efficiency of suitable FPT algorithms

for geometric problems by performing extensive

experiments.

ACKNOWLEDGEMENTS

We would like to thank Mike Fellows for his support, com-

ments and ideas in the course of writing this survey.

REFERENCES

[1] Dobkin, D. and Teller, S. (2004) Computer Graphics. In

Goodman, J. and O’Rourke, J. (eds), Handbook of Discrete

and Computational Geometry, (2nd edn.), pp. 1095–1116.

CRC Press LLC.

[2] Alt, H. and Guibas, L. (1999) Discrete Geometric Shapes:

matching, Interpolation, and Approximation. In Sack, J.

and Urrutia, J. (eds), Handbook of Computational Geometry,

pp. 121–153. Elsevier Science.

[3] Guibas, L. (2004) Modeling Motion. In Goodman, J.

and O’Rourke, J. (eds), Handbook of Discrete and

Computational Geometry, (2nd edn), pp. 1117–1134. CRC

Press LLC.

[4] O’Rourke, J. and Toussaint, G. (2004) Pattern recognition. In

Goodman, J. and O’Rourke, J. (eds), Handbook of Discrete

and Computational Geometry, (2nd edn), pp. 1135–1162.

CRC Press LLC.

[5] Sato, M. and Ohtshuki, T. (1987) Applications of computational

geometry to vlsi layout pattern design. Integr. VLSI J., 5, 303–

317.

[6] van Kreveld, M. (2004) Geographic information systems. In

Goodman, J. and O’Rourke, J. (eds), Handbook of Discrete

and Computational Geometry, (2nd edn), pp. 1293–1314.

CRC Press LLC.

[7] Floriani, L.D., Puppo, E. and Magillo, P. (1999) Applications of

computational geometry to geographical information systems.

In Sack, J. and Urrutia, J. (eds), Handbook of Computational

Geometry, pp. 333–388. Elsevier Science.

[8] Tamassia, R. and Liota, G. (2004) Graph drawing. In

Goodman, J. and O’Rourke, J. (eds), Handbook of Discrete

and Computational Geometry, (2nd edn), pp. 1163–1187.

CRC Press LLC.

PARAMETERIZED COMPLEXITY OF GEOMETRIC PROBLEMS Page 11 of 13

THE COMPUTER JOURNAL, 2007

[9] Sharir, M. (2004) Algorithmic Motion Planning. In Goodman, J.

and O’Rourke, J. (eds), Handbook of Discrete and

Computational Geometry, (2nd edn), pp. 1037–1064. CRC

Press LLC.

[10] Halperin, D., Kavraki, L. and Latombe, J.-C. (2004) Robotics.

In Goodman, J. and O’Rourke, J. (eds), Handbook of Discrete

and Computational Geometry, (2nd edn), pp. 1065–1093.

CRC Press LLC.

[11] Preparata, N. and Shamos, M. (1990) Computational Geometry:

An Introduction. (2nd edn). Springer-Verlag.

[12] Mulmuley, K. (1994) Computational Geometry: An

Introduction Through Randomized Algorithms. Prentice Hall.

[13] de Berg, M., van Kreveld, M., Overmars, M. and

Schwarzkopf, O. Computational Geometry: Algorithms and

Applications (2nd edn). Springer-Verlag.

[14] Agarwal, P. and Sharir, M. (1998) Efficient algorithms for

geometric optimization. ACM Comput. Surv., 30, 412–458.

[15] Bern, M. and Eppstein, D. (1996) Approximation Algorithms

for Geometric Problems. In Hochbaum, D. (ed),

Approximation Algorithms for NP-Hard Problems. PWS

Publishing.

[16] Arora, S. (2002) Approximation schemes for NP-hard

geometric optimization problems: a survey. http://www.cs.

princeton.edu/~arora/pubs/arorageo.ps.

[17] Rao, S. and Smith, W. (1998) Approximating Geometric

Graphs via ‘spanners’ and ‘banyans’. Proc. 30th Annu. ACM

Sympos. Theory of Computing (STOC), Dallas, TX, pp. 540–

550. ACM.

[18] Har-Peled, S. and Mazumdar, S. (2004) On coresets for k-means

and k-median clustering. Proc. 36th Annu. ACM Sympos. Theory

of Computing (STOC), Chicago, IL, pp. 291–300. ACM.

[19] Downey, R. (2003) Parameterized complexity for the skeptic.

Proc. 18th IEEE Ann. Conf. Computational Complexity,

Aarhus, Denmark, pp. 147–169.

[20] Remy, J. and Steger, A. (2006) A Quasi-polynomial time

Approximation Scheme for Minimum Weight Triangulation.

Proc. 38th Annu. ACM Sympos. Theory of Computing

(STOC ), Seattle, WA, pp. 316–325.

[21] Gonzalez, T. (1985) Clustering to minimize the maximum

intercluster distance. Theor. Comput. Sci., 38, 293–306.

[22] Feder, T. and Greene, D. (1988) Optimal Algorithms for

Approximate Clustering. Proc. 20th Annu. ACM Sympos.

Theory of Computing (STOC), Chicago, IL, pp. 434–444. ACM.

[23] Flum, J. and Grohe, M. (2006) Parameterized Complexity

Theory. Texts in Theoretical Computer Science. An EATCS

Series, Vol. XIV. Springer-Verlag.

[24] Niedermeier, R. (2006) Invitation to Fixed-Parameter

Algorithms. Oxford Lecture Series in Mathematics and its

Applications. Oxford University Press.

[25] Downey, R. and Fellows, M. (1999) Parameterized Complexity.

Springer-Verlag.

[26] Bazgan, C. (1995) Scheemas d’approximation et complexitae

parametree. Technical report, Universite Paris Sud.

[27] Cai, L. and Chen, J. (1997) On fixed-parameter tractability and

approximability of NP optimization problems. J. Comput. Syst.

Sc., 54, 465–474.

[28] Cesati, M. and Trevisan, L. (1997) On the efficiency of

polynomial time approximation schemes. Inf. Process. Lett.,

64, 165–171.

[29] Marx, D. Parameterized complexity and approximation,

algorithms. Comput. J. 10.1093/comjnl/bxm048.

[30] Mulzer, W. and Rote, G. (2006) Minimum-Weight Triangulation

is NP-hard. Proc. 22nd ACM Sympp. on Computational

Geometry (SoCG). Sedona, AZ, pp. 1–10. ACM.

[31] Hoffmann, M. and Okamoto, Y. (2004) The Minimum

Weight Triangulation Problem with Few Inner Points. Proc.

1st Int. Workshop Parameterized and Exact Computation

(IWPEC ), Lecture Notes in Computer Science, Vol. 3162,

200–212.

[32] Borgelt, C., Grantson, M. and Levcopoulos, C. (2006) Fixed

parameter algorithms for minimum weight partitions. Proc.

22nd European Workshop Computational Geometry EWCG,

pp. 5–12.

[33] Spillner, A. (2005) A Faster Algorithm for the Minimum

Weight Triangulation Problem with few Inner Points. Proc.

1st ACiD, Durham, UK, pp. 135–146.

[34] Knauer, C. and Spillner, A. (2006) A Fixed-Parameter

Algorithm for Minimum Weight Triangulation based on Small

Graph Separators. Proc. 32nd Int. Workshop on Graph

Theoretic Concepts in Computer Science, Lecture Notes in

Computer Science, vol. 4271, 49–57.

[35] Megiddo, N. (1984) Linear programming in linear time when

the dimension is fixed. J. ACM, 31, 114–127.

[36] Dyer, M. and Frieze, A. (1989) A randomized algorithms for

fixed-dimension linear programming. Math. Program., 44,

203–212.

[37] Chazelle, B. and Matoussek, J. (1996) On linear-time

deterministic algorithms for optimization problems in fixed

dimension. J. Algorithms, 21, 579–597.

[38] Matousek, J., Sharir, M. and Welzl, E. (1996) A subexponential

bound for linear programming. Algorithmica, 16, 498–516.

[39] Deineko, V. and Woeginger, G. (1996) The

convex-hull-and-k-line traveling salesman problem. Inf.

Process. Lett., 59, 295–301.

[40] Deineko, V., Hoffmann, M., Okamoto, Y. and Woeginger, G.

(2004) The traveling salesman problem with few inner points.

Proc. 10th Int. Computing and Combinatorics Conf.

(COCOON), Series, Lecture Notes in Computer Science, Vol.

3106, pp. 268–277. Oper. Res. Lett., 34, 106–110.

[41] Mohar, B. (1999) A linear time algorithm for embedding graphs

in an arbitrary surface. SIAM J. Discret. Math, 12, 6–26.

[42] Chambers, E., de Verdiere, E., Erickson, J., Lazarus, F.

and Whittlesey, K. (2006) Splitting (complicated) surfaces is

hard. Proc. 22nd Annu. ACM Sympp. Comput. Geom. (SoCG),

pp. 421–429. ACM.

[43] Alber, J. and Fiala, J. (2004) Geometric separation and exact

solutions for the parameterized independent set problem on

disk graphs. J. Algorithms, 52, 134–151.

Page 12 of 13 P. GIANNOPOULOS

THE COMPUTER JOURNAL, 2007

[44] Huffner, F., Niedermeier, R. and Wernicke, S. Techniques for

practical fixed-parameter algorithms. Comput. J. 10.1093/

comjnl/bxm040.

[45] Alber, J., Fernau, H. and Niedermeier, R. (2001) Graph

separators: a parameterized view. Proc. 7th COCOON 2001,

Lecture Notes in Computer Science, Vol. 2108, pp. 318–327.

[46] Marx, D. (2006) Parameterized Complexity of Independence

and Domination on Geometric Graphs. Proc. 2nd Int.

Workshop on Parameterized and Exact Computation

(IWPEC), Lecture Notes in Computer Science, Vol. 4169,

154–165.

[47] Kara, J. and Kratochvıl, J. (2006) Fixed Parameter Tractability

of Independent Set in Segment Intersection Graphs. Proc. 2nd

Int. Workshop on Parameterized and Exact Computation

(IWPEC), Lecture Notes in Computer Science, Vol. 4169,

pp. 166–174.

[48] Dujmovıc, V. et al. (2006) A fixed-parameter approach to

2-layer planarization. Algorithmica, 45, 159–182.

[49] Suderman, M. and Whitesides, S. (2005) Experiments with the

fixed-parameter approach for two-layer planarization. J. Graph

Algorithms Appl., 9, 149–163.

[50] Dujmovıc, V., Fernau, H. and Kaufman, M. (2004) Fixed

parameter algorithms for 1-sided crossing minimization. Proc.

11th Int. Sympp. Graph Drawing (GD ’03), Lecture Notes in

Computer Science, Vol. 2912, pp. 332–344.

[51] Dujmovıc, V. and Whitesides, S. (2004) An efficient fixed

parameter tractable algorithm for 1-sided crossing

minimization. Algorithmica, 40, 15–31.

[52] Dujmovic, V. et al. (2001) On the parameterized complexity of

layered graph drawing. Proc. 5th Annu. European Sympp.

Algorithms (ESA), Lecture Notes in Computer Science, Vol.

2161, pp. 488–499.

[53] Sugiyama, K., Tagawa, S. and Toda, M. (1981) Methods for

visual understanding of hierarchical systems. IEEE Trans.

Sys., Man Cybern., 11, 109–125.

[54] Grohe, M. (2004) Computing crossing numbers in quadratic

time. J. Comput. Syst. Sci., 68, 285–302.

[55] Knauer, C., Schramm, E., Spillner, A. and Wolff, A.

Configurations with Few Crossings in Topological Graphs.

Proc. 16th Annual International Symposium on Algorithms

and Computation (ISAAC), Lecture Notes in Computer

Science, Vol. 3827, pp. 604–613.

[56] Guo, J., Huffner, F. and Niedermeier, R. (2004) A structural

view on parameterizing problems: distance from triviality.

Proc. 1st Int. Workshop Parameterized and Exact

Computation (IWPEC), Lecture Notes in Computer Science,

Vol. 3162, pp. 162–173.

[57] Sharir, M. and Welzl, E. (2006) On the Number of

Crossing-Free Matchings (cycles, and partitions). SODA ’06:

Proc. Seventeenth Annual ACM-SIAM Symp. on Discrete

Algorithm, 860–869, New York, NY, 33 ACM Press.

[58] Spillner, A. (2005) Optimal Convex Partitions of Point Sets with

Few Inner Points. Proc. 17th Canadian Conf. Computational

Geometry (CCCG), Windsor, Ontario, Canada, pp. 39–42.

[59] Kinsey, L. (1993) Topology of Surfaces. Undergraduate Texts

in Mathematics. Springer-Verlag.

[60] Gross, J. and Tucker, T. (1987) Topological Graph Theory. John

Wiley & Sons.

[61] Mohar, B. and Thomassen, C. (2001) Graphs on Surfaces. Johns

Hopkins University Press.

[62] Hatcher, A. (2002) Algebraic Topology. Cambridge University

Press.

[63] Langerman, S. and Morin, P. (2005) Covering things with

things. Discrete Computat. Geom., 33, 717–729.

[64] Downey, R.G. and Fellows, M.R. (1995) Fixed-parameter

tractability and completeness II: on completeness for W[1].

Theor. Comput. Sci., 141, 109–131.

[65] Downey, R.G. and Fellows, M.R. (1995) Fixed-parameter

tractability and completeness I: basic results. SIAM

J. Comput., 24, 873–921.

[66] Marx, D. (2005) Efficient Approximation Schemes for

Geometric Problems? Proc. 13th Annu. European Sympos.

Algorithms (ESA), Vol. 3669, Lecture Notes in Computer

Science, pp. 448–459.

[67] Reif, J. (1986) Complexity of the generalized Mover’s Problem.

In Schwartz, J.T., Sharir, M. and Hopcroft, J.E. (eds), Planning,

Geometry, and Complexity of Robot Motion, pp. 267–281.

Ablex Publishing Corp.

[68] Cesati, M. and Wareham, H. (1995) Parameterized complexity

analysis in robot motion planning. Proc. 25th IEEE Int. Conf.

Systems, Man, and Cybernetics: Vol. 1, pp. 880–885. IEEE Press.

[69] Sharir, M. and Welzl, E. (1996) Rectilinear and Polygonal

p-piercing and p-center Problems. Proc. 12th Annu. ACM

Sympos. Comp. Geometry (SoCG), Philadelphia, PA, pp.

122–132. ACM.

[70] Cabello, S., Giannopoulos, P. and Knauer, C. (2006) On the

parameterized complexity of d-dimensional point set pattern

matching. Proc. 2nd Int. Workshop on Parameterized and

Exact Computation (IWPEC ), Lecture Notes in Computer

Science, Vol. 4169, Philadelphia, PA, USA, pp. 175–183.

[71] Chen, J., Chor, B., Fellows, M., Huang, X., Juedes, D.,

Kanj, I.A. and Xia, G. (2005) Tight lower bounds for

certain parameterized NP-hard problems. Inf. Comput., 201,

216–231.

[72] Indyk, P. (2004) Nearest neighbors in high-dimensional spaces.

In Goodman, J. and O’Rourke, J. (eds), Handbook of Discrete

and Computational Geometry. (2nd edn), pp. 877–892. CRC

Press LLC.

PARAMETERIZED COMPLEXITY OF GEOMETRIC PROBLEMS Page 13 of 13

THE COMPUTER JOURNAL, 2007