# UCB-TSP

Document Sample

```					Approximation Algorithms for
UCLA
Acknowledgements
• Orienteering Results
– Joint with Avrim Blum, Shuchi Chawla, David
Karger, Terran Lane, Maria Minkoff
– FOCS 2003
– Joint with Nikhil Bansal, Avrim Blum, Shuchi
Chawla
– STOC 2004
Problem Statement
• We are given various points where deliveries must
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.
• 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
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
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.
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
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
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

x
t

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.

Bicriterion Approximation
• 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
• 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
• 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
• 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,
• 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.
Layout of the OPT Path
5

4
3
2

1

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

4
R(3,4,5)
3
2
R(1,3,4)

1         R(1,2,3)

Time
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
R(3,4,5)
3
These two disjoint.
2
R(1,3,4)
These two not disjoint.
1         R(1,2,3)

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
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
rectangles.
Dynamic Program
• We arrange the vertices in increasing order
• 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
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).
• 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.
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).
Extensions
• Can be extended to deal with “start times”
and thereby full “time windows” instead of
• 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.

```
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
 views: 0 posted: 2/15/2012 language: pages: 44