Document Sample
UCB-TSP Powered By Docstoc
					Approximation Algorithms for
    TSP with Deadlines
        Adam Meyerson
• 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
  – 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.
• 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
  – 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
        Minimum Excess Path
• We’d like to travel from s to t, while
  visiting at least k of the interesting sites in
• 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+
Approximate Minimum-Excess
     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
• Segments of type 1 have length b(j+1) - b(j).
• Segments of type 2 have length at least 3(b(j+1)-
• 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
    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.
        Example Path


s                 y
         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.
TSP with Deadlines

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
• 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
• 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+).
TSP with Deadlines

 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.
           Layout of the OPT Path



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


           1         R(1,2,3)

          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

                                  These two disjoint.
                          These two not disjoint.
           1         R(1,2,3)

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

  form: {j2i + 2i-1: 0≤j≤2log m-i - 1}.
• Define C0 = the set of minimal vertices.
    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
          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
Summary and Further Work
         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).
• 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.

Shared By: