- By
**aysel** - Follow User

- 133 Views
- Uploaded on

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

- YairBartalHebrew University
- Lee-Ad GottliebAriel University

TexPoint fonts used in EMF.

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

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

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

- 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

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

- 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

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

Spanner

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

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

Spanner

- hierarchical spanner [Gao-Guibas-Nguyen ‘04]
- connect representative points of

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

1-level

2i

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

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

- 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

- 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

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

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

- 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

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

MST

Tour via minimum spanning tree

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

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Ɛ

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

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

- Starting point – a quadtree like

hierarchy [Talwar, ‘04]

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

- Arbitrary center
- point, ordering

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

- [Talwar, ‘04]: For any r-point set S
- MST(S) = Rr1-1/ddim« Rr
- Per point cost = R/r1/ddim

2R

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

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

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

Download Presentation

Connecting to Server..