Loading in 5 sec....

Approximation Algorithms for TSP with DeadlinesPowerPoint Presentation

Approximation Algorithms for TSP with Deadlines

- By
**Rita** - Follow User

- 329 Views
- Updated On :

Approximation Algorithms for TSP with Deadlines. Adam Meyerson UCLA. Acknowledgements. Orienteering Results Joint with Avrim Blum, Shuchi Chawla, David Karger, Terran Lane, Maria Minkoff FOCS 2003 TSP with Deadlines Joint with Nikhil Bansal, Avrim Blum, Shuchi Chawla STOC 2004.

Related searches for Approximation Algorithms for TSP with Deadlines

Download Presentation
## PowerPoint Slideshow about 'Approximation Algorithms for TSP with Deadlines' - Rita

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

### TSP with Deadlines

### TSP with Deadlines

Acknowledgements

- Orienteering Results
- Joint with Avrim Blum, Shuchi Chawla, David Karger, Terran Lane, Maria Minkoff
- FOCS 2003

- TSP with Deadlines
- Joint with Nikhil Bansal, Avrim Blum, Shuchi Chawla
- STOC 2004

Problem Statement

- We are given various points where deliveries must be made, along with a deadline for each delivery. The goal is to find a path which makes as many deliveries as possible by their deadlines.
- This is a simplification of the problem of vehicle routing with time windows. In fact, we can add release times to model this exactly.

Motivation/Applications

- Vehicle Routing with Time Windows named as one of the most important problems in operations research.
- Robot Navigation!
- Task scheduling with setup times.
- Orienteering a long-standing open problem in approximation algorithms.

Related Problems

- Traveling Salesman
- Visit all cities, minimize total travel time

- K-TSP
- Visit k of the cities, minimize total travel time
- Chaudhuri, Godfrey, Rao, Talwar FOCS 2003

- Orienteering
- Visit as many cities as possible, in a given amount of travel time

Three Problems in This Talk

- Minimum Excess Path. Visit k cities on a path P from s to t, minimize the difference dP(s,t) - d(s,t).
- Point-to-Point Orienteering. Find a path from s to t with dP(s,t)≤D which maximizes the number of cities visited.
- TSP with Deadlines. Find a path starting at s which maximizes the number of cities visited before their (distinct) deadlines.

Minimum Excess Path

- We’d like to travel from s to t, while visiting at least k of the interesting sites in between.
- The excess of our path, is the distance traveled minus the distance from s to t.
- Example: Driving cross-country. Excess is the length of the detours.
- Example: Slack in a string.

Solution Concept

- If dP*(s,t) >> d(s,t) then k-TSP is enough.
- If dP*(s,t) = d(s,t), then we travel in a straight line away from s.
- We can split the optimum path into “segments” based on distance from s.
- Type 1 segment visits each node only once.
- Type 2 segment loops around, visits 3+ times.

Algorithm for Min-Excess

- For each pair of nodes (x,y) with increasing distance from s, we can compute the a path from x to y which visits k additional nodes having distance between that of x and y.
- For type one segments, we have zero intermediate nodes and get exact solutions.
- For type two segments, we use k-TSP and may increase the distance traveled by a factor of 2.
- We combine these segments together using dynamic programming.

Analysis of Min-Excess

- Let b(j) = distance from s to the start of the jth segment.
- Segments of type 1 have length b(j+1) - b(j).
- Segments of type 2 have length at least 3(b(j+1)-b(j)).
- Summing these, we see that dP*(s,t) ≥ d(s,t)+(2/3) where is the length of the type two intervals.

Min-Excess Result

- Using dynamic programming, we compute a short path which visits k nodes. One possibility is to use the segment boundaries of the optimum.
- Since type 2 segments are increased in length by a factor of two (Garg’s k-TSP result), this path will have length at most dP*(s,t) + .
- Thus we find a path P such that dP(s,t)-d(s,t) is at most (5/2)(dP*(s,t)-d(s,t)) for a 2.5 approximation.
- In general (3/2)-(1/2) where from k-TSP.

Point-to-Point Orienteering

- Given a pair of points (s,t) and a distance bound D. We’d like to travel from s to t while visiting as many intermediate nodes as possible. However, we are required to reach t by time D.

Point to Point Algorithm

- For each pair of nodes (x,y) and value k, we compute a minimum excess path from x to y which visits k nodes.
- We then select the triple (x,y,k) with the maximum k, such that the computed path has excess D-d(s,x)-d(x,y)-d(y,t) or smaller.
- We return the path which travels from s to x via shortest path, then x to y via the computed path, then y to t via shortest path.

Point to Point Analysis

- Consider breaking the optimum path into three pieces, each visiting k/3 nodes.
- Let these pieces have boundaries (s,x) and (x,y) and (y,t). Suppose that:
- dP(s,x) > (1/3)(D-d(s,x)-d(x,t)) + d(s,x)
- dP(x,y) > (1/3)(D-d(s,x)-d(x,y)-d(y,t)) + d(x,y)
- dP(y,t) > (1/3)(D-d(s,y)-d(y,t)) + d(y,t)
- But then dP(s,t) > D + d(s,t): a contradiction.

Point-to-Point Result

- This gives a 3-approximation to the point to point orienteering problem. We visit at least a third of the intermediate nodes which optimum can visit while traveling a distance of at most D.

Bicriterion Approximation

Multiple Deadlines

- We now consider the multiple deadline problem. Each node x which we might visit has its own deadline D(x). Our goal is to visit as many nodes as possible before their respective deadlines.
- Note that orienteering is the case where the deadlines of all nodes are equal D(x)=D.

Small Margin Case

- Suppose most nodes x are visited between D(x)/1+ and D(x). In other words, most of the value comes from visiting nodes very close to their deadline.
- Intuitively, this means we are “almost” visiting nodes in order of deadline.

Small Margin Algorithm

- For each (j,x,y) we will find a path from x to y which visits as many nodes as possible which have deadlines between (1+)^j and (1+)^(j+1).
- This path should have length at most (1+)^j
- We will paste these segments together to maximize the number of nodes visited.
- Again we use dynamic programming.

Small Margin Analysis

- We obtain a solution which visits first nodes with deadlines between 1 and (1+) and then nodes with deadlines between (1+) and (1+)2 and so forth and so on.
- Our solution guarantees to visit each node at most (1+) after its deadline because of the segment lengths.
- We visit at least (1/3) as many nodes as the best solution with this ordering property.

Small Margin Result

- Note that we assume optimum doesn’t visit nodes more than (1+) before their deadline, so optimum uses almost the same ordering constraint.
- In particular, optimum visits nodes with deadlines between 1 and (1+) before nodes with deadlines after (1+)2.
- By using only even (or only odd) exponents, we can show that there is a solution within a factor 2 of optimum with the ordering constraint. This gives a 6-approximation in the small margin case, while violating deadlines by (1+).

Large Margin Case

- Now suppose many nodes are visited at times not even close to their deadlines (say at most D(x)/2).
- Consider retracing parts of the optimum path, first visiting the nodes with the earliest deadlines, then returning to u, then the next group of nodes, and so on.
- Retracing back and forth causes us to visit nodes later, but we can make sure it’s not worse than a factor of two later, so deadlines are not violated.
- Omitting details, we can get a 15-approximation.

Bicriteria Approximation

- We produce many paths, and take the best.
- The j’th path will be produced by assuming nodes are visited between D(x)/(1+)^(j+1) and D(x)/(1+)^j.
- Once we are only considering nodes visited before D(x)/2, we use the large margin case.
- This yields O(log 1/) paths, and between them they capture the optimum profit. Of course, each of our paths is approximate.
- We end up with a O(log 1/) (times constants) approximation. May violate deadlines by (1+).

O(log n) Approximation

O(log n) Approximation

- We’d like to avoid exceeding any deadlines.
- We can do this with O(log D) approximation where D = largest deadline, via appropriate setting of epsilon.
- However, we’d like approximation factor to be strongly logarithmic.

Minimal Vertices

- The labeled vertices are minimal. Any vertex which optimum visits after a minimal vertex must have a later deadline.
- Note that minimal vertices have increasing deadlines.

Rectangle Definition

- A rectangle R(a,b,c) has its left edge at the time OPT visits a, its top at the deadline of point c, and its lower right corner at point b. These points are all in the lower envelope.
- Two rectangles are disjoint if no vertical or horizontal line intersects both of them.
- A collection of disjoint rectangles is a collection of rectangles which are pairwise disjoint.

Disjoint Rectangles

5

4

Deadline

R(3,4,5)

3

These two disjoint.

2

R(1,3,4)

These two not disjoint.

R(1,2,3)

1

Time

A Family of Disjoint Collections

- Given a set of integers {n1, n2, …} we can define a collection of disjoint rectangles
- C = {R(nx-1, nx, nx+1) for all x}
- Note two rectangles R(h1,j1,k1) and R(h2,j2,k2) are disjoint if h2≥ j1 and j2≥k1.

- We create log n such collections, where collection Ci corresponds to the integers of the following form: {j2i + 2i-1: 0≤j≤2log m-i - 1}.
- Define C0 = the set of minimal vertices.

i

i-1

Every Node in OPT is in Family

- Consider a vertex v visited by OPT
- Let D(v[i]) ≤ D(v) ≤ D(v[i+1]) for some i
- Let t(v[j-1]) ≤ t(v) ≤ t(v[j]) for some j
- Observe that i ≥ j
- If i=j, then v is a minimal vertex (in C[0])
- Otherwise, i and j both lie in a rectangle of C[b] if the corresponding set contains exactly one number between [i, j]
- Select b such that 2b ≤ i-j ≤ 2b+1
- Now v is in either C[b] or C[b+1]

Approximating the Best C[b]

- Consider restricting OPT to just one collection C[b]. Since each rectangle contains a set of points with distinct deadlines, if we could run point-to-point orienteering on the rectangles we’d be done.
- But we don’t know which are the minimal vertices, and thus don’t know the rectangles.

Dynamic Program

- We arrange the vertices in increasing order of deadline.
- For each j,k we consider the graph restricted to vertices with deadlines between those of vertices j and k.
- We then solve point-to-point orienteering, requiring that each vertex be visited before deadline D(j).

Algorithm Details

- Let π(j,k,g,h,p) = approximately shortest path starting from g and ending at h which accumulates profit p from vertices with deadlines between D(j) and D(k).
- We construct these using P2P orienteering, guaranteeing that our path for profit p/3 has length at most the optimum shortest path for profit p.

More Details

- Now we compute (k, p, g) = minimum length path which obtains at least reward p from visiting nodes with deadline at most D(k) and has path end at g.
- This can be computed as:
- (k, p, g) = minj,q,h (j, q, h)+π(j,k,h,g,p-q)
- If (k, p, g)>D(k) then we consider the path to be NULL (not possible).

Deadline TSP Result

- Our algorithm produces a solution which visits at least 1/3 as many sites as the best solution based on disjoint rectangles.
- Since the optimum can be partitioned into O(log n) families of disjoint rectangles, this gives an O(log n) approximation to deadline TSP.

General Techniques

- The main technique for all of these results has been dynamic programming.
- While this is standard in building exact algorithms and FPTAS, its application to constant-approximations is new
- The main idea is to approximate certain portions of the dynamic program, and show that these factors add (not multiply).

Extensions

- Can be extended to deal with “start times” and thereby full “time windows” instead of just deadlines.
- Also provides O(1) approximation where rewards decay exponentially with time.
- Can also compute bounded-cost tours (cycles) or trees which maximize number of cities visited.

Download Presentation

Connecting to Server..