a linear time approximation scheme for euclidean tsp n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
A linear time approximation scheme for Euclidean TSP PowerPoint Presentation
Download Presentation
A linear time approximation scheme for Euclidean TSP

Loading in 2 Seconds...

play fullscreen
1 / 80

A linear time approximation scheme for Euclidean TSP - PowerPoint PPT Presentation


  • 134 Views
  • Uploaded on

A linear time approximation scheme for Euclidean TSP. Yair Bartal Hebrew University Lee-Ad Gottlieb Ariel University. TexPoint fonts used in EMF. Read the TexPoint manual before you delete this box.: AAAA. Traveling salesman problem.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'A linear time approximation scheme for Euclidean TSP' - aysel


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
a linear time approximation scheme for euclidean tsp
A linear time approximation scheme for Euclidean TSP
  • YairBartalHebrew University
  • Lee-Ad GottliebAriel University

TexPoint fonts used in EMF.

Read the TexPoint manual before you delete this box.: AAAA

traveling salesman problem
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…

Optimal tour

euclidean tsp
Euclidean TSP
  • SanjeevArora [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

3

euclidean tsp1
Euclidean TSP
  • Shortly after Arora’s PTAS appeared, Rao-Smith improved its runtime.
    • Arora: n(logn)Ɛ-Ỡ(d)
    • Rao-Smith: 2Ɛ-Ỡ(d)n + 2Ỡ(d)nlog n
  • Rao-Smith: Is linear time possible?
    • Question reiterated by Chan ‘08, Borradaile-Epstein ’12.

4

euclidean tsp2
Euclidean TSP
  • Shortly after Arora’s PTAS appeared, Rao-Smith improved its runtime
    • Arora: n(logn)Ɛ-Ỡ(d)
    • Rao-Smith: 2Ɛ-Ỡ(d)n + 2Ỡ(d)nlog n
  • Rao-Smith: Is linear time possible?
    • Question reiterated by Chan ‘08, Borradaile-Epstein ’12.
  • Computational model
    • Cell-probe model: Ω(nlogn) 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)]

5

talk outline
Talk Outline
  • Step 1: Preliminaries
    • Outline Arora’salorithm: Quadtree
    • Rao-Smith improvement: Spanner
  • Step 2: Present our algorithm
    • Faster implementation of Rao-SmithSparse decomposition
arora s quadtree
Arora’s Quadtree
  • Random quadtree

Min distance 1

arora s quadtree1
Arora’s Quadtree
  • Random quadtree

4-level

24=16

Random offset

arora s quadtree2
Arora’s Quadtree
  • Random quadtree

3-level

23=8

arora s quadtree3
Arora’s Quadtree
  • Random quadtree

2-level

22=4

arora s quadtree4
Arora’s Quadtree
  • Random quadtree

1-level

21=2

arora s quadtree5
Arora’s Quadtree
  • Random quadtree

0-level

20=1

arora s quadtree6
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
arora s quadtree7
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

arora s quadtree8
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)
euclidean tsp3
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)
    • Rao-Smith: 2Ɛ-Ỡ(d)n + 2Ỡ(d)nlog n

16

spanner
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

H

1

2

2

1

1

1

1

spanner1
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

H

1

2

2

1

1

1

1

spanner2
Spanner
  • Arora: required many portals for unknown tour
  • Rao-Smith: Spanner determines portals
linear time
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
spanner3
Spanner
  • hierarchical spanner [Gao-Guibas-Nguyen ‘04]
    • connect representative points of

i-level cells at distance at most 2i/ε

1-level

2i

spanner4
Spanner
  • hierarchicalspanner [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

1-level

2i

spanner5
Spanner
  • Lightness [Das-Narasimhon ’97]
  • Greedy algorithm – built on top of

hierarchical 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

1-level

2i

spanner algorithm
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
spanner algorithm1
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
spanner algorithm2
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
spanner algorithm3
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
spanner algorithm4
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
spanner algorithm5
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
  • 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.

sparse spaces
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 dynamicapproximate MST
  • Our solution: Dynamic proxy graph to approximate MST
spanner algorithm6
Spanner algorithm
  • 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 algorithm7
Spanner algorithm
  • 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 algorithm8
Spanner algorithm
  • 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
  • Resulting graph
    • Approximates MST
    • Allows fast dynamic repair
conclusion
Conclusion
  • Light low-stretch spanner in linear time
  • Yields a linear time approximation scheme to Euclidean TSP:
    • (1+Ɛ)-approximate tour
    • Runtime: 2Ɛ-Ỡ(d)n
tour via minimum spanning tree
Tour via minimum spanning tree
  • The cost of optimal tour is similar to MST weight:
    • OPT ≥ MST
    • OPT ≤ 2 MST

MST

tour via minimum spanning tree1
Tour via minimum spanning tree
  • The cost of optimal tour is similar to MST weight:
    • OPT ≥ MST
    • OPT ≤ 2 MST

MST

quadtree
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Ɛ

2i

2i/m

euclidean tsp proof
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
metric tsp
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
metric partition
Metric partition
  • Starting point – a quadtree like

hierarchy [Talwar, ‘04]

metric partition1
Metric partition
  • Starting point – a quadtree like

hierarchy [Talwar, ‘04]

  • Random radius
  • Ri = [2i, 2·2i]
  • Arbitrary center
  • point, ordering
metric partition2
Metric partition
  • Starting point – a quadtree like

hierarchy [Talwar, ‘04]

metric partition3
Metric partition
  • Starting point – a quadtree like

hierarchy [Talwar, STOC ‘04]

    • Caveat: lognhiearchical levels suffice
      • Ignore tiny distances < Ɛ/n2
  • Random radius
  • Ri-1 = [2i-1, 2·2i-1]
  • Arbitrary center
  • point
metric tsp1
Metric TSP
  • 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)

2i-1/M

metric tsp2
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
    • mrO(ddim)nlogn time
  • Join tours for small clusters into tour for larger cluster
metric tsp3
Metric TSP
  • Theorem: Given an optimal tour T, there exists a partition with
    • (m,r)-light tour T’
      • M = ddimlogn/Ɛ
      • m = MO(ddim) = (logn/Ɛ)O(ddim)
      • r = Ɛ-O(d)loglogn
    • Length of T’ is within (1+Ɛ) factor of the length of T
metric tsp4
Metric TSP
  • Theorem: Given an optimal tour T, there exists a partition with
    • (m,r)-light tour T’
      • M = ddimlogn/Ɛ
      • m = MO(ddim) = (logn/Ɛ)O(ddim)
      • r = Ɛ-O(d)loglogn
    • Length of T’ is within (1+Ɛ) factor of the length of T
  • 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

metric tsp5
Metric TSP
  • Theorem: Given an optimal tour T, there exists a partition with
    • (m,r)-light tour T’
      • M = ddimlogn/Ɛ
      • m = MO(ddim) = (logn/Ɛ)O(ddim)
      • r = Ɛ-O(d)loglogn
    • Length of T’ is within (1+Ɛ) factor of the length of T
  • 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…
metric tsp6
Metric TSP
  • 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 tsp7
Metric TSP
  • 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 tsp8
Metric TSP
  • 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
  • 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 tsp9
Metric TSP
  • 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
  • At the (i-1)-level, radius Ri-1=2i-1
    • E = Expected cost to edge (length 1)
    • C = Cost of reroutingedge = Ri-1/M
    • P = Probability edge is cut = ?
    • E = C * P

Ri-1/M

metric tsp10
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)

2R

2R

metric tsp11
Metric TSP
  • 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
  • At the (i-1)-level, radius Ri-1=2i-1
    • E = Expected cost to edge (length 1)
    • C = Cost of reroutingedge = Ri-1/M
    • P = Probability edge is cut = ddim/Ri-1
    • E = C * P

Ri-1/M

metric tsp12
Metric TSP
  • 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
  • At the (i-1)-level, radius Ri-1=2i-1
    • E = Expected cost to edge (length 1)
    • C = Cost of reroutingedge = Ri-1/M
    • P = Probability edge is cut = ddim/Ri-1
    • E = C * P = ddim/M

= Ɛ/logn

Ri-1/M

metric tsp13
Metric TSP
  • 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
  • At the (i-1)-level, radius Ri-1=2i-1
    • 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 = ddim/M

= Ɛ/logn

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

Ri-1/M

metric tsp14
Metric TSP
  • Modify a tour to be (m,r)-light – Part II
  • Focus on r (i.e. number of crossing edges)
    • Reduce number of crossings
metric tsp15
Metric TSP
  • Modify a tour to be (m,r)-light – Part II
  • Focus on r (i.e. number of crossing edges)
    • Reduce number of crossings
  • 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
MST in doubling spaces
  • [Talwar, ‘04]: For any r-point set S
    • MST(S) = Rr1-1/ddim« Rr
    • Per point cost = R/r1/ddim

2R

mst in doubling spaces1
MST in doubling spaces
  • [Talwar, ‘04]: For any r-point set S
    • MST(S) = Rr1-1/ddim« Rr
    • Per point cost = R/r1/ddim
  • Proof by illustration:

2R

mst in doubling spaces2
MST in doubling spaces
  • [Talwar, ‘04]: For any r-point set S
    • MST(S) = Rr1-1/ddim« Rr
    • Per point cost = R/r1/ddim
  • Proof by illustration:

2R

mst in doubling spaces3
MST in doubling spaces
  • [Talwar, ‘04]: For any r-point set S
    • MST(S) = Rr1-1/ddim« Rr
    • Per point cost = R/r1/ddim
  • Proof by illustration:

2R

mst in doubling spaces4
MST in doubling spaces
  • [Talwar, ‘04]: For any r-point set S
    • MST(S) = Rr1-1/ddim« Rr
    • Per point cost = R/r1/ddim
  • Proof by illustration:
    • MST cost dominated by small edges
    • Packing: r points at distance R/r1/ddim
    • Total cost: rR/r1/ddim= Rr1-1/ddim

2R

2R

metric tsp16
Metric TSP
  • Modify a tour to be (m,r)-light – Part II
  • Focus on r (i.e. number of crossing edges)
    • Reduce number of crossings
  • At the (i-1)-level, radius Ri-1=2i-1
    • E = Expected cost to edge from patching
    • C = Per edge cost of patching = ?
    • P = Probability edge is patched = ?
    • E = C * P

2R

metric tsp17
Metric TSP
  • Modify a tour to be (m,r)-light – Part II
  • Focus on r (i.e. number of crossing edges)
    • Reduce number of crossings
  • At the (i-1)-level, radius Ri-1=2i-1
    • 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 tsp18
Metric TSP
  • Modify a tour to be (m,r)-light – Part II
  • Focus on r (i.e. number of crossing edges)
    • Reduce number of crossings
  • At the (i-1)-level, radius Ri-1=2i-1
    • E = Expected cost to edge from patching
    • C = Per edge cost of patching = Ri-1/r1/ddim
    • P = Probability edge is patched

≤ Probability edge is cut

= ddim/Ri-1

    • E = C * P

2R

metric tsp19
Metric TSP
  • Modify a tour to be (m,r)-light – Part II
  • Focus on r (i.e. number of crossing edges)
    • Reduce number of crossings
  • At the (i-1)-level, radius Ri-1=2i-1
    • E = Expected cost to edge from patching
    • C = Per edge cost of patching = Ri-1/r1/ddim
    • P = Probability edge is patched

≤ Probability edge is cut

= ddim/Ri-1

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

2R

metric tsp20
Metric TSP
  • Modify a tour to be (m,r)-light – Part II
  • Focus on r (i.e. number of crossing edges)
    • Reduce number of crossings
  • At the (i-1)-level, radius Ri-1=2i-1
    • E = Expected cost to edge from patching
    • C = Per edge cost of patching = Ri-1/r1/ddim
    • P = Probability edge is patched

≤ Probability edge is cut

= ddim/Ri-1

    • E = C * P = ddim/r1/ddim
  • As before, we want: E = Ɛ/logn
    • Expected cost over all levels: logn*Ɛ/logn=Ɛ
    • So take r = (lognddim/Ɛ)ddim
    • But dynamic program runs in mr O(ddim) time - QPTAS

2R

metric tsp21
Metric TSP
  • Sparse decomposition:
    • Search hierarchy bottom-up for “dense” balls.
    • Remove “dense” ball
      • Ball is composed of sparse subballs
      • So it’s justbarely 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
metric tsp22
Metric TSP
  • 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

Ri-1/M

metric tsp23
Metric TSP
  • 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 loglognlevels
      • Radius > Ri-12loglogn= Ri-1logn
    • Probability of edge being cut:
      • ddim/(Ri-1logn)
      • Compare to : ddim/Ri-1

Ri-1/M

metric tsp24
Metric TSP
  • Modify a tour to be (m,r)-light – Part II
  • Focus on r (i.e. number of crossing edges)
    • Reduce number of crossings
  • At the (i-1)-level, radius Ri-1=2i-1
    • E = Expected cost to edge from patching
    • C = Per edge cost of patching = Ri-1/r1/ddim
    • P = Probability edge is patched

≤ Probability edge is cut

= ddim/Ri-1 logn

    • E = C * P = ddim/r1/ddimlogn
  • 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 tsp25
Metric TSP
  • 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

Ri-1/M

global tour in local neighborhood
Global tour in local neighborhood
  • 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

global tour in local neighborhood1
Global tour in local neighborhood
  • Our contribution:
    • Estimate global tour weight

within ball B(u,R): OPT Ʌ S*

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

MST(S)

global tour in local neighborhood2
Global tour in local neighborhood
  • Our contribution:
    • Estimate global tour weight

within ball B(u,R): OPT Ʌ S*

    • Use local 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?

Optimal tour

net respecting tour
Net-respecting 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…

length ~c

Ɛc

Ɛc-net point

net respecting tour1
Net-respecting 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…

length ~c

Ɛc

Ɛc-net point

global tour in local neighborhood3
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

Case 1

S

Case 2

global tour in local neighborhood4
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!

S