Abstract 1 Introduction 2 Preliminaries 3 An Approximation Scheme for 𝒌-path and Orienteering in Doubling Metrics 4 An Approximation Scheme for Deadline TSP in Doubling Metrics References

Approximation Schemes for Orienteering and Deadline TSP in Doubling Metrics

Kinter Ren Department of Computer Science, University of Alberta, Edmonton, Canada Mohammad R. Salavatipour ORCID Department of Computer Science, University of Alberta, Edmonton, Canada
Abstract

In this paper we look at various extensions of the classic Traveling Salesman Problem (TSP) on graphs with bounded doubling dimension and bounded treewidth and present approximation schemes for them. Suppose we are given a weighted graph G=(V,E) with a start node sV, distances on the edges d:E+ and integer k. In k-stroll problem the goal is to find a path from s of minimum length that visits at least k vertices. In k-path we are given an additional end node tV and the path is supposed to go from s to t. The dual problem to k-stroll is the rooted orienteering in which instead of k we are given a budget B and the goal is to find a walk of length at most B starting at s that visits as many vertices as possible. In the point-to-point orienteering (P2P orienteering) we are given start and end nodes s,t and the walk is supposed to start at s and end at t. In the deadline TSP (which generalizes P2P orienteering) we are given a deadline D(v) for each vV and the goal is to find a walk starting at s that visits as many vertices as possible before their deadline (where the visit time of a node is the distance travelled from s to that node). The best approximation for rooted orienteering (or P2P orienteering) is (2+ε)-approximation [13] and O(logn)-approximation for deadline TSP [4]. For Euclidean metrics of fixed dimension, Chen and Har-Peled present [16] a PTAS for rooted orienteering. There is no known approximation scheme for deadline TSP for any metric (not even trees). Our main result is the first approximation scheme for deadline TSP on metrics with bounded doubling dimension (which includes Euclidean metrics). To do so we first we present a quasi-polynomial time approximation scheme for k-path and P2P orienteering on such metrics. More specifically, if G is a metric with doubling dimension κ and aspect ratio Δ, we present a (1+ε)-approximation that runs in time nO((logΔ/ε)2κ+1). Building upon these, we obtain an approximation scheme for deadline TSP when the distances and deadlines are integer which runs in time nO((logΔ/ε)2κ+2). The same approach also implies a bicriteria (1+ε,1+ε)-approximation for deadline TSP for when distances and deadlines are in +. For graphs with bounded treewidth ω we show how to solve k-path and P2P orienteering exactly in polynomial time and a (1+ε)-approximation for deadline TSP in time nO((ωlogΔ/ε)2).

Keywords and phrases:
Deadline Traveling Salesman Problem, Orienteering, Doubling Metrics, Approximation algorithm
Category:
APPROX
Funding:
Kinter Ren: Supported by NSERC DG of the 2nd author.
Mohammad R. Salavatipour: NSERC
Copyright and License:
[Uncaptioned image] © Kinter Ren and Mohammad R. Salavatipour; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Routing and network design problems
Related Version:
Full Version: https://arxiv.org/abs/2405.00818 [31]
Editors:
Alina Ene and Eshan Chattopadhyay

1 Introduction

We study a fundamental variant of the Traveling Salesman Problem (TSP) in which the “salesman” wants to visit as many customers as possible before their required service deadlines. Suppose we are given a weighted graph G=(V,E) with a start node sV, deadlines D:V+, and a distance/length function d:E+. In the deadline TSP problem, our objective is to find a path (or a walk) starting at s that visits as many nodes as possible by their deadlines. We say that the path visits node v by its deadline if the length of the path, starting at s until it visits v (for the first time), is at most D(v). A node might be visited multiple times, but it is counted only once. Alternatively, we can assume G is a complete weighted graph where the edge weights satisfy triangle inequality, i.e. the (V,d) is a metric space.

A special case of the deadline TSP is the rooted Orienteering problem, where all the nodes have a universal deadline B (think of it as a budget for the length of the path travelled) and the goal is to find a path, starting at s, of length at most B that visits as many vertices as possible. Researchers have also studied another version of the Orienteering, known as point-to-point Orienteering problem, denoted by P2P orienteering, where we are given a start node sV, an end node tV, and a budget B. Here, our objective is to find an s-t path of length at most B that visits as many nodes (other than s,t) as possible. This too can be viewed as a special case of deadline TSP: the deadlines for each node v are set as Bd(v,t), and the deadline TSP path is completed by connecting it directly to the end node t. Notice that P2P orienteering can be seen as the “dual” of the k-path problem [12]. It is almost the same as the classical 𝒌-stroll problem [9] (also known as the (path) k-TSP problem [16]) except in k-stroll we are given a start node vV and integer k and the objective is to find a minimum-length path from s visiting at least k nodes, while in k-path problem we are given an additional end node tV and the path is supposed to go from s to t. It is important to note that P2P orienteering and k-path are equivalent in terms of exact algorithms. However, an approximation for one problem does not imply an approximation for the other.

Blum et al. [9] developed the first O(1)-approximation algorithm for the rooted orienteering problem in a general metric space. Their main approach involves a clever reduction to k-TSP, via an intermediate problem. They introduced the concept of excess (also referred to as regret) for a path and formulated the related minimum-excess problem, demonstrating that an approximation for the latter extends to an approximation for the orienteering problem. Given a path P that includes two vertices u,v, let dP(u,v) denote the length of the sub-path from u to v. The excess of an s,t-path P, denoted by P, is the difference between the length of the path and the distance between the endpoints of the path, P=dP(s,t)d(s,t) and the minimum-excess problem seeks to find an s-t path of minimum-excess that visits at least k nodes. Moreover, they [9] demonstrated that the min-excess problem can be approximated using algorithms for k-stroll, implying that an approximation algorithm for k-stroll leads to an approximation algorithm (with a constant factor loss in the ratio) for the orienteering problem, via the intermediate min-excess problem. Applying a similar approach and concentrating on enhancing the approximation algorithm for the k-stroll, the factor has been refined to the currently best (2+ϵ)-approximation, which also extends to P2P orienteering [13] in a general metric space.

Chen and Har-Peled [16] developed the first Polynomial-Time Approximation Scheme (PTAS) for the rooted orienteering problem in a fixed-dimensional Euclidean space. The prior reduction by [9] increases the approximation ratio by a constant factor and can not provide a PTAS. To achieve a PTAS for the rooted orienteering problem, Chen and Har-Peled [16] introduced the concept of μ-excess for a path (extending the notion of the excess of a path) and defined (ϵ,μ)-approximation for k-TSP. Roughly speaking, the μ-excess of a path is the difference between its length and the length of the best approximation of the path using straight lines between only μ nodes of the path (as opposed to considering the length of the line connecting the two endpoints of the path, as in the min-excess path). This notion is formally defined soon. An (ϵ,μ)-approximation for rooted k-TSP is any path that starts from the root and visits k points and whose length is at most P + ϵP,μ, where P denotes the length of the optimal rooted k-TSP path and P,μ is the μ-excess for the optimal path. Note that the upper bound provided by (ϵ,μ)-approximation for the k-TSP may be significantly tighter than that by (1+ϵ)-approximation (namely, (1+ϵ)P), especially when μ is sufficiently large, as the μ-excess of a path can be much smaller than the length of the path. In fact, Chen and Har-Peled [16] showed that the algorithm of Mitchell for classic TSP on Euclidean plane [29] provides a (ϵ,1ϵ)-approximation for the rooted k-TSP problem on the that metric and this leads to a PTAS for the rooted orienteering problem.

Deadline TSP seems substantially more difficult to approximate. For deadline TSP Bansal et al. [4] presented an O(logn)-approximation and extended that to an O(log2n)-approximation for the Time-Window TSP problem (where each node v, other than a deadline D(v), has also “release” time R(v), and it is “counted” if the time it is visited along the output path falls in the interval [R(v),D(v)]). They also provided a bicriteria approximation: one that produces a log(1/ε)-approximate solution that violates the deadlines by (1+ε). The O(logn)-approximation remains the best known approximation for deadline TSP on general metrics (in polynomial time). More recently, Friggstad and Swamy [20] presented an O(1)-approximation for deadline TSP which runs in time O(nlognΔ) where Δ is the diameter of the graph; for this they assume that distances (and so deadlines) are all integers. Approximations for both orienteering and deadline TSP for other metrics (such as directed graphs) have been obtained as well (discussed in Section 1.2). For instance, for deadline TSP on trees Farbstein and Levin [18], present a bicriteria (1+ε,1+ε)-approximation (i.e. (1+ε)-approximation and violating the deadlines by (1+ε)).

To the best of our knowledge, there is no true approximation scheme for deadline TSP on any metrics (even on Trees). Our goal in this work has been to obtain an approximation scheme for deadline TSP on bounded doubling dimensions (which includes Euclidean metrics as a special case). We should note that the best known approximation for deadline TSP on Euclidean metrics is the same as general metrics: O(logn)-approximation in polynomial time and O(1)-approximation in time O(nlognΔ).

1.1 Our Results and Techniques

By scaling we assume all distances are between 1 and Δ. Our main result of the paper is a Quasi-Polynomial Time Approximation Scheme QPTAS (under mild conditions) for deadline TSP on doubling metrics. (see the full version of our paper [31] for all missing proofs)

Theorem 1.

Suppose G=(V,E) is a graph with doubling dimension κ, start nodes sV and deadline D(v) for vV as an instance of deadline TSP where distances (and deadlines) are integer values. There is a (randomized) (1+ε)-approximation for deadline TSP that runs in time nO((logΔ/ε)2κ+2).

This is the first approximation scheme for any non-trivial metrics for deadline TSP. We note that not violating any of the deadlines is the critical. Along the way to obtain this goal we present a number of other results that are used as building blocks in the proof of this main theorem. As a starting point we show that orienteering can be solved exactly in polynomial time on graphs with bounded treewidth and how this can be turned into a QPTAS for deadline TSP on such metrics when the distances are integer and Δ is quasi-polynomial in n.

Theorem 2.

Given a graph with treewidth ω, there is an exact algorithm with running time is O(Poly(n)ωω2) for solving the k-path or P2P orienteering problem. Furthermore, there is an approximation scheme for deadline TSP on such graphs with integer distances with running time nO((ωlogΔ/ε)2).

Proof of this Theorem (see the full version [31]) is simpler and has some of the main ideas used in the subsequent theorems; so is a good starting point. We should note that recently (independently and after the first version of our paper [31] appeared), [10] considered orienteering on graph with bounded treewidth and obtained a (1+ε)-approximation by designing a different dynamic programming.

Next we focus on metrics with bounded doubling dimension.

Theorem 3.

Given a graph G=(V,E) with doubling dimension κ, start and end nodes s,tV and integer k. There is a (randomized) (1+ε)-approximation for k-path that runs in nO((logΔ/ε)2κ+1) time.

We actually show a stronger bound on the length of the k-path solution produced by this theorem which bounds the excess or regret similar to [16] for Euclidean metrics. Although getting a QPTAS for k-path on doubling metrics isn’t difficult using the known techniques, one needs the stronger bound obtained here (with respect to excess) as it is crucially used to prove the following:

Theorem 4.

Given a graph G=(V,E) with doubling dimension κ, start and end nodes s,tV and length budget B. There is a (randomized) (1+ε)-approximation for P2P orienteering that runs in time nO((logΔ/ε)2κ+1).

Building upon these theorems we then have the tools needed to prove Theorem 1. We note that the algorithm of this theorem can be adapted to obtain a (randomized) bicriteria (1+ε,1+ε)-approximation for deadline TSP (i.e. cost at most 1+ε the optimum while violating the deadlines by at most 1+ε) that works even when distances are in + (instead of integer) with the same running time.

Limitations of known techniques.

The reason that our running time in Theorems 1, 3, and 4, includes logΔ in the exponent is that our algorithm uses the (randomized) hierarchical decomposition of such metrics [32], which produces a decomposition of height O(logΔ). A natural question is: why can’t we get rid of the dependence on Δ (like [32])? One should note that for most vehicle routing problems on Euclidean or doubling metrics, one can assume that Δ=Poly(n) by a standard scaling of distances at a loss of (1+ε) in approximation factor (for e.g. this has been the first step in [2, 32, 7] for designing approximation schemes for TSP on Euclidean and doubling metrics). This however does not work for budgeted versions (such as orienteering or deadline TSP) as a feasible solution for the scaled version might violate the budget(s) by a (1+ϵ) factor in the original version. In other words, once we scale the distances (by 1+ε factor) to reduce to an instance with Poly(n) distances, a solution in the new instance will not yield a feasible solution in the original as the hard budget constraint (on the total distance) may be violated. Another point worth mentioning is that, although one can get an approximation scheme (with time nO(Polylog(Δ+n)) for k-path on doubling metrics by embedding them into Polylog(Δ)-treewidth metrics [33] and using Theorem 2, this will not lead to an approximation scheme for orienteering or deadline TSP as one needs a stronger guarantee, like we obtain in the proof of Theorem 3. Again, this is for the same reason that obtaining a true (and not bicriteria) PTAS for Orienteering on Euclidean metrics [16] required stronger k-path algorithms. In general, embedding results cannot be used for budgeted versions of vehicle routing (such as orienteering or deadline TSP).

A natural question is: can’t one extend the known techniques developed for designing PTAS’s for TSP on various metrics (such as planar metrics [28] or doubling metrics [7, 3]) to the setting of orienteering or deadline TSP? It appears the answer is not easy for orienteering and deadline TSP. In general, budgeted versions seem more difficult on any metrics. Extending the ideas of [7] to orienteering or deadline TSP encounters some problems. The very first one (as mentioned above) is the assumption that distances are bounded by Poly(n) by scaling and losing a (1+ε)-factor. This can be done for k-path but not in the budgeted settings such as orienteering or deadline TSP. Even if one bypasses this issue, the algorithm of [7] considers tours that are sparse or dense (we have a similar breakdown in our proof). However, for both situations [7] considers (approximate) portal respecting tours. Such tours might have large excess (or regret); so although they will have an approximately optimal overall length, they don’t have the stronger bound (with respect to the excess) needed to obtain a P2P orienteering solution (see [13, 16]). Furthermore, our algorithm for deadline TSP has a step (similar to [20]) that needs to guess a set of vertices whose “excess” (which is defined to be the difference of its visit time in optimum vs. the shortest path distance to the root) is growing geometrically. This requires guessing Θ(logΔ) many vertices. So overall, there are several obstacles to overcome to turn these algorithms into a PTAS. Nonetheless we hope that ideas developed here (in the proof of Theorem 1) can be used and extended to obtain a PTAS for deadline TSP in doubling or maybe Euclidean metrics.

1.2 Related Works

The seminal works of Arora [2] and Mitchell [29] presented the first PTAS for Euclidean TSP and some of its variants such as k-TSP. However, extending this to orienteering proved to be challenging. For orienteering on Euclidean plane Arkin et al. [1] presented a (2+ε)-approximation. The first PTAS for rooted orienteering on Euclidean metrics was given by Chen and Har-Peled [16]. More recently Gottlieb et al. [23] presented a more efficient PTAS for rooted orienteering on Euclidean metrics.

For orienteering on general metrics there are several O(1)-approximations [9, 13, 19], with the current best being (2+ε)-approximation by [13]. For orienteering on directed graphs Chekuri and Pál [15] present a quasi-polynomial time for various problems including deadline TSP, such as an O(logopt)-approximation for time window in quasi-polynomial time. Nagarajan and Ravi [30] also present poly-logarithmic approximations for directed variants of k-TSP and Orienteering, some of these results were improved in [8]. Chekuri et al. [13] present an O(log2opt)-approximation for the time-window version and an O(logopt)-approximation for P2P orienteering on directed graphs. There is also a line of research on stochastic orienteering (e.g. see [25, 5, 27]).

As said earlier, the best known result for deadline TSP on general metrics is by [4] which is an O(logn)-approximation. They also provide a bicriteria (O(log1ε),1+ε). Assuming distances (and deadlines) are integers, this implies an O(logDmax)-approximation where Dmax is the maximum deadline. Different extensions of deadline TSP have been studied also. For instance, Bansal et al. [4] present an O(log2n)-approximation for the time-window version and an O(logDmax)-approximation when the time window values are integer. Chekuri et al. [13] prove that any α-approximation for P2P orienteering implies an O(αmax{logopt,logLmaxLmin})-approximation for the time-window version where opt is the optimal value and Lmax and Lmin are the sizes of the largest and smallest windows. For the variant of time-window TSP where there are multiple time-windows given for each node, Garg et al. [22] proved an Ω(loglognlogloglogn)-hardness of approximation even on trees. There are other variants of orienteering and deadline TSP that have been studied (see [13, 15, 20, 21]).

Some variants of vehicle routing problems have been studied on doubling metric as well. Talwar [32] presented a QPTAS for TSP on such metrics. Bartal et al. [7] building upon the work of Talwar presented a PTAS for TSP on doubling metrics. Several variants of TSP, such as Capacitated Vehicle Routing Problem (CVRP) or TSP with neighborhoods have approximation schemes on doubling metrics [11, 26].

2 Preliminaries

We consider a metric space (V,d) as a (complete) weighted graph G=(V,E). By scaling we assume the minimum pair-wise distance is 1 and diameter is Δ. For vV and r0, we let B(v,r)={uV|d(u,v)r} denote the ball of radius r around v. The doubling dimension [24] of a metric space (V,d) is the smallest value κ such that for all vV, for all ρ>0, every ball B(v,2ρ) can be covered by the union of at most 2κ balls of the form B(z,ρ), where zV. A metric is called doubling when its doubling dimension is a constant. For a subset UV, the diameter of U, denoted by ΔU, is defined as maxu,vUd(u,v).

We now formally define the problems. We consider a metric space (V,d) which is induced by an edge-weighted graph G=(V,E). Let P=v1,v2,,vk be a path in G, starting at s=v1 and ending at t=vk. The length of the path is denoted by P=i=1k1d(vi,vi+1). We use |P| to denote the number of vertices on the path. If P is a walk then |P| is the number of distinct nodes in P. Let a μ-jump of P be a path v1=vi1,vi2,,viμ=vk of size μk obtained from P by bypassing some of its intermediate points. The optimum μ-jump of P, denoted by Jμ(P), is the μ-jump of P with the maximum length. We define the μ-excess of P (see [16]), denoted by P,μ, to be the difference between the length of P and the length of Jμ(P), i.e. P,μ=PJμ(P). Observe that P,μ may be significantly smaller than P, especially when μ is sufficiently large.

In k-path, we are given a start node s, an end node t, and a target integer k. The goal is to find a minimum length path from s to t that visits at least k nodes. An (ε,μ)-approximation for k-path is an algorithm that finds a path P with |P|=k where PP+εP,μ where P is the optimum solution. We study the following extension of k-path to multi-path in Section 3 where we design our algorithms for P2P orienteering.

Definition 5 (multi k-path).

Given a graph G=(V,E), m pairs of nodes (si,ti), 1im, and a target integer k, the goal of multi 𝐤-path is to find m paths Pi from si to ti in G such that:

  • the total number of distinct nodes visited by all paths P1,P2,,Pm is at least k. (a node might be visited by multiple paths, but it is counted only once.)

  • the total length of all m paths i=1mPi is minimized.

Notice that multi k-path becomes k-path when m=1.

In P2P orienteering, we are given a start node s, an end node t, and a budget B. The objective is to find an s-t path P with PB that maximizes the count of distinct nodes visited.

For any path P in G and nodes u,v in P, let Puv denote the subpath from u to v in P. In deadline TSP, we are given a start node sV and deadlines D(v) for each node in V. A feasible solution is a path starting at s. We say that such a path visits node vP by its deadline if PsvD(v). The objective is to find a path P starting at s to maximize the count of distinct nodes visited within their deadlines.

For graphs of bounded doubling dimension, like earlier works on problems on such metrics, we rely on a hierarchical decomposition of V. Suppose (V,d) is a doubling metric with diameter Δ. We employ the hierarchical decomposition of metric spaces by means of probabilistic partitioning. The decomposition is essentially the one introduced by Bartal [6], and subsequently used by others. In particular, Talwar [32] used this to design the first approximation scheme (QPTAS) for TSP and other problems in doubling metrics. A cluster C in the metric (V,d) is a subset of nodes in V. A decomposition of the metric (V,d) is a partitioning of V into clusters. A hierarchical decomposition of V is a sequence of partitions of V, where each partition is a refinement of the previous one. Normally this is represented by a tree T (called the split-tree), where each node of T corresponds to a cluster. We use C to both refer to a node in T as well as the cluster (set of nodes in V) it corresponds to. The root node of T corresponds to the single set {V} and the leaf nodes correspond to singleton sets {{v}}vV. The children of each node CT correspond to a partition of C where each part has diameter about half of that of C. The union of all subsets corresponding to the vertices at each level of T constitutes a partition of V.

Theorem 6 ([32]).

There is a hierarchical decomposition of V, i.e. a sequence of partitions Π0, Π1, ,Πh, where Πi1 is a refinement of Πi, Πh={V}, and Π0={{v}}vV, and satisfies the following:

  1. 1.

    Π0 corresponds to the leaves and Πh corresponds to the root of the split-tree T, and height of T is h=δ+2, where δ=logΔ and Δ is the diameter of the metric.

  2. 2.

    For each CT at level i, cluster CΠi, has diameter at most 2i+1.

  3. 3.

    The branching factor b of T is at most 2O(κ).

  4. 4.

    For any u,vV, the probability that they are in different sets corresponding to nodes in level i of T is at most O(κ)d(u,v)2i.

3 An Approximation Scheme for 𝒌-path and Orienteering in Doubling Metrics

Before we can give the proof of Theorem 1 we prove Theorems 3 and 4 as our algorithm for Theorem 1 builds upon the idea in these proofs. Suppose that G=(V,E) (a graph with bounded doubling dimension κ), s,tV, and budget B+ are given as an instance of P2P orienteering. Let δ=logΔG. We assume ΔG is quasi-polynomial in which case δ is polylogarithmic.

Overview.

Before we present our approximation scheme for P2P orienteering on G let us review the algorithm of Chen and Har-Peled [16] for P2P orienteering on Euclidean plane. They showed that the algorithm of Mitchell [29] for Euclidean TSP in fact implies a (ϵ,u)-approximation for k-path, i.e. an algorithm that finds a path P with |P|=k where PP+εP,μ, where P is the optimum k-path solution. Using this approximation algorithm to solve the orienteering problem (with the assumption that k is the guessed value of the optimum solution for orienteering), they show that one can break the path obtained by the algorithm into μ=O(1ε) segments, each containing εk vertices; this will be a μ-jump; once we remove one segment that has the longest length the total length of the path is dropped by at least εP,μ, and therefore the length of the resulting path is at most the length of the optimum path P and hence below the given budget and the total number of nodes is at least (1ϵ)k. This yields the approximation scheme for orienteering (via k-path). The algorithm for (ϵ,u)-approximation of k-path is essentially the algorithm of Mitchell [29] for Euclidean TSP which breaks the problem into (polynomially many) subinstances, each defined by a window w (a minimum bounding box). Mitchell defines a vertical (or horizontal) line that cuts a windows w a cut and for a parameter m=O(1/ϵ) if the number of edges of the optimum path that cross is no more than m then this cut is sparse; else is dense. If is sparse one can guess the edges of the optimum in time O(nm) and break the problem into independent instances. If there is no sparse cut then the value of the optimum in this window is large. In this case using either Mitchell’s [29] scheme (using bridges) or Arora’s scheme [2] for TSP (making paths portal respecting paths) one can modify the solution for the problem restricted to w to a near optimum one of length at most (1+1m)P(w), where P(w) is the restriction of the optimum path to window w. We should point out that this idea of partitioning sub-instances into sparse and dense regions has been used in other works (e.g. in [7] to obtain a PTAS for TSP on doubling metrics).

Our QPTAS for orienteering on doubling metrics builds upon this idea of sparse and dense sub-instances, but the difficulty is we do not have a polynomial size set of windows or cuts as in the Euclidean case. We first try to find a good approximation for k-path on G with a similar stronger upper bound on the quality of the solution: a solution with a stronger upper bound of the form P+ϵP,μ. We show the existence of a near-optimum solution for k-path which has some structural properties. Suppose that T is a hierarchical decomposition of G as in Theorem 6. Consider an arbitrary node CT of the hierarchical decomposition at level i with children C1,,Cσ. Roughly speaking we would like this near optimum solution to have very few edges crossing between different clusters Ci’s when we focus on C or these edges be portal-respecting if we impose some portals for each Ci as in the algorithm for TSP on doubling metrics [32]. The existanse of such a structured near optimum allows us to find it using a DP on T.

For simplicity of presentation, suppose P (for k-path) is known (let’s call this “Assumption 1”). As said above, consider CT with children C1,,Cσ. We also consider the restriction of P to C, denoted by PC=PC and let ΔC denote the diameter of C. We consider two cases based on whether PClognεΔC holds or not. If the inequality holds we call PC sparse with respect to C; else we call it dense.

Sparse case.

If PClognεΔC, we show in this case the expected number of edges of PC crossing between different subgraphs C1,,Cσ is O(κlognϵ); this uses property 4 of Theorem 6. For simplicity assume this actually holds with high probability instead of “in expectation” (call this “Assumption 2”)

Dense case.

If PC>lognϵΔC we modify PC to a near optimum one by making PC to be portal respecting when it crosses between C1,,Cσ (as was done for TSP for e.g. in [32]). We consider each of Ci and generate a set of O(logκn) portals for it. We make PC portal respecting, that is, we modify it such that it crosses between different subgraphs Ci only through portals to reduce the number of times it crosses between different subgraphs to be poly-logarithmic. We show the expected increase of length of PC in C is bounded by O(PCε/logn), which holds by Theorem 6. Again, assume that this actually holds with high probability instead of “in expectation” every time we do this (call this “Assumption 3”)

We modify P to a structured near optimum solution P as follows. Starting from the root of T, and let initially P=P. We modify P as we go down the tree T: for each node CT, if PC (restriction of P to C) is sparse w.r.t. C we make no modification going down to children of C. However, if PC is dense w.r.t. C, we make PC portal respecting when crossing between the subgraphs corresponding to children of C. This increases the length of PC by at most O(PCε/logn). Given that height of T is O(logn), the total increase in length of P over all steps can be bounded to be O(εP).

We have made a number of assumptions above that we should remove. We don’t know P (Assumption 1) and whether it is sparse or dense in each step we are going down the tree T. To remove this assumption we guess both cases of whether P is sparse or dense at each step and add both into the DP. To remove Assumptions 2 and 3, we repeat the random decomposition of Theorem 6 Ω(logn) many times at each step. In other words, imagine we do parallel (or non-deterministic) runs of the decomposition at each step we want to partition a cluster. Then instead of things holding in expectation, one can show that in at least one such decomposition Assumptions 2 and 3 actually hold with high probability. This idea of repeating random decompositions has been used in earlier works, most recently by [17] to present approximation scheme for k-MST on minor free graphs. This non-deterministic decomposition can be described as a tree itself, which we call a γ-split-tree. Recall that in the hierarchical decomposition we would partition each cluster C into C1,,Cσ where each Ci has diameter at most ΔC2 and σ2O(κ). In a γ-split-tree we consider γ many such (independent) partitions of C in each step when we decompose C. This will help us to show that for at least one partition, the properties that are shown to hold in expectation (Assumptions 2 and 3) actually hold with high probability for at least one partition of C. We don’t know which of the several parallel decompositions we run at each step will have this property; so we guess and try all of them in our DP.

In the next subsection we formalize this and present our structural theorem that proves the existence of a nearly optimum solution with certain properties. We then show in Subsection 3.2 that the structural theorem in fact shows the existence of a (ε,μ)-approximation for k-path. In Subsection 3.3 we show how we can find that using a suitable DP. Finally in Subsection 3.4 we prove that we show an approximation scheme for P2P orienteering.

3.1 Structural Theorem

Let P be any feasible solution and P be an optimal solution to k-path. For a subgraph (or subset of vertices) UG we use PU to denote the restriction of P to U.

Definition 7.

P is called η-dense with respect to UG if PU>ηΔU; otherwise P is η-sparse.

We will set η=lognϵ. A set CV is a ρ-cover for UV if for any uU, there exists cC such that d(u,c)ρ. A set S is a ρ-packing if for any two distinct points u and v in S, d(u,v)2ρ holds. A set N is a ρ-net for UV if N is a ρ2-packing and a ρ-cover for U. We can find a ρ-net for any graph G easily by iteratively removing balls of radius ρ. The center of these balls forms a ρ-net.

Consider a set CG. A random partition of C is a partition πC=C1,C2,,Cσ of C that is obtained by taking a random ΔC4-net of C (i.e. the centers chosen iteratively are picked randomly); so the balls of the net have diameter ΔC2 and we know that |πC|2O(κ). Note that the algorithm for proving Theorem 6 essentially starts from the single cluster {V} (as the root of the decomposition) and at each step, when we have a cluster C, it is decomposed into 2O(κ) parts by taking a random partition of C. We say an edge (u,v) is crossing πC if u and v are in different parts of πC i.e. uCi and vCj for ij. Such an edge is called a bridge-edge. The following lemma (implied by Theorem 6) shows one property of bridge-edges of πC.

Lemma 8 ([32]).

For any edge (u,v) with u,vC, the probability that (u,v) crosses πC (and so is a bridge-edge) is at most κd(u,v)ΔC for some constant κ=O(κ).

Consider PC=PC. We consider the set of edges of P that are bridge-edges, denoted as EπC, i.e. EπC={(u,v)P:(u,v) crosses πC}. Suppose PC is η-sprase with respect to C, i.e. PCηΔC. We upper bound the number of bridge-edges of πC, i.e. the size of EπC in this case.

Lemma 9.

If P is η-sprase with respect to C, then 𝔼[|EπC|]κlognϵ for some constant κ=O(κ).

Now suppose P is η-dense with respect to C. Again consider the (random) partition πC of C. For each CiπC, we further consider a βΔCi-net of it where β=ϵ4κδ ( recall δ=logΔG and κ is the constant in Lemma 8), denoted as Si and we call them the portal set for Ci. The following packing property of doubling metrics bounds the size of |Si|:

Proposition 10 ([24]).

Let (V,d) be a doubling metric with doubling dimension κ and diameter Δ, and let S be a ρ-packing. Then |S|(Δρ)κ.

Using this proposition: |Si|(8κδϵ)κ. We are going to modify PC such that when it crosses between different clusters Ci in πC (i.e. uses bridge-edges) it does so via portals only. This means after the modification it will use portal-edges; those bridge-edges whose both end-points are portals. We say a path P is portal respecting with respect to πC if for any edge u,v of P crossing between two parts Ci,CjπC, it only cross through portals, i.e. uSi and vSj. The following lemma shows that one can modify PC to be portal respecting with respect to πC with a small increase of length.

Lemma 11.

PC can be changed to another path P that is portal respecting with respect to πC such that 𝔼[P](1+ε2δ)PC.

Proof.

We start with PC and whenever an edge u,v of PC is crossing two parts Ci,CjπC that are not portals we replace that edge with a path between u,v via the closest portals in Ci and Cj. Consider any edge u,v in PC that crosses πC, say uCi and vCj. Let u be the nearest portal to u in Si and v be the nearest portal to v in Sj. Replace edge u,v in PC by the edges (u,u), (u,v), (v,v). The increased length incurred is d(u,u)+d(v,v)+d(u,v)d(u,v), which is at most 2d(u,u)+2d(v,v) by triangle inequality. Note that because Si is a βΔCi-net of Ci then d(u,u)βΔCiβΔC2 and d(v,v)βΔCjβΔC2. Thus the increased length incurred is at most 2βΔC. Recall that for u,vPC, the probability that (u,v) crosses πC is at most δκd(u,v)ΔC. Thus in expectation, the increased length of PC after making it portal respecting with respect to πC is at most u,vPCκd(u,v)ΔC2βΔC=κβPC=ϵ2δPC. Now we formalize the idea of parallel runs of the hierarchical decomposition of Theorem 6. Note that the algorithm for proving Theorem 6 starts from the single cluster {V} (as the root of the decomposition) and at each step uses a random partition to the current cluster C to decompose it into 2O(κ) clusters of diameter half the size. This continues until we arrive at singleton node clusters (leaves of the split-tree). We call one random partition of a cluster C a split operation. The γ-split-tree hierarchical decomposition of a doubling metric is obtained by considering γ random partitions of C (instead of just one) at each step. A γ-split-tree decomposition has two types of nodes that appear in alternating layers: cluster nodes and split nodes. For each cluster C we have γ split nodes in the γ-split-tree (each corresponding to a random partition of C) and these split nodes are all children of C. For each split node s that is a child of C, it will have children C1,,Cσ that are clusters obtained by decomposing C according to the random partition corresponding to s. We continue until leaf nodes are cluster nodes with constant size.

Definition 12.

A γ-split tree for G is a rooted tree Γ with alternating levels of cluster nodes and split nodes. A cluster node C corresponds to a subset of V. The root of Γ, corresponds to the single cluster {V} and each leaf node corresponds to a set of size O(1) of vertices. Each non-leaf cluster node C has γ split nodes as its children. Each split node corresponds to a (random) partition of C into clusters of diameter ΔC2. Each of those clusters becomes cluster children of the split node. So each split node has 2O(κ) (cluster) children.

Suppose Γ is a γ-split-tree for G and Φ is a partial function from (some) cluster nodes of Γ to one of their split node children with the following properties:

  • Φ(C0)=s for some child split node of C0 (where C0 is the root of Γ).

  • if every ancestor split node of C is in the image of Φ then Φ(C) is defined.

Note that this function induces a “standard” hierarchical decomposition split-tree as in Theorem 6 as follows: start at the root node C0={V} of Γ and let root of tree T be C0 and repeat the following procedure: at each step, being at a cluster node C pick Φ(C) (a split node child of C) and consider the cluster children of Φ(C), say C1,,Cσ, and create nodes corresponding to these as children of C in T. Recursively repeat the procedure from each of them. This builds a split-tree tree T. We call such a (partial) function Φ a determining function for Γ and we say T is induced by Φ on Γ: T=Γ|Φ.

For any cluster C and the split node defined by Φ(C), we use |PEπΦ(C)| to denote the number of bridge-edges of P in πΦ(C), i.e. |PRπΦ(C)|=EπΦ(C). Let γ=3logn, we can build a γ-split tree Γ for G in the following way. We start by making C0={V} to be the root of Γ and iteratively add levels to Γ. For a cluster node C, we generate its children split nodes as follows: we compute γ independent random partitions of C, denoted as {πi}, 1iγi. Each πi=Ci,1,,Ci,σi (where σi2O(κ)) is obtained by taking a random ΔC4-net for C. Let Rπi be the set of bridge-edges of C, i.e. edges in C crossing πi: Rπi={u,vC:uCi,j,vCi,j, for jj}. For each Ci,j, we further consider the portal set Si,j which is a βΔCi,j-net of it. Let Rπi be the set of portal edges of C: Rπi={u,vC:uSi,j,vSi,j, for jj}. Since G is a doubling metric and S is a net, we find the following bound on the sizes of the portals: |Rπi|(σi|Si,j|)2 which is bounded by (16κδϵ)2κ. We create a child split node si for C for each πi.

For a split node s, let C be its parent cluster node and let πi be the partition (i.e. the ΔC4-net for C) corresponding to s. Then for each Ci,jπi we create a child cluster node Cj for s. The number of the children cluster nodes of s is at most 2O(κ). We continue this process until each leaf node is a cluster node C with |C|=O(1). From the construction above we know ΔCiΔC2 if Ci is a child of a split node s which is a child of C. Thus there are at most 2logΔG=2δ levels in Γ. If we define the height of Γ as the number of levels of cluster nodes then the height of Γ is at most δ. The branching factor of Γ is then the product of the branching factor of a cluster node and a split node, which is at most γ2O(κ). Hence the size of Γ is (3logn2O(κ))δ. Now we are ready to prove the following structure theorem for a near optimum solution.

Theorem 13 (structure theorem).

Let graph G=(V,E) with doubling dimension κ, start and end nodes s,tV, and integer k be given as an instance of k-path. Assuming P is an optimum solution and γ=3logn we can construct a γ-split-tree where with probability at least 11n there exists a determining function Φ and a corresponding split-tree hierarchical decomposition T=Γ|Φ of G and a nearly optimal solution P such that P visits at least k vertices and for any cluster CT we have either:

  • 1) |PRπΦ(C)|2κlognϵ, or

  • 2) |PRπΦ(C)|(16κδϵ)2κ and PC(1+ϵ)PC.

Proof.

Suppose Γ is a γ-split-tree for G. We build P iteratively based on P and at the same time build Φ() and hence T from the top to bottom.

Initially we set P to be P and start from the root cluster node C0 of Γ. At any point when we are at a cluster node C we consider whether P is sparse or dense with respect to C:

Sparse case.

If PCηΔC, i.e. P is η-sparse with respect to C, we don’t modify PC for when going down from C to any split node s of C. Consider any child split node s of C and let πs be the partition of C according to the split node s. Consider the number of edges of PC that are bridge-edges based on this partition i.e. |Eπs| (where Eπs=PRπs). According to Lemma 9, 𝔼(|PRπs|)=𝔼(|Eπs|)κlognϵ. Let the event Λs be the event that |PRπs|2κlognϵ. By Markov inequality Pr[Λs]12. Recall there are γ=3logn many children split nodes of c, i.e. γ independent random partitions of C. Thus the probability that for at least one child split node s of c, event Λs holds is at least 1(112)3logn11n3. In this case we select split node s and define Φ(C)=s and consider each cluster child node of s iteratively (P has not changed in this step).

Dense case.

Suppose P is η-dense with respect to C. Consider an arbitrary split child s of C. We will modify P going down the split node s to be portal respecting with respect to πs as described in Lemma 11. Assume πs=C1,,Cσ. For each Ci let Si be a set of portals. If we go down the split node s we modify P to be portal-respecting for each Ci. Note that the set of edges P crossing πs after making it portal respecting with respect to πs is a subset of Rπs. Thus |PRπs| is at most |Rπs| which is at most (16κδϵ)2κ in this case. According to Lemma 11, the expected increase of length of P after making it portal respecting with respect to πs is at most ϵ2δPC. Let Λs be the event that the increase of length of P after making it portal respecting with respect to πs is at most ϵδPC. By Markov inequality, Pr[Λs]12. Recall there are γ many children split nodes of C. Thus the probability that for at least one child split node s of C we have Λs is at least 1(112)3logn11n3. In this case we set Φ(C)=s for this particular split node s for which Λs happens.

Therefore, regardless of whether P is sparse or dense w.r.t. C, such s exists for cluster C with the probability at least 12n3 and we can define Φ(C). Once we have Φ(.) defined for clusters at a level of Γ, we have determined the clusters at the same level of T=Γ|Φ. Note there are at most n cluster nodes in one level of T. Thus with probability at least 12n2 such split nodes exist for all cluster nodes in one level. Since height of Γ (and T) is δ, thus with probability at least (12n2)δ11n (assuming that δ is polylogarithmic in n) such Φ(.) is well defined over all levels. Note the increase of length of P only occurs when P is η-dense with respect to C and for any of these clusters C in Γ|Φ, the increase of length P by modifying P to be portal respecting with respect to πΦ(C) is at most εδPC. Since this (1+εδ)-factor increase occurs each time we go down the decomposition form a cluster C to the next cluster level down, and the height of the decomposition is δ, thus inductively, for any cluster C in Γ|Φ: PC(1+ϵδ)δPCeϵPC(1+ϵ)PC for some ε>0 depending on ε. Replacing ϵ with ε we get PC(1+ϵ)PC.

3.2 (𝜺,𝝁)-approximation for 𝒌-path

In this section we show a stronger bound on the length of the near optimum solution P guaranteed by Theorem 13. Recall that a (ε,μ)-approximation for k-path is a path P with |P|=k where PP+εP,μ where P is the optimum solution. We prove that path P in Theorem 13 is in fact an (ε,μ)-approximation for μ=1ϵ+1.

Recall that in the proof of the structure theorem, the increase in length of P only happens in cases when P is dense with respect to a cluster C in Γ and we make the path portal respecting. Consider such a dense cluster C in the hierarchical decomposition T=Γ|Φ, i.e. P is η-dense with respect to C. We show P has high μ-excess in this case and the increased length of P in C can be upper bounded by a factor of μ-excess of P.

Lemma 14.

Let D be a set of disjoint clusters and Q be a path. Then Q,2CD(QCΔC).

Proof.

Intuitively, this is saying if Q passes through several (disjoint) clusters in D then the excess of Q is at least as big as sum of excess of Q in those clusters.

Suppose start-end node of Q are u,v and let Q0 be the path just consisting of u,v. By definition of the excess, Q,2=QQ0. Now consider following path Q, which starts at u and follows Q but when it encounters a cluster C in D and it visits C for the first time it directly connects the start and end node of the subpath of Q in C. When it encounters a cluster C in D that is visited before, then bypasses C entirely, i.e. directly connects the last vertex in Q before it enters C this time and the first vertex in Q after it visits after it exits C this time. From the construction of Q, if CD, then QCΔC. Clearly for any cluster CD: QC=QC. Thus Q,2=QQ0QQ=CD(QCQC)CD(QCΔC).

Theorem 15.

Let graph G=(V,E) with doubling dimension κ, start and end nodes s,tV, and integer k be given as an instance of k-path. Suppose P and Γ|Φ are as guaranteed by Theorem 13. Let μ=1ϵ+1, then P is a (ϵ,μ)-approximation.

Proof.

Note that in the proof of Theorem 13, the increase of length of P only occurs when P is η-dense with respect to a cluster C. We generate a set of disjoint clusters D in T=Γ|Φ: we start from C0 (the root of T) to generate D iteratively. If P is η-dense with respect to C then add C to D, if P is η-sprase with respect to C and C is a non-leaf cluster node then iteratively consider all children cluster nodes of C. Let D be the set of cluster nodes returned by this process. From the construction of D, clusters in D are disjoint, and for each cluster CD, P is η-dense with respect to C and PP=CD(PCPC).

Let {v1,,vμ} be the optimal μ-jump of P and let P1,P2,,Pμ1 be the subpaths divided by the vertices in this μ-jump, i.e. Pi is the subpath of P whose start and end are vi and vi+1, respectively. By definition of excess, P,μ=i=1μ1Pi,2. For the set D and each Pi, by Lemma 14, Pi,2CD(PiCΔC). Thus P,μi=1μ1CD(PiCΔC), which is CD(PC(μ1)ΔC). Recall from the proof of Theorem 13 that we modify P when it is η-dense with respect to C (i.e. PC>lognεΔC) and we always have PC(1+ε)PC, which implies PClognϵ(1+ε)ΔC; in a sense P is also (almost) η-dense with respect to C. Since μ=1ϵ+1, thus PC(μ1)ΔCPC2ε and P,μCDPC2ε.

As in the proof Theorem 13, for any cluster CT, PC(1+ϵ)PC. Thus PP=CD(PCPC)CDϵPC2ϵ2P,μεP,μ.

We should note that we can generalize this proof slightly as follows. Suppose that we pick some arbitrary μ-jump of P (instead of the optimum) and consider P~1,,P~μ1 which are the subpaths of P defined by that μ-jump. Then the same arguments show that i=1μ1P~i,2i=1μ1CD(P~iCΔC)=CDPC(μ1)ΔC which implies i=1μ1P~i,2CDPC2. Using this one can show that at the end PP+εi=1μ1P~i,2. This slightly more general version will be used later when designing our algorithm for deadline TSP.

3.3 Finding A Near Optimum Solution For 𝒌-path

In this section we prove Theorem 3 by showing how we can find a near optimum solution for k-path as guaranteed by Theorem 15 using Dynamic Programming (DP). The DP is built on the γ-split tree Γ we compute. Consider an arbitrary cluster node C in Γ and the restriction of the near optimum solution P in the subgraph G(C), denoted by PC. The set of edges of PC might be a collection of disjoint paths; one can imagine following along P, it enters and exits C multiple times and each time it enters it follows a path in C until it exits again (assuming that s,t are not in C). If we denote the start-end of these subpaths in C as si,ti, 1im (for some m) and if |PC|=kC then PC is a feasible solution for multi k-path with start-end pairs si,ti and parameter kC. This suggests a subproblem in our DP table will corresponds to an instance of multi-path k-path in a cluster C.

We define a subproblem in the DP as an instance of multi-path k-path with specified cluster node C, integer kC and σC start-end pairs of vertices {(si,ti)} and the goal is to find a set of paths {Pi}i=1σC such that Pi is a si-ti path in C and |i=1σCPi|=kC while minimizing i=1σCPi. We use A[C,kC,(si,ti)i=1σC] to denote the subproblem defined above and let the entry of the table store the optimal value of the solution to multi-path k-path for this subproblem. One should note that in the proof of Theorem 13, when we build P from P, each time we go down a node of the split-tree, we might have a number of bridge-edges (when P is η-sprase with respect to the current cluster C) or portal-edges (when P is dense with respect to the current cluster C). When P is sprase, the number of bridge-edges is at most 2κlognε (it was event Λs in the sparse case) and when P is dense then the number of portal-edges is at most (16κδϵ)2κ. Therefore, each step P restricted to C might be chopped up into at most (16κδϵ)2κ subpaths, each with a new start-end point in a cluster Ci that is part of the partition of C. Given that the height of the split-tree is δ, the total number of start-end points for the instance of multi k-path at any cluster node C is at most δ(16κδϵ)2κ. This upper bounds σ in our subproblems.

Now we describe how to fill in the entries of the table. The base cases are when the cluster C has constant size |C|=a. Such instances can be solved using exhaustive search in O(1) time.

Consider an arbitrary entry A[C,kC,(si,ti)i=1σC] where for all split nodes children of C and every cluster children of them the entries of the table are computed. Consider any child split node s of C in Γ and let C1,C2,Cg be the children cluster nodes of s in Γ. Recall πs is the corresponding partition of C and Rπs is the set of bridge-edges in C (crossing πs). For each Cj let Sj be its portal set and recall Rπs is the set of edges crossing πs only through {Sj}. We guess kCj for each Cj such that j=1gkCj=kC. We show how to guess start-end pairs {(si,ti)i=1σCj} for each Cj and check the consistency of them. To do so we consider two cases: in the first case (meaning we guess we are in the sparse case) we guess a subset of Rπs of size at most 2κlognϵ; in the second case (meaning we assume we are in the dense case) we guess a subset of Rπs of size at most (16κδϵ)2κ. Let Eπs be the subset guessed in either case. Furthermore for each edge in Eπs, we guess it is in which one of the σC paths with start-end pair (si,ti)i=1σC and for each path with start-end pair (si,ti) we guess the order of the guessed edges appearing on the path. Specifically speaking, let e1,e2,el be the edges guessed in the path with source-sink pair (si,ti) appearing in this order. Let Ca1,Ca2,,Cal+1 be the children cluster nodes of s that the path encounters following e1,e2,el, i.e. e1 crosses between Ca1 and Ca2, e2 crosses between Ca2 and Ca3, , and el crosses between Cal and Cal+1. Then we set si and the endpoint of e1 in C1 to be a start-end pair in Ca1, the endpoint of e1 in Ca2 and the endpoint of e2 in Ca2 to be a start-end pair in Ca2, , the endpoint of el in Cal+1 and ti to be a start-end pair in Cal+1. By doing so we generate start-end pairs for each Cj and we sort them based on their ordering in si-ti path and in the increasing order of i. This defines σCj start-end pairs for each Cj.

Lemma 16.

We can compute all entries A[C,kC,(si,ti)i=1σC] in time nO((δϵ)2κ+1).

The goal is to compute A[c0,k,(s,t)] where k and (s,t) are specified in the k-path instance. Proof of Theorem 3 follows from this lemma and Theorems 13 and 15.

Proof of Lemma 16.

Formally, to compute A[C,kC,(si,ti)i=1σC]:

  • Consider any child split node s of C, let C1,C2,,Cg be the children cluster nodes of s (where g can depend on s).

  • Guess (i.e. try all possible values) kCj for each Cj such that j=1gkCj=kC.

  • Let πs be the corresponding partition of C and Rπs be the bridge-edges of πs. For each Cj let Sj be the portal set for it and let Rπs be the set of portal-edges of πs. We consider both of the following two cases: 1) we guess a subset of Rπs of size at most 2κlognϵ; 2) we guess a subset of Rπs; in both cases we denote the set of guessed edges as Eπs.

  • For each edge in Eπs, we guess it is in which one of the σC paths with start-end pair (si,ti)i=1σC and for each path with start-end pair (si,ti) we guess the order of the guessed edges appearing as described above. We generate {(si,ti)}i=1σCj for each Cj accordingly. Then:

  • We set A[C,kC,(si,ti)i=1σC]=minj=1gA[Cj,kCj,(si,ti)i=1σCj]+(u,v)Eπsd(u,v), where the minimum is taken over all tuples s,kC1,,kCg,(si,ti)i=1σC1,,(si,ti)i=1σCg as described above.

Based on the structure theorem and the recurrence given above it is straightforward to see that this recurrence computes the best P as guaranteed in Theorem 15.

Now we analyze the running time. First we show the time required to compute one entry of the DP table is nO((δϵ)2κ+1). In the recursion, for a cluster node C, there are 3logn children split nodes of C to consider. For a certain split node s, let C1,C2,,Cg be children cluster nodes of s, there are at most ng guesses to for {kCj} such that j=1gkCj=kC, which is at most n2O(κ) because g2O(κ). For Eπs: there are two cases, if EπsRπs then |Eπs|2κlognϵ, there are at most n(4κlognϵ) many possible Eπs’s to consider; if EπsRπs, then because |Rπs|(16κδϵ)2κ in this case there are at most 2(16κδϵ)2κn(16κδϵ)2κ many possible Eπs’s to consider. To generate (si,ti)i=1σCj for each Cj: for a certain Eπs and for each edge in Eπs we guess it is in which one of σC paths with start-end pair (si,ti)i=1σC and for each path with start-end pair (si,ti) we guess the order of the edges appearing, which is at most |Eπs|!|Eπs|σC guessings. Note at each recursion it may increase at most |Eπs| many the number of start-end pairs and the depth of the recursion is δ. Thus σCδ|Eπs| and |Eπs|!|Eπs|σc(16κδϵ)2κ!(16κδϵ)2κδ(16κδϵ)2κnO((δε)2κ+1).

We show the size of the dynamic programming table is at most nO((δϵ)2κ+1). Recall an entry of the table is of the form A[C,kC,(si,ti)i=1σC]. For C, there are at most (3logn2κ)δ cluster nodes in Γ because the size of Γ is at most (3logn2κ)δ. For kC, there are at most n possible value of kC to consider. For {si,ti}i=1σC, there are at most n2σC start-end pairs to consider, which is at most n2δ(16κδϵ)2κ because σC is at most δ|Eπs|.

Therefore, computing the whole DP table and finding the near optimum path P as in Theorem 15 takes at most nO((δϵ)2κ+1) time.

3.4 Approximating P2P Orienteering on Doubling Metrics

In this section we prove Theorem 4 using the results of previous section for k-path.

Lemma 17.

Let G=(V,E) be graph with constant doubling dimension κ and given an instance of a P2P orienteering on G with specified budget B, start node sV and end node tV. Let P be the optimal for this instance and k=|P|. Then we can get a s-t path that visits at least (1ϵ)k vertices in G with the length at most B.

Proof.

Let μ=1ε+1 and assume that kμ2 (otherwise we can find P in polynomial time by exhaustive search in time O(n1/ε2)). We construct a subsequence of 1,,k to define a μ-jump of P: Let ai=(i1)(k1)μ1+1, 1iμ. Note that a1=1 and aμ=k. Let P1,P2,,Pμ1 be the subpaths of P divided by {va1,,vaμ}, i.e. Pi is a subpath of P with the source vai and sink vai+1.

For each Pi we consider the 2-excess of it and let Pj be the subpath with maximum 2-excess among {Pi}i=1μ1, i.e. j=argmaxiPi,2. Note |Pj|=aj+1aj+1=(j(k1)μ1+1)((j1)(k1)μ1+1)+1k1μ1+1. Then let P be the path exactly the same as P except P directly connects vaj and vaj+1 in Pj. From the construction of P,

|P|=k|Pj|+2kk1μ11+2kk1μ1(1ϵ)ksince kμ2, and (1)
P=PPj,2=BPj,2. (2)

We consider P as a feasible solution for a k-path instance with k=|P|(12ϵ)k and s,tV. By Theorem 15, we can compute a (ϵ,μ)-approximation for this instance where μ=1ϵ+1, denoted as P′′:

|P′′|k(1ϵ)kand (3)
P′′P+ϵP,μBPj,2+ϵP,μBPj,2+1μ1P,μ, (4)

where the 2nd line uses (2). We consider the μ-jump of P defined by va1,,vaμ. Note that this is is also a w-jump of P. By the definition of excess and how we obtained P from P (by short-cutting Pj,2):

P,μ||P||||va1,,vaμ||=i=1μ1Pi,2Pj,2. (5)

Thus, using (4) and (5): P′′BPj,2+1μ1(i=1μ1Pi,2Pj,2)B, where the last inequality follows from the fact that Pj,2 is the largest among all indices.

However, for the P2P orienteering instance, P and k in Lemma 17 are unknown in advance. Therefore, we will consider all possible integers 1kn and for each k we get the approximation for k-path on G with specified k and s,tV. We return the maximum k such that the length of path we get for k-path is at most B. This completes the proof of Theorem 4.

4 An Approximation Scheme for Deadline TSP in Doubling Metrics

In this section we prove Theorem 1. Our algorithm builds upon ideas from [20] for O(1)-approximation for deadline TSP for general metrics combined with new ideas as well as those developed in the previous section to get an approximation scheme for deadline TSP on doubling metrics. Friggstad and Swamyy [20] present an O(1)-approximation for deadline TSP running in time nO(lognΔ) assuming that all distances are integers and at least 1. They use the notion of regret which is the same as 2-excess. Note if path P visits u and then v then short-cutting the subpath Puv (replacing it with edge uv) will save a length which is exactly Puv,2. They guess a sequence of vertices v0=s,v1,,v of an optimal solution (with =O(logΔ)) such that the 2-excess of the subpaths of optimal increase geometrically: Pvivi+1,2αi, where α is some constant satisfying 1+αα2. They consider a set of P2P orienteering instances with start node vi, end node vi+1, and length budget d(vi,vi+1)+αi. These instances are not independent however, hence this is a more general problem that we call multi-path orienteering with group budget constraints (see [20]). They show given an β-approximation for P2P orienteering, at an another O(1)-factor loss, one can turn it into an O(β)-approximation for multi-group multi-path orienteering. Then they concatenate these paths; these paths are not respecting the deadlines however. In order to make them deadline respecting, from every three consecutive paths they shortcut two of them, so another O(1)-factor loss. The saving for the shortcutting of two paths is enough for the deadline of every vertex in the third path being satisfied. To obtain O(1)-approximation for P2P orienteering instances with groups, they use known reductions from the problem of maximum coverage with group budgets to classic maximum coverage and use algorithm of [14] to get a constant approximation via a reduction to classic P2P orienteering (see [20] for more details). Putting everything together, to obtain an O(1)-approximation for deadline TSP they lose O(1) factor in three steps.

In our setting in order to get a (1+ε)-approximation for deadline TSP on graphs with bounded doubling dimension, we have to change all these steps so that we don’t lose more than (1+ϵ) factor in any step. It turns out it becomes significantly more complex to maintain an at most (1+ϵ) loss in any step. As in [20], we assume distances are integer and 1 (this can be done as pointed out in [20] by scaling).

Overview of the proof.

Suppose we have guessed a sequence of vertices v0=s,v1,,vm of an optimum solution P where the μ-excess of the sub-path Pvi,vi+1 is (at least) αi, where α=1+ε (for simplicity assume the increase in excess is exactly αi). We also assume we have guessed the lengths of these sub-paths, say Pvi,vi+1=Bi. Note that the vertices visited in Pvi,vi+1 all must have a deadline at least as big as the visit time of vi in P(which we have guessed since we know all previous Bj’s, j<i); let Wi denote this set of vertices. Let i be the P2P orienteering instance with start-end pair vi,vi+1, budget Bi, where the vertices allowed to visit are Wi. Note that the sub-paths Pvi,vi+1 form a solution to these instances i for i1. If we have vi’s and Bi’s, we can try to solve these O(logΔ) instances simultaneously (our DP described for P2P orienteering can be expanded to handle when we have O(logΔ) instances to be solved on the same ground set simultaneously).

One problem is that the vertices visited in i might be violating their deadlines slightly. We will show that this violation will be small (using the assumption that the excess of subpath Pvi,vi+1 was αi) and that by using a similar technique as we did to convert an approximation for k-path to an approximation for P2P orienteering we can drop a small fraction of vertices visited in all instances such that the total saving in time achieved for all j with j<i is enough to ensure all the (remaining) vertices in i are visited before their deadline. Now we start explaining the details of the proof.

Let G=(V,E) be a graph with constant doubling dimension κ, given a start node sV and deadline D(v) for all vV as an instance of deadline TSP on G. Suppose μ is a constant (will be fixed to be 1ε+1 later and let α=(1+ε). Let P be an optimum solution for this instance and v0,v1,,vm be a sequence of vertices in P satisfying the following properties:

  • v0=s is the start node of P.

  • vi+1 is the first vertex in P after vi with Pvivi+1,μ>αi, except possibly for vm (the last vertex of P).

So each vertex vi+1 is the first vertex along the optimum after vi such that the μ-excess of the subpath Pvivi+1 is at least αi. We will be guessing these vertices vi’s eventually and try to find (good) approximations of Pvivi+1. We can assume that |Pvivi+1|μ2, otherwise we can compute Pvivi+1 exactly using exhaustive search. We also denote the vertex on P immediately before vi+1 by vi. Note PnΔG, thus mhδ (where δ=logΔ) for some constant h=h(ε)>0. For each 0i<m, we break Pvivi+1 into μ1 subpaths of (almost) equal sizes, denoted as Pi,j,1j<μ, by selecting a μ-jump Ji:vi=ui1,ui2,ui3,,uiμ1,uiμ=vi+1 as follows. Assume Pvivi+1=vi,1,,vi,ki where vi=vi,1 and vi,ki=vi+1, let aj=(j1)(ki1)μ1+1 then a1=1, aμ=ki, and if we consider vi,a1,,vi,aμ then we obtain Ji by letting vi,aj=uij. Suppose Jμ=Jμ(Pvivi+1) is the optimum μ-jump of Pvivi+1, which is the μ-jump with the maximum length. Recall that Pvivi+1,μ is the μ-excess of Pvivi+1 and with Bi=Jμ(Pvivi+1)+Pvivi+1,μ we have Pvivi+1=Bi.To simplify the notation we denote the μ-excess of subpath Pvivi+1 by i,μ. We also use i,μ to denote the μ-excess of path Pvivi. From the definition of v0,v1,,vm it follows that i,μ>αi and i,μαi1. Let v be an arbitrary vertex in Pvivi+1 that falls in between uij and uij+1. We use Ji(vi,uij) to denote the length of Ji from vi to uij (i.e. following along Ji from the start node vi to uij). Define Li,j=j=0i1Pvjvj+1+Ji(vi,uij). Note that the visiting time of v in P (and hence the deadline of v) is lower bounded by Li,j.

Let Ni,j={v:D(v)Li,j}. Observe that if we consider Pvivi+1 broken up into several legs Puijuij+1, 1j<μ, then it is a P2P orienteering instance with start node vi, end node vi+1 and given extra intermediate nodes uij and the path is supposed to go through these intermediate nodes in this order; so it consists of μ1 legs where leg j is between uij,uij+1 and uses vertices in Ni,jV and total budget Bi=Jμ(Pvivi+1)+i,μ.

Definition 18 (multiple-groups-legs orienteering).

Let G=(V,E) be a graph, given m groups each with μ1 legs, where leg of group i (0i<m, 1<μ) has start and end node pair (si,,ti,) and can use vertices from Ni,V (we have the property that end-node of leg is the same as start node of leg +1: ti,=si,+1), total budget for all the legs of group i is Bi. The goal is to find a collection of paths Qi,, for 0i<m, 1μ1, such that Qi, is a si,-ti, path (and so concatenation of all legs of group i gives a single path from start node of the first leg to the last node of leg μ1), such that =1μ1Qi,Bi and |i=0m1=1μ1(Qi,Ni,)| is maximized.

Note Puij,uij+1 (0i<m,1j<μ) is a feasible solution of the multiple groups-legs orienteering instance with groups 0i<m and legs 1j<μ, start and end node pairs (uij,uij+1), budgets Bi and subset Ni,j. Consider the instance restricted to group i alone an instance of multiple-leg P2P orienteering where we have to find a vivi+1-path that goes through all uij’s in order (so has μ1 legs) and has budget Bi; call this instance i. Note Pvivi+1 is a feasible solution to i, thus the optimal of i visits at least |Pvivi+1| many vertices in j=1μ1Ni,j. We consider all i’s concurrently, i.e. an instance with pairs of start-end nodes vivi+1 for group i where each group is also required to go through vertices of Ji in that order and thus has μ1 legs where each leg has start-end pair uij,uij+1, total budget Bi for all the legs of group i, and the subset Ni,jV, 0i<m, 1j<μ for leg j of group i. For a path Q, let QNi,j be the set of vertices Q visited in Ni,j. Using an argument similar to that of Theorem 13 we can show there is a (1+ϵ)-approximation i.e. a set of paths Qi,j such that Qi,j is a uij,uij+1-path and if we define concatenation of different legs of group i by Qi=Qi,1++Qi,μ1 then:

Qi=j=1μ1Qi,jPvivi+1εi,μand (6)
|i=0m1Qi|=|i=0m1j=1μ1(Qi,jNi,j)|(14ε)|P|. (7)

We also show that if v is visited by Qi,j then if Qi,j(uij,v) denotes the segment of path Qi,j from uij to v, then the length of the segment from vi to v in Qi can be upper bounded:

Qi(vi,v)==1j1Qi,+Qi,j(uij,v)Ji(vi,uij)+(1ε)i,μ. (8)

We will prove the existence of such paths Qi,j with a structure in the next theorem and also how to find these using a DP. For now suppose we have found such paths Qi as described above. We concatenate all these paths to obtain the final answer 𝒬=Q0+Q1++Qm1. We show the vertices of 𝒬 are visited before their deadlines and hence we have an approximation for deadline TSP. Given the bounds given for the sizes of Qi’s in (6), the number of vertices visited overall (respecting their deadlines) is at least (14ε)|P|.

To see why the vertices in 𝒬 respect their deadlines consider an arbitrary node vQi. Note that each Qi contains the vertices in Ji (as those are the vertices that define μ1 legs of the i’th group). Suppose v is visited in Qi,j, i.e. between uij and uij+1. Therefore, the visit time of v in 𝒬, i.e. 𝒬sv is bounded by:

𝒬sv = =0i1Q+Qi(vi,v)
=0i1(Pvv+1ε,μ)+Ji(vi,uij)+(1ε)i,μusing (6) and (8)
= Li,j+(1ε)i,με=0i1,μD(v),

where the last inequality follows from the fact that i,μαi1 and ,μ>α so ε=0i1,με=0i1α=(αi1)i,μ.

So we need to show the existence of Qi as described and how to find them. The road to get these paths Qi is an extension of what we had for multi-path orienteering in the previous section and is obtained by a DP that computes multi-group-legs with multiple paths (i.e. instances i’s) concurrently. The proof of following theorem is an extension of that of Theorems 13 and 15.

Theorem 19 (multi-groups-legs multi-paths orienteering structure theorem).

Let G=(V,E) be a graph with constant doubling dimension κ, given sV and D(v) for all v as an instance of deadline TSP and P be an optimal solution. Let vi (0i<m), uij (0i<m, 1j<μ), Bi, and Ni,j as described above for μ=1ε+1. Consider a multi-groups-legs orienteering instance with groups 0i<m and legs 1j<μ, start and end node pairs (uij,uij+1), budgets Bi, and subset Ni,j. then we can construct a γ-split-tree (with γ=n3hδ) such that with probability at least 11n there exists a determining function Φ and a corresponding split-tree hierarchical decomposition T=Γ|Φ of G and a structured solution of the multi-groups-legs orienteering instance Qi,j, (0i<m, 1j<μ) such that if we define Qi=Qi,1++Qi,μ1 for each 0i<m, then:

  1. 1.

    |i=0m1j=1μ1(Qi,jNi,j)|(14ε)|i=0m1j=1μ1Puij,uij+1|=(14ε)|P|.

  2. 2.

    Qi=j=1μ1Qi,jBiεi,μ=Jμ(Pvi,vi+1)+(1ε),iμ and for any vertex visited by Qi, say v visited in Qi,j we have the length of the path from vi to v in Qi, denoted by Qi(vi,v), satisfies: Qi(vi,v)Jμ(Pvi,vi)+(1ε)i,μ.

  3. 3.

    For any cluster CT and a partition πΦ(C) of C defining its children in T, let RπΦ(C),RπΦ(C) are the set of bridge-edges and portal-edges of C cut by the partition, we have either:

    • |QiRπΦ(C)|2κlognϵ or

    • |QiRπΦ(C)|(16κδϵ)2κ.

Using a more complex DP and we can find a near optimum structured solution as guranteed by this Theorem. This DP tries to solve multi-groups-legs multi-paths orienteering simultaneously.

References

  • [1] Esther M. Arkin, Joseph S. B. Mitchell, and Giri Narasimhan. Resource-constrained geometric network optimization. In Ravi Janardan, editor, Proceedings of the Fourteenth Annual Symposium on Computational Geometry, Minneapolis, Minnesota, USA, June 7-10, 1998, pages 307–316. ACM, 1998. doi:10.1145/276884.276919.
  • [2] Sanjeev Arora. Polynomial time approximation schemes for euclidean traveling salesman and other geometric problems. J. ACM, 45(5):753–782, 1998. doi:10.1145/290179.290180.
  • [3] Sandip Banerjee, Yair Bartal, Lee-Ad Gottlieb, and Alon Hovav. Novel properties of hierarchical probabilistic partitions and their algorithmic applications. In 65th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2024, Chicago, IL, USA, October 27-30, 2024, pages 1724–1767. IEEE, 2024. doi:10.1109/FOCS61266.2024.00107.
  • [4] Nikhil Bansal, Avrim Blum, Shuchi Chawla, and Adam Meyerson. Approximation algorithms for deadline-tsp and vehicle routing with time-windows. In László Babai, editor, Proceedings of the 36th Annual ACM Symposium on Theory of Computing, Chicago, IL, USA, June 13-16, 2004, pages 166–174. ACM, 2004. doi:10.1145/1007352.1007385.
  • [5] Nikhil Bansal and Viswanath Nagarajan. On the adaptivity gap of stochastic orienteering. CoRR, abs/1311.3623, 2013. arXiv:1311.3623.
  • [6] Yair Bartal. Probabilistic approximations of metric spaces and its algorithmic applications. In 37th Annual Symposium on Foundations of Computer Science, FOCS ’96, Burlington, Vermont, USA, 14-16 October, 1996, pages 184–193. IEEE Computer Society, 1996. doi:10.1109/SFCS.1996.548477.
  • [7] Yair Bartal, Lee-Ad Gottlieb, and Robert Krauthgamer. The traveling salesman problem: Low-dimensionality implies a polynomial time approximation scheme. SIAM J. Comput., 45(4):1563–1581, 2016. doi:10.1137/130913328.
  • [8] MohammadHossein Bateni and Julia Chuzhoy. Approximation algorithms for the directed k-tour and k-stroll problems. Algorithmica, 65(3):545–561, 2013. doi:10.1007/S00453-011-9610-6.
  • [9] Avrim Blum, Shuchi Chawla, David R Karger, Terran Lane, Adam Meyerson, and Maria Minkoff. Approximation algorithms for orienteering and discounted-reward tsp. SIAM Journal on Computing, 37(2):653–670, 2007. doi:10.1137/050645464.
  • [10] Kevin Buchin, Mart Hagedoorn, Guangping Li, and Carolin Rehs. Orienteering (with time windows) on restricted graph classes. In International Conference on Current Trends in Theory and Practice of Computer Science, pages 151–165. Springer, 2025. doi:10.1007/978-3-031-82670-2_12.
  • [11] T.-H. Hubert Chan and Shaofeng H.-C. Jiang. Reducing curse of dimensionality: Improved PTAS for TSP (with neighborhoods) in doubling metrics. In Robert Krauthgamer, editor, Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2016, Arlington, VA, USA, January 10-12, 2016, pages 754–765. SIAM, 2016. doi:10.1137/1.9781611974331.CH54.
  • [12] Kamalika Chaudhuri, Brighten Godfrey, Satish Rao, and Kunal Talwar. Paths, trees, and minimum latency tours. In 44th Annual IEEE Symposium on Foundations of Computer Science, 2003. Proceedings., pages 36–45. IEEE, 2003. doi:10.1109/SFCS.2003.1238179.
  • [13] Chandra Chekuri, Nitish Korula, and Martin Pál. Improved algorithms for orienteering and related problems. ACM Transactions on Algorithms (TALG), 8(3):1–27, 2012. doi:10.1145/2229163.2229167.
  • [14] Chandra Chekuri and Amit Kumar. Maximum coverage problem with group budget constraints and applications. In International Workshop on Randomization and Approximation Techniques in Computer Science, pages 72–83. Springer, 2004. doi:10.1007/978-3-540-27821-4_7.
  • [15] Chandra Chekuri and Martin Pál. A recursive greedy algorithm for walks in directed graphs. In 46th Annual IEEE Symposium on Foundations of Computer Science (FOCS 2005), 23-25 October 2005, Pittsburgh, PA, USA, Proceedings, pages 245–253. IEEE Computer Society, 2005. doi:10.1109/SFCS.2005.9.
  • [16] Ke Chen and Sariel Har-Peled. The euclidean orienteering problem revisited. SIAM Journal on Computing, 38(1):385–397, 2008. doi:10.1137/060667839.
  • [17] Vincent Cohen-Addad. Bypassing the surface embedding: approximation schemes for network design in minor-free graphs. In Stefano Leonardi and Anupam Gupta, editors, STOC ’22: 54th Annual ACM SIGACT Symposium on Theory of Computing, Rome, Italy, June 20 - 24, 2022, pages 343–356. ACM, 2022. doi:10.1145/3519935.3520049.
  • [18] Boaz Farbstein and Asaf Levin. Deadline TSP. Theor. Comput. Sci., 771:83–92, 2019. doi:10.1016/J.TCS.2018.11.016.
  • [19] Zachary Friggstad and Chaitanya Swamy. Compact, provably-good lps for orienteering and regret-bounded vehicle routing. In Friedrich Eisenbrand and Jochen Könemann, editors, Integer Programming and Combinatorial Optimization - 19th International Conference, IPCO 2017, Waterloo, ON, Canada, June 26-28, 2017, Proceedings, volume 10328 of Lecture Notes in Computer Science, pages 199–211. Springer, 2017. doi:10.1007/978-3-319-59250-3_17.
  • [20] Zachary Friggstad and Chaitanya Swamy. A constant-factor approximation for directed latency in quasi-polynomial time. J. Comput. Syst. Sci., 126:44–58, 2022. doi:10.1016/J.JCSS.2021.12.001.
  • [21] Jie Gao, Su Jia, Joseph S. B. Mitchell, and Lu Zhao. Approximation algorithms for time-window TSP and prize collecting TSP problems. In Ken Goldberg, Pieter Abbeel, Kostas E. Bekris, and Lauren Miller, editors, Algorithmic Foundations of Robotics XII, Proceedings of the Twelfth Workshop on the Algorithmic Foundations of Robotics, WAFR 2016, San Francisco, California, USA, December 18-20, 2016, volume 13 of Springer Proceedings in Advanced Robotics, pages 560–575. Springer, 2016. doi:10.1007/978-3-030-43089-4_36.
  • [22] Naveen Garg, Sanjeev Khanna, and Amit Kumar. Hardness of approximation for orienteering with multiple time windows. In Dániel Marx, editor, Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms, SODA 2021, Virtual Conference, January 10 - 13, 2021, pages 2977–2990. SIAM, 2021. doi:10.1137/1.9781611976465.177.
  • [23] Lee-Ad Gottlieb, Robert Krauthgamer, and Havana Rika. Faster algorithms for orienteering and k-tsp. Theor. Comput. Sci., 914:73–83, 2022. doi:10.1016/J.TCS.2022.02.013.
  • [24] Anupam Gupta, Robert Krauthgamer, and James R Lee. Bounded geometries, fractals, and low-distortion embeddings. In 44th Annual IEEE Symposium on Foundations of Computer Science, 2003. Proceedings., pages 534–543. IEEE, 2003. doi:10.1109/SFCS.2003.1238226.
  • [25] Anupam Gupta, Ravishankar Krishnaswamy, Viswanath Nagarajan, and R. Ravi. Running errands in time: Approximation algorithms for stochastic orienteering. Math. Oper. Res., 40(1):56–79, 2015. doi:10.1287/MOOR.2014.0656.
  • [26] Aditya Jayaprakash and Mohammad R. Salavatipour. Approximation schemes for capacitated vehicle routing on graphs of bounded treewidth, bounded doubling, or highway dimension. ACM Trans. Algorithms, 19(2):20:1–20:36, 2023. doi:10.1145/3582500.
  • [27] Haotian Jiang, Jian Li, Daogao Liu, and Sahil Singla. Algorithms and adaptivity gaps for stochastic k-tsp. In Thomas Vidick, editor, 11th Innovations in Theoretical Computer Science Conference, ITCS 2020, January 12-14, 2020, Seattle, Washington, USA, volume 151 of LIPIcs, pages 45:1–45:25. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPICS.ITCS.2020.45.
  • [28] Philip N. Klein. A linear-time approximation scheme for TSP in undirected planar graphs with edge-weights. SIAM J. Comput., 37(6):1926–1952, 2008. doi:10.1137/060649562.
  • [29] Joseph SB Mitchell. Guillotine subdivisions approximate polygonal subdivisions: A simple polynomial-time approximation scheme for geometric tsp, k-mst, and related problems. SIAM Journal on computing, 28(4):1298–1309, 1999. doi:10.1137/S0097539796309764.
  • [30] Viswanath Nagarajan and R. Ravi. The directed orienteering problem. Algorithmica, 60(4):1017–1030, 2011. doi:10.1007/S00453-011-9509-2.
  • [31] Kinter Ren and Mohammad R. Salavatipour. Approximation schemes for orienteering and deadline tsp in doubling metrics, 2024. doi:10.48550/arXiv.2405.00818.
  • [32] Kunal Talwar. Bypassing the embedding: algorithms for low dimensional metrics. In László Babai, editor, Proceedings of the 36th Annual ACM Symposium on Theory of Computing, Chicago, IL, USA, June 13-16, 2004, pages 281–290. ACM, 2004. doi:10.1145/1007352.1007399.
  • [33] Kunal Talwar. Bypassing the embedding: algorithms for low dimensional metrics. In Proc. of 36th ACM Symp. on Theory of Computing (STOC), 2004. doi:10.1145/1007352.1007399.