Polynomial Time Approximation Schemes for Euclidean
Traveling Salesman and Other Geometric Problems
SANJEEV ARORA
Princeton University, Princeton, New Jersey
Abstract. We present a polynomial time approximation scheme for Euclidean TSP in fixed dimen-
sions. For every fixed c . 1 and given any n nodes in 5
2
, a randomized version of the scheme finds
a(11 1/c)-approximation to the optimum traveling salesman tour in O(n(log n)
O(c)
) time. When
the nodes are in 5
d
, the running time increases to O(n(log n)
(O(
=
dc))
d21
). For every fixed c, d the
running time is n z poly(log n), that is nearly linear in n. The algorithm can be derandomized, but this
increases the running time by a factor O(n
d
). The previous best approximation algorithm for the
problem (due to Christofides) achieves a 3/2-approximation in polynomial time.
We also give similar approximation schemes for some other NP-hard Euclidean problems:
Minimum Steiner Tree, k-TSP, and k-MST. (The running times of the algorithm for k-TSP and
k-MST involve an additional multiplicative factor k.) The previous best approximation algorithms for
all these problems achieved a constant-factor approximation. We also give efficient approximation
schemes for Euclidean Min-Cost Matching, a problem that can be solved exactly in polynomial time.
All our algorithms also work, with almost no modification, when distance is measured using any
geometric norm (such as ,
p
for p $ 1 or other Minkowski norms). They also have simple parallel
(i.e., NC) implementations.
Categories and Subject Descriptors: F.2.2 [Analysis of Algorithms and Problem Complexity]:
Geometrical problems and computations, Routing and layout; G.2.2 [Graph Theory]: Path and circuit
problems, Trees
General Terms: Algorithms, Theory
Additional Key Words and Phrases: Approximation Algorithms, Traveling Salesman Problem, Steiner
Problem, Network Design, Matching
1. Introduction
In the Traveling Salesman Problem (“TSP”), we are given n nodes and for each
pair {i, j} of distinct nodes, a distance d
i, j
. We desire a closed path that visits
each node exactly once (i.e., is a salesman tour) and incurs the least cost, which is
the sum of the distances along the path. This classic problem has proved a rich
The work of S. Arora was supported by NSF CAREER award NSF CCR 95-02747, an Alfred Sloan
Fellowship, and a Packard Fellowship.
Author’s address: Computer Science Department, Princeton University, 35 Odden Street, Princeton,
NJ 08544; e-mail: arora@cs.princeton.edu.
Permission to make digital/hard copy of part or all of this work for personal or classroom use is
granted without fee provided that the copies are not made or distributed for profit or commercial
advantage, the copyright notice, the title of the publication, and its date appear, and notice is given
that copying is by permission of the Association for Computing Machinery (ACM), Inc. To copy
otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission
and/or a fee.
© 1998 ACM 0004-5411/98/0900-0753 $05.00
Journal of the ACM, Vol. 45, No. 5, September 1998, pp. 753–782.
testing ground for most important algorithmic ideas during the past few decades,
and influenced the emergence of fields such as operations research, polyhedral
theory and complexity theory. For a fascinating history, see Lawler et al. [1985].
Since the 1970s, mounting evidence from complexity theory suggests that the
problem is computationally difficult. Exact optimization is NP-hard (Karp
[1972]). So is approximating the optimum within any constant factor (Sahni and
Gonzalez [1976]). There are also other reasons to believe in the TSP’s nastiness
(cf. D
P
completeness [Papadimitriou and Yannakakis 1984] and PLS-complete-
ness [Johnson et al. 1988]).
But TSP instances arising in practice are usually quite special, so the hardness
results may not necessarily apply to them. In metric TSP the nodes lie in a metric
space (i.e., the distances satisfy the triangle inequality). In Euclidean TSP the
nodes lie in 5
2
(or more generally, in 5
d
for some d) and distance is defined
using the ,
2
norm. Note that Euclidean TSP is a subcase of metric TSP.
Unfortunately, even Euclidean TSP is NP-hard (Papadimitriou [1977]; Garey
et al. [1976]). Therefore, algorithm designers were left with no choice but to
consider more modest notions of a “good” solution. Karp [1977], in a seminal
work on probabilistic analysis of algorithms, showed that when the n nodes are
picked uniformly and independently from the unit square, then the fixed dissec-
tion heuristic with high probability finds tours whose cost is within a factor 1 1
1/c of optimal (where c . 1 is arbitrarily large). Christofides [1976] designed an
approximation algorithm that runs in polynomial time and for every instance of
metric TSP computes a tour of cost at most 3/2 times the optimum.
Two decades of research failed to improve upon Christofides’ algorithm for
metric TSP. The Held–Karp heuristic is conjectured to have an approximation
ratio 4/3 (some results of Goemans [1995] support this conjecture) but the best
upperbound known is 3/2 (Wolsey [1980], Shmoys and Williamson [1990]). Some
researchers continued to hope that even a PTAS might exist. A PTAS or
Polynomial-Time Approximation Scheme is a polynomial-time algorithm–or a
family of such algorithms–that, for each fixed c . 1, can approximate the
problem within a factor 1 1 1/c. The running time could depend upon c, but for
each fixed c has to be polynomial in the input size. PTASs are known for very
few problems; two important ones are Subset-Sum (Ibarra and Kim [1975]) and
Bin-Packing (Fernandez de la Vega and Lueker [1981]; see also Karmarkar and
Karp [1982]). Recently Arora et al. [1992] showed that if P Þ NP, then metric
TSP and many other problems do not have a PTAS. Their work relied upon the
theory of MAX-SNP-completeness (Papadimitriou and Yannakakis [1991]), the
notion of probabilistically checkable proofs or PCPs (Feige et al. [1991]; Arora
and Safra [1992]), and the connection between PCPs and hardness of approxima-
tion [Feige et al. 1991].
The status of Euclidean TSP remained open, however. In this paper, we show
that Euclidean TSP has a PTAS. For every fixed c . 1, a randomized version of
this algorithm computes a (1 1 1/c)-approximation to the optimal tour in
O(n(log n)
O(c)
) time. When the nodes are in 5
d
, the running time rises to
O(n(log n)
(O(
=
dc))
d21
). Our algorithm can be derandomized, but this seems to
multiply the running time by a factor O(n
d
)in5
d
. Our techniques also apply to
many other geometric problems, which are described in Section 1.1.
We design the PTAS by showing that the plane can be recursively partitioned
(using a randomized variant of the quadtree) such that some (1 1 1/c)-
754 SANJEEV ARORA
approximate salesman tour crosses each line of the partition at most r 5 O(c)
times (see Theorem 2.1.2). Such a tour can be found by dynamic programming.
For each line in the partition the algorithm first “guesses” where the tour crosses
this line and the order in which those crossings occur. Then the algorithm
recurses independently on the two sides of the line. There are only n log n
distinct regions in the partition. Furthermore, the “guess” can be fairly coarse, so
the algorithm spends only (O(log n))
O(r)
5 (log n)
O(c)
time per region, for a
total running time of n z (log n)
O(c)
.
We remark that the idea of partitioning a TSP instance into smaller instances
and dynamic programming has been used before, most famously in Karp [1977].
Smith [1988] showed how to solve the TSP in 5
2
to optimality in 2
O(
=
n)
time;
the main idea is that the plane can be recursively partitioned such that an
optimal tour crosses every partition only O(
=
n) times. Recently Grigni et al.
[1995] designed an approximation scheme for planar graph TSP using similar
ideas.
Finally, the inevitable question: Is our PTAS practical? A straightforward
implementation (for even moderate values of c) is very slow, but we see no
reason why a speedier, more subtle, implementation may not exist (see Section
4.1 in the appendix). At the very least, the Theorem gives a way of decomposing
TSP instances into a large number of “independent” and smaller instances, and
this may prove helpful in parallelizing existing programs. We note that classical
local-exchange heuristics such as K-OPT or Lin–Kernighan [1973] are already
known to compute very good tours on “real-life” TSP instances [Johnson and
McGeoch 1997; Bentley 1992]. However, the performance of known heuristics
for problems such as Steiner Tree or k-TSP is not as good.
We find it conceivable that our techniques, which show that Euclidean
instances have near-optimal salesman tours with a very simple structure, may
contribute to a theoretical understanding of local-exchange heuristics on Euclid-
ean instances. (The “real-life” instances in TSPLIB [Reinelt 1991] that constitute
the test-bed for many of these heuristics are often either Euclidean or derived
from Euclidean instances.) For example, even our current dynamic programming
algorithm can be viewed–after some twists in the definition of “local search”–as a
local search algorithm that performs up to O(c) edge exchanges per step (see
Section 4.2). Note however that none of the known heuristics is believed to be a
PTAS.
1
History. The current paper evolved out of preliminary results obtained in
January 1996, culminating in a submission to IEEE FOCS 1996 in April 1996
[Arora 1996]. A few weeks later, Mitchell [1996/1998] independently discovered
an n
O(c)
time approximation scheme for points in 5
2
. His algorithm used ideas
from his earlier constant-factor approximation algorithm for k-MST [Mitchell
1996]. It relies on the geometry of the plane and does not seem to generalize to
1
The few published results in fact suggest the opposite. With an adversarially-chosen starting tour,
2-OPT may produce a tour whose cost is V(log n/log log n) times the cost of the optimum tour, even
when the n nodes lie in 5
2
[Chandra et al. 1994]. K-OPT can in the worst case produce tours whose
cost is twice the optimum. In case of metric TSP, finding a locally-optimum tour for K-OPT (for K $
8) is PLS-complete [Krentel 1989]. This strongly suggests that no polynomial-time algorithm can find
such a local optimum; see Johnson et al. [1988]. Many variants of Lin–Kernighan are also
PLS-complete [Papadimitriou 1992].
755Polynomial Time Approximation Schemes
higher dimensions. In January 1997, the author discovered the nearly-linear-time
algorithm described in this paper. The key ingredient of this algorithm is
Theorem 2.1.2, which the author had originally conjectured to be false. He is
grateful to Karen Wang, whose inability [1996] to construct any counterexample
to Theorem 2.1.2 motivated him to abandon his conjecture.
1.1. DEFINITIONS AND RESULTS. The input to our algorithm is a set of n
points in 5
d
, given by their coordinates. For p $ 1, the distance between two
points ( x
1
, ..., x
d
), (y
1
, ..., y
d
) [ 5
d
in the ,
p
norm is defined as ((
i51
d
ux
i
2 y
i
u
p
)
1/p
. When p 5 2, this norm is called the Euclidean norm; this is the
norm we will usually discuss in detail.
We will use the standard Real RAM model of computation, which assumes a
unit cost for arithmetic on real numbers. Strictly speaking, we will need
computations on real numbers only to “preprocess” the input in linear time.
After this, we truncate coordinates and edge costs to their 2 log n most
significant digits. This affects all edge costs (and hence the optimum tour cost) by
at most a multiplicative factor (1 1 1/n
2
)–which is negligible in the context of an
approximation scheme.
Now we define the geometric problems for which we will design approximation
schemes. Except for Euclidean Matching, all are NP-hard. Prior to our work, the
best approximation algorithms for the NP-hard problems achieved a constant
factor approximation in polynomial time (see the survey by Bern and Eppstein
[1996]). These algorithms used problem-specific ideas and usually require at least
V(n
2
) time (sometimes a lot more). In contrast, our approximation schemes for
the different problems rely on essentially the same idea.
Euclidean Traveling Salesman. Given n nodes in 5
d
, find the shortest tour that
visits all nodes.
Minimum Steiner Tree. Given n nodes in 5
d
, find the minimum-cost tree
connecting them.
2
In general, the minimum spanning tree is not an optimal
solution. In 5
2
(with distances measured in ,
2
norm) the cost of the MST can
be as far as a factor 2/
=
3 from the optimum. Furthermore, the famous
Gilbert–Pollak [1968] conjecture said it can’t be any further from the optimum;
this conjecture was recently proved by Du and Hwang [1992]. A spate of
research activity in recent years (starting with the work of Zelikovsky [1993])
has provided better algorithms, with an approximation ratio around 1.143
[Zelikovsky 1996]. The metric case is MAX-SNP-hard [Bern and Plassmann
1989].
k-TSP. Given n nodes in 5
d
and an integer k . 1, find the shortest tour that
visits at least k nodes. An approximation algorithm due to Mata and Mitchell
[1995] achieves a constant factor approximation in 5
2
.
k-MST. Given n nodes in 5
d
and an integer k $ 2, find k nodes with the
shortest Minimum Spanning Tree. The problem is NP-hard [Fischetti et al.
1994]. Blum et al. [1995] gave the first O(1)-factor approximation algorithm
for points in 5
2
and Mitchell [1996] improved this factor to 2
=
2.
2
It appears that this problem was first posed by Gauss in a letter to Schumacher (R. L. Graham,
personal communication).
756 SANJEEV ARORA
Euclidean Min-Cost Perfect Matching (EMCPM). Given 2n points in 5
2
(or 5
d
in general), find the minimum cost set of nonadjacent edges that cover all
vertices. This problem is in P (even for nongeometric instances). Vaidya [1988]
shows how to solve it optimally in O
˜
(n
2.5
) time, and to approximate it within a
factor (1 1 1/c)inO(poly(c)n
1.5
log
3
n) time [Vaidya 1989].
1.1.1. For each fixed d, the 5
d
version of each of the above problems has a
randomized PTAS. The algorithm computes a (1 1 1/c)-approximation with
probability at least 1/2. In 5
2
the running time is n(log n)
O(c)
for TSP, Steiner Tree,
and Min-Cost Euclidean Matching, and nk(log n)
O(c)
for k-TSP and k-MST. All
running times on instances in 5
d
are larger by a factor (O(log n))
(O(
=
dc))
d21
. The
above expressions for running times are unchanged when the problem is specified
using any Minkowski norm instead of the Euclidean norm. Furthermore, all the
above PTASs can be derandomized, by increasing the running time in 5
d
by O(n
d
).
The various parts of this theorem will be proved in different sections (titled
appropriately). The TSP part will be proved in Section 2 and the parts corre-
sponding to other problems will be proved in Section 3.
We remark that though our algorithms generalize to 5
d
with no difficulties,
this was not always the case with previous (constant factor) approximation
algorithms for k-TSP and k-MST. Those algorithms relied on the geometry of
the plane and broke down even in 5
3
. But a recent algorithm of Garg
[1996]–discovered independently of our paper–works in any metric space.
Geometric versions of polynomial time problems have been studied for many
years, especially MST and Euclidean Matching. Exploiting geometric structure
for these problems is known to lead to faster algorithms than the corresponding
algorithms for general graphs. The best MST algorithm requires O
˜
(2
d
n
4/3
) time
in 5
d
for d . 2 [1]. Note that treating the instance as a weighted graph with (
2
n
)
edges would lead to V(n
2
) running time. Vaidya described a nearly-linear-time
approximation scheme for geometric MST, which computes a (1 1 1/c)-
approximation in O
˜
(cn2
O(d)
) time.
2. The TSP Algorithm
This section describes our approximation scheme for the TSP. Section 2.1
describes the algorithm for Euclidean TSP in 5
2
. The proof of the algorithm’s
correctness relies upon Theorem 2.1.2, which is proved in Section 2.2. Then
Section 2.3 describes the algorithm for Euclidean TSP in 5
d
and Section 2.4
describes the (trivial) extensions of our algorithm when distances are measured
in some non-Euclidean norms.
2.1. EUCLIDEAN TSP IN 5
2
. As mentioned in the introduction, the main idea
in the algorithm is to perform a (recursive) geometric partitioning of the
instance. The geometric partitioning is very simple: it is a randomized variant of
the familiar quadtree. Theorem 2 below says that with probability at least 1/2,
(over the choice of the randomness used to construct this partition), there exists
a(11 1/c)-approximate tour that crosses each line of the partition O(c) times.
Furthermore, these crossings happen at some prespecified points; see below for
more details. Such a tour can be found easily using dynamic programming that
runs in n z (log n)
O(c)
time.
757Polynomial Time Approximation Schemes
