a linear time approximation scheme for euclidean tsp

A linear time approximation scheme for Euclidean TSP

Yair Bartal Hebrew UniversityLee-Ad Gottlieb Ariel University

Traveling salesman problem Definition: Given a set of cities (points) find a minimum

tour that visits each point Classic, well-studied NP-hard problem

[Karp ‘72; Papadimitriou, Vempala ‘06] Mentioned in a handbook from 1832!

Common benchmark for optimization methods Many books devoted to TSP

Other variants Closed tour Multiple tours Etc…

2

Optimal tour

Euclidean TSP Sanjeev Arora [A ‘98] and Joe Mitchell [M ‘99] : Euclidean TSP with fixed dimension admits a PTAS

(1+Ɛ)-approximate tour In time n(log n)Ɛ-Ỡ(d)

Easy extension to other norms

They were awarded the 2010 Gödel Prize for this discovery

33

Euclidean TSP Shortly after Arora’s PTAS appeared, Rao-Smith improved its

runtime. Arora: n(log n)Ɛ-Ỡ(d)

Rao-Smith: 2Ɛ-Ỡ(d)n + 2Ỡ(d)nlog n

Rao-Smith: Is linear time possible? Question reiterated by Chan ‘08, Borradaile-Epstein ’12.

44

Euclidean TSP Shortly after Arora’s PTAS appeared, Rao-Smith improved its

runtime Arora: n(log n)Ɛ-Ỡ(d)


Rao-Smith: Is linear time possible? Question reiterated by Chan ‘08, Borradaile-Epstein ’12.

Computational model Cell-probe model: Ω(nlog n) bound via sorting [Das, Kapoor, Smid

‘97] What about real/integer RAM?

This paper: Linear time approximation scheme in integer RAM model Runtime: 2Ɛ-Ỡ(d)n Assume: integer coordinates in range [0,O(n)]

55

Talk Outline Step 1: Preliminaries

Outline Arora’s alorithm: Quadtree Rao-Smith improvement: Spanner

Step 2: Present our algorithm Faster implementation of Rao-SmithSparse decomposition

6

Arora’s Quadtree Random quadtree

7Min distance 1


8

4-level

24=16

Random offset


9

3-level

23=8


10

2-level

22=4


11

1-level

21=2


12

0-level

20=1

Arora’s Quadtree Definition: A tour is (m,r)-light on a quadtree if it enters all

cells (clusters) At most r times Only via m pre-defined portals

13

Arora’s Quadtree Given quadtree Q

The best (m,r)-light tour on Q can be computed exactly in mO(r)+nlogn time Via simple dynamic programming Arora showed that a good

(m,r)-light tour always exists

14

Arora’s Quadtree Existence of a good (m,r)-light tour

Modify OPT (unknown) Achieve (m,r)-light tour close to OPT

Step 1: Move cut edges to portals

Step 2: Reduce the number of crossings (patching)

15

Euclidean TSP How can Arora’s runtime be improved?

Rao-Smith: Spanners reduce portals

Reduce number of portals Arora: m = logO(d)n portals Rao & Smith: m = Ɛ-O(d) portals

Recall that runtime is ~ mO(r)

r = Ɛ-O(d)

Arora: n (log n)Ɛ-Ỡ(d)


16

16

Spanner A spanner is a subgraph with favorable properties

Stretch Weight (lightness)

Euclidean spaces admit good spanners Weight ~ O(MST) ~ O(OPT) (1+Ɛ)-stretch

Best spanner tour is close to OPT

17

G

2

11

H

2

11

1

Spanner A spanner is a subgraph with favorable properties

Stretch Weight (lightness)

Euclidean spaces admit good spanners Weight ~ O(MST) ~ O(OPT) (1+Ɛ)-stretch

Best spanner tour is close to OPT

G

2

11

H

2

11

1

18

Spanner Arora: required many portals for unknown tour Rao-Smith: Spanner determines portals

19

Linear time Main tools employed by Rao-Smith

Quadtree light spanner

Implement Rao-Smith in linear time? Quadtree can be built in linear time [Chan ‘08] Our contribution: build a light spanner in linear time.

Rest of talk: light spanner in linear time

20

Spanner hierarchical spanner [Gao-Guibas-Nguyen ‘04]

connect representative points of i-level cells at distance at most 2i/ε

21

1-level

2i

Spanner hierarchical spanner [Gao-Guibas-Nguyen ‘04]

connect representative points of i-level cells at distance at most 2i/ε

connect children to parents

Stretch among children true dist ≤ spanner dist + 2(2i) true dist ≥ spanner dist – 2(2i) (1+ε)-stretch

But weight may be large! Cost of MST at each of logn levels

22

1-level

2i

Spanner Lightness [Das-Narasimhon ’97]

Greedy algorithm – built on top ofhierarchical spanner Consider edges in order of length Add long edge only if short path

does not already exists

Checking paths is expensive Seems to require nlogn time

Our contribution: Linear time via sparse decompositions

23

1-level

2i

Spanner algorithm Sparse decomposition

Space can be decomposed into neighborhoods with MST ~ diameter [Bartal-Gottlieb-Krauthgamer ‘12]

Consider a ball of radius R If the local tour weight inside is at least R/Ɛ

“Dense” ball Ball can be removed TSP solved separately on each subproblem

24

Spanner algorithm

25

Sparse decomposition Space can be decomposed into neighborhoods with MST ~ diameter [Bartal-Gottlieb-Krauthgamer ‘12]

Consider a ball of radius R If the local tour weight inside is at least R/Ɛ

“Dense” ball Ball can be removed TSP solved separately on each subproblem

Spanner algorithm Suppose the space were sparse

Each neighborhood has light MST - spanner weight ~ O(diameter)

Suppose all i-level edges have been decided calculate i+1 level edges

26




27




28

Suppose the space were sparse Each neighborhood has light MST - spanner weight ~ O(diameter)


Place circles about centers Random radii [2i,2(2i)]

Should long edge be added? Low weight implies few edges cut

in expectation Maintain dist from cut edges to center Constant time computation per cell,

O(n) non-empty cells.

Spanner algorithm

29

Sparse spaces Conclusion: If space is sparse, we can build a spanner in

linear time Caveat: at least in expectation But can be shown to hold w.h.p. … and deterministically

How do we ensure space is sparse? Need to detect dense areas and remove them There exist linear time approximate MST algorithms… Problem: need dynamic approximate MST

Our solution: Dynamic proxy graph to approximate MST

30

Spanner algorithm

31

MST proxy Weight close to MST in all neighborhoods

For each close center pair If a path already exists within the ball,

record it Otherwise, add edge

Spanner algorithm

32




Spanner algorithm

33




Resulting graph Approximates MST Allows fast dynamic repair

Conclusion Light low-stretch spanner in linear time

Yields a linear time approximation scheme to Euclidean TSP: (1+Ɛ)-approximate tour Runtime:2Ɛ-Ỡ(d)n

34

Tour via minimum spanning tree

37

MST

The cost of optimal tour is similar to MST weight: OPT ≥ MST OPT ≤ 2 MST

Tour via minimum spanning tree

38

MST

The cost of optimal tour is similar to MST weight: OPT ≥ MST OPT ≤ 2 MST

Quadtree Step 2: Reduce number of used portals to r

Use patchings to reduce the number of “surviving” edges For higher dimensions

The cost of a patching is bounded by the cost of the MST of the points MST of r points in cell of side-length 2i: 2i r1-1/d

Per point cost: 2i r-1/d ≤ 2iƐ

39

2i

2i/m

Euclidean TSP: Proof Patching cost analysis

Pr. edge of length 1 is cut at level i: 1/2i

Cost to endpoints if edge is patched: 2iƐ Expected cost from patching at level i: (1/2i)(2iƐ) = Ɛ Expected cost from all logn levels: Ɛ logn ???

Key observation: Quadtree can be constructed bottom-up

All patchings for level i are decided before level i+1 is constructed Patching an edge at level i eliminates the edge

can’t be patched again at a higher level So the total cost to the edge due to patching is Ɛ

New tour length: (1+Ɛ)T Done with Step 2, and with Euclidean TSP

40

Metric TSP Ingredients used for Euclidean PTAS. Do they exist for

metrics? Portals [Talwar-04]

Bound on MST Euclidean: 2i r1-1/d

Doubling: 2i r1-1/ddim [Talwar-04] Quadtree

Partitions for doubling spaces exist In particular, Step 1 of the Euclidean analysis holds

But bottom-up construction doesn’t! So patching argument for multiple levels breaks down

Plan: Give a replacement for the quadtree show that an (m,r)-light tour close to optimal tour T exists on this partition

41

Metric partition

42

Starting point – a quadtree like hierarchy [Talwar, ‘04]


Metric partition

43

Arbitrary center point, ordering

Random radius Ri = [2i, 2·2i]

Metric partition

44


Metric partition

45

Random radius Ri-1 = [2i-1, 2·2i-1]

Arbitrary center point

Starting point – a quadtree like hierarchy [Talwar, STOC ‘04]

Caveat: logn hiearchical levels suffice Ignore tiny distances < Ɛ/n2

Metric TSP

46

2i-1/M

Definition: A tour is (m,r)-light on a hierarchy if it enters all cells (clusters) At most r times Only via m portals Portals are 2i-1/M –net points

m = MO(ddim)

47

Metric TSP Theorem [Arora ‘98,Talwar ‘04]: Given a partition, the best (m,r)-light tour on the partition can be

computed exactly Via simple dynamic programming mr O(ddim) nlogn time

Join tours for small clusters into tour for larger cluster

Metric TSP Theorem: Given an optimal tour T, there exists a partition

with (m,r)-light tour T’

M = ddim logn/Ɛ m = MO(ddim) = (logn/Ɛ)O(ddim)

r = Ɛ-O(d) loglogn Length of T’ is within (1+Ɛ) factor of the length of T

48





If the partition were known, then by the discussion above, T’ could be found in time

mr O(ddim) n logn = n 2Ɛ-Ỡ(ddim) loglog2n

49





If the partition were known, then by the discussion above, T’ could be found in time

mr O(ddim) n logn = n 2Ɛ-Ỡ(ddim) loglog2n

It remains only to prove the Theorem, and to show how to find the partition Turns out that finding this partition is computationally expensive Drives up the runtime even further…

50

Metric TSP

51

To prove the Theorem, consider the following procedure: Create a random partition Show that it admits an (m,r)-light tour similar to the optimal tour That is, expected cost of modifying optimal tour to being (m,r)-light is

small

Ri-1/M

Metric TSP

52

Modify a tour to be (m,r)-light – Part I [Arora ‘98, Talwar ‘04] Focus on m (i.e. net points) Move cut edges to be incident on net points

Ri-1/M

Metric TSP

53


At the (i-1)-level, radius Ri-1=2i-1

E = Expected cost to edge (length 1) C = Cost of rerouting edge P = Probability edge is cut E = C * P

Ri-1/M

Metric TSP

54



E = Expected cost to edge (length 1) C = Cost of rerouting edge = Ri-1/M P = Probability edge is cut = ? E = C * P

Ri-1/M

Metric TSP Prob. edge (length 1) cut by box of length 2R

≤ d* 1/(2R)

Prob. edge (length 1) cut by metric ball of radius R ≤ ddim * 1/(2R)

55

2R

2R

Metric TSP

56



E = Expected cost to edge (length 1) C = Cost of rerouting edge = Ri-1/M P = Probability edge is cut = ddim/Ri-1

E = C * P

Ri-1/M

Metric TSP

57




E = C * P = ddim/M= Ɛ/logn

Ri-1/M

Metric TSP

58




E = C * P = ddim/M= Ɛ/logn

Expected cost over all levels logn * Ɛ/logn = Ɛ (1+Ɛ)-approximate tour Done with Part I

Ri-1/M

Metric TSP

59

Modify a tour to be (m,r)-light – Part II Focus on r (i.e. number of crossing edges)

Reduce number of crossings

Metric TSP

60



Patching: Reroute tour back into cluster. Patching cost: internal tour on the endpoints

MST on each cluster. How do we estimate the cost of the MST?

MST in doubling spaces [Talwar, ‘04]: For any r-point set S

MST(S) = Rr1-1/ddim « Rr Per point cost = R/r1/ddim

61

2R



Proof by illustration:

62

2R




63

2R




64

2R



Proof by illustration: MST cost dominated by small edges Packing: r points at distance R/r1/ddim

Total cost: r R/r1/ddim = Rr1-1/ddim

65

2R

2R

Metric TSP

66




E = Expected cost to edge from patching C = Per edge cost of patching = ? P = Probability edge is patched = ? E = C * P

2R

Metric TSP

67




E = Expected cost to edge from patching C = Per edge cost of patching = Ri-1/r1/ddim

P = Probability edge is patched = ? E = C * P

2R

Metric TSP

68





P = Probability edge is patched≤ Probability edge is cut = ddim/Ri-1

E = C * P

2R

Metric TSP

69






E = C * P = ddim/r1/ddim

2R

Metric TSP

70






E = C * P = ddim/r1/ddim

As before, we want: E = Ɛ/logn Expected cost over all levels: logn*Ɛ/logn = Ɛ So take r = (logn ddim/Ɛ)ddim

But dynamic program runs in mr O(ddim) time - QPTAS

2R

Metric TSP Sparse decomposition:

Search hierarchy bottom-up for “dense” balls. Remove “dense” ball

Ball is composed of sparse subballs So it’s just barely dense

Recurse on remaining point set

Upshot: can assume tour is everywhere sparse

How do we if the ball is dense? Local tour can be estimated using the local MST Modulo some caveats, error terms…

OPT Ʌ B(u,R) = O(MST(S)) B(u,3R) Ʌ OPT = Ω(MST(S)) -Ɛ-O(ddim) R

71

Metric TSP

72

Ri-1/M

Modify a tour to be (m,r)-light – Part II

Suppose a tour is q-sparse Any possible Ri-1-ball contains weight Ri-1q

Think of this as Ri-1q edges of length 1 Expectation:

Random Ri-1 radius cuts Rq/R = q edges

A cluster is formed by multi-level cuts Expectation: q cuts per level

Metric TSP

73

Ri-1/M

Recall: edge of length 1 is cut at level Rj

With probability ddim/Rj

If r = q 2loglogn Expectation: q cuts per level Assumption: Cuts from 2loglogn levels Charge patching to top loglogn levels

Radius > Ri-12loglogn = Ri-1logn Probability of edge being cut:

ddim/(Ri-1 logn) Compare to : ddim/Ri-1

Metric TSP

74





P = Probability edge is patched≤ Probability edge is cut = ddim/Ri-1 logn

E = C * P = ddim/r1/ddim logn

As before, we want: E = Ɛ/logn Expected cost over all levels: logn*Ɛ/logn = Ɛ So take r = (ddim/Ɛ)ddim

Dynamic program runs in mr O(ddim) time - PTAS

2R

Metric TSP

75

Ri-1/M

Problem: Previous analysis assumed ball always cuts ≤ q edges True in expectation

some balls may cut > q edges Solution sketch: sample logn radii for each ball

Drives up runtime of dynamic program

Global tour in local neighborhood

77

Our contribution: Estimate global tour weight within ball B(u,R): OPT Ʌ S* Use local MST(S)

S*: Full graph on subset S of ball B


78


Upper bound is trivial Theorem: OPT Ʌ S* =O(MST(S)) Proof: Why spend more?

MST(S)


Upper bound is trivial Theorem: OPT Ʌ S* =O(MST(S)) Proof: Why spend more?

Lower bound is nontrivial counter-example:

OPT uses no edges of S* Problem: edges leaving S

How can we limit these?


79

Optimal tour

Definition: A tour is net-respecting if Any edge of length ~ c Is incident on (nearby) Ɛc-net points

A tour which is not net-respecting Can be modified to be net respecting Cost: (1+O(Ɛ))-factor

Why is this important? Can bound number of edges leaving a neighborhood…

Net-respecting tour

80

length ~c

Ɛc-net pointƐc

Definition: A tour is net-respecting if Any edge of length ~ c Is incident on (nearby) Ɛc-net points

A tour which is not net-respecting Can be modified to be net respecting Cost: (1+O(Ɛ))-factor

Why is this important? Can bound number of edges leaving a neighborhood…

Net-respecting tour

81

length ~c

Ɛc-net pointƐc

Global tour in local neighborhood For net-respecting tours

Weight of OPT in large ball lower-bounded by MST of small ball B*(u,3R) Ʌ OPT = Ω(MST(S)) -Ɛ-O(ddim) R

Proof idea: Charge against MST(S) Case 1: Points of S form component in large ball

Cost is greater than cost paid by MST(S)

Case 2: Points of S with edge leading out Saves cost of connecting – at most 2R But long edge must be incident on ƐR-net points

By packing property, only Ɛ-O(ddim) such points

82

SCase 1

Case 2

Global tour in local neighborhood Conclusion: Can bound global tour in local neighborhood

B*(u,3R) Ʌ OPT = O(MST(B(u,3R))) B*(u,3R) Ʌ OPT = Ω(MST(B(u,R))) - Ɛ-O(ddim) R

In our setting

MST(B(u,R))) » Ɛ-O(ddim) R

Done!

83

S

a linear time approximation scheme for euclidean tsp

Documents

dnlog n raosmith

aroras runtime

aroras ptas

aroras quadtreeexistence

aroras quadtreedefinition

logodnportalsrao smith

best spanner tour

n log ndrao