On the Approximability of Time Disjoint Walks

TL;DR

This paper introduces the Time Disjoint Walks problem for collision-free routing, analyzes its complexity on various DAG subclasses, and provides approximation algorithms with proven bounds.

Contribution

It establishes complexity boundaries for TDW on specific DAG subclasses and offers a tight approximation algorithm for bounded-degree DAGs.

Findings

Poly-time algorithm for min-sum and min-max TDW on oriented stars.

NP-hardness of min-sum TDW on oriented stars with a path.

Approximation ratio of Θ(k/ log k) for bounded-degree DAGs.

Abstract

We introduce the combinatorial optimization problem Time Disjoint Walks (TDW), which has applications in collision-free routing of discrete objects (e.g., autonomous vehicles) over a network. This problem takes as input a digraph $G$ with positive integer arc lengths, and $k$ pairs of vertices that each represent a trip demand from a source to a destination. The goal is to find a walk and delay for each demand so that no two trips occupy the same vertex at the same time, and so that a min-max or min-sum objective over the trip durations is realized. We focus here on the min-sum variant of Time Disjoint Walks, although most of our results carry over to the min-max case. We restrict our study to various subclasses of DAGs, and observe that there is a sharp complexity boundary between Time Disjoint Walks on oriented stars and on oriented stars with the central vertex replaced by a path. In particular, we present a poly-time algorithm for min-sum and min-max TDW on the former, but show that min-sum TDW on the latter is NP-hard. Our main hardness result is that for DAGs with max degree $\Delta\leq3$, min-sum Time Disjoint Walks is APX-hard. We present a natural approximation algorithm for the same class, and provide a tight analysis. In particular, we prove that it achieves an approximation ratio of $\Theta(k/\log k)$ on bounded-degree DAGs, and $\Theta(k)$ on DAGs and bounded-degree digraphs.

Equations

$$\lambda (W,j):=\sum _{i\in [j-1]}\lambda (w_i,w_{i+1}).$$

$$d_1+\lambda (W_1,j_1)\ne d_2+\lambda (W_2,j_2).$$

$$OP{T}_{\mathcal{Q}}(f(x))\le \alpha \cdot OP{T}_{\mathcal{P}}(x).$$

$$\big{|}OPT_{\mathcal{P}}(x)-c_{\mathcal{P}}(x,g(x,y))\big{|}\leq\beta\cdot\big{|}OPT_{\mathcal{Q}}(f(x))-c_{\mathcal{Q}}(f(x),y)\big{|}.$$

$$V_{C_j}$$

$$E_{C_j}$$

$$\mathcal{T}:=\{(x_i^s,x_i^t)\mid i\in [n]\}\cup \{(c_j^s,c_j^t)\mid j\in [m]\}$$

$$\lambda (u,v):=\{\begin{array}{ll}1,& \text{if }(u,v)=(l_j^a,l_j^{a^{\prime }}),j\in [m],a\in [2];\text{ or}\\ & \text{if }(u,v)=(x_i^s,l_j^a),i\in [n],j\in [m],a\in [2];\text{ or}\\ & \text{if }(u,v)=(l_h^{a^{\prime }},l_j^b),h,j\in [m],a,b\in [2];\\ 7,& \text{if }(u,v)=(x_i^s,x_i^t),i\in [n]\\ 7-2|S_l|,& \text{if }(u,v)=(l_j^{a^{\prime }},x_i^t),j\in [m],a\in [2],i\in [n],l_j^a=l\\ 2{\pi }_l(l_j^a)-1,& \text{if }(u,v)=(c_j^s,l_j^a),j\in [m],a\in [2],l_j^a=l\\ 7-1-\lambda (c_j^s,l_j^a),& \text{if }(u,v)=(l_j^{a^{\prime }},c_j^t),j\in [m],a\in [2]\end{array}$$

$$OP{T}_{\mathcal{Q}}(f(\varphi ))\le 7(n+m)+(m-OP{T}_{\mathcal{P}}(\varphi ))\le 22m-OP{T}_{\mathcal{P}}(\varphi ).$$

$$OP{T}_{\mathcal{Q}}(f(\varphi ))\le 22\cdot (4/3)\cdot OP{T}_{\mathcal{P}}(\varphi )-OP{T}_{\mathcal{P}}(\varphi )\le 29\cdot OP{T}_{\mathcal{P}}(\varphi ).$$

$$c_{\mathcal{P}}(\varphi ,g(\varphi ,y)):=c_{\mathcal{P}}(\varphi ,q(\varphi ,z(y)))\ge \gamma .$$

$$7(n+m)+(m-\gamma )\le c_{\mathcal{Q}}(f(\varphi ),z(y))\le c_{\mathcal{Q}}(f(\varphi ),y).$$

$$c_{\mathcal{P}}(\varphi ,g(\varphi ,y))\ge \gamma \ge 7n+8m-c_{\mathcal{Q}}(f(\varphi ),y).$$

$$OP{T}_{\mathcal{P}}(\varphi )-c_{\mathcal{P}}(\varphi ,g(\varphi ,y))$$

$$\displaystyle=\beta\cdot\big{(}c_{\mathcal{Q}}(f(\phi),y)-OPT_{\mathcal{Q}}(f(\phi))\big{)},$$

$$d_i\le 2\sum _{h\in [i-1]}\lambda (W_h).$$

$$d_i\le$$

$$\le$$

$$\rho \le \frac{c_{TDW}(x,\mathcal{A}(x))}{OP{T}_{TDW}(x)}$$

$$\le 1+\frac{2k{\sum }_{i\in [k]}\lambda (W_i)}{{\sum }_{i\in [k]}\lambda (W_i)}=O(k).$$

$$\rho \le \frac{c_{TDW}(x,\mathcal{A}(x))}{OP{T}_{TDW}(x)}$$

$$\displaystyle\leq 1+\frac{d_{i^{\ast}}}{\lambda(W_{i^{\ast}})},i^{\ast}:=\operatorname*{\arg\!\max}_{i\in[k]}\bigg{(}\frac{d_{i}}{\lambda(W_{i})}\bigg{)}$$

$$\le 1+O(1)\cdot \frac{d_{i^{\ast }}}{\log d_{i^{\ast }}}$$

$$\le 1+O(1)\cdot \frac{k}{\log k}=O(k/\log k).$$

$$d_i\le |{bad\_delays}_i|\le |\{h\in [i-1]\mid W_h\cap W_i\ne \varnothing \}|=:{\mu }_i$$

$${\delta }_u+\lambda (W_i,u)$$

$${\delta }_v+\lambda (W_i,v)$$

$$\lambda (W_h,u)-\lambda (W_h,v)$$

$${\mu }_i\le \min ({\Delta }^{4\lambda (W_i)},k).$$

$${\mu }_i\le (\lambda (W_i)+1){\Delta }^{\lambda (W_i)+1}\le {\Delta }^{2(\lambda (W_i)+1)}\le {\Delta }^{4\lambda (W_i)},$$

$${\lambda }_k(W_i,c_z)=\{\begin{array}{ll}l+z,& \text{if }i\in I_A\\ l+2\hat{k}-z-2\cdot (z\mathrm{mod}2),& \text{if }i\in I_B\end{array}$$

$${bad\_delays}_{i,h}=\{\begin{array}{ll}\{d_h\},& \text{if }i,h\in I_A\text{ or}\\ & \text{if }i,h\in I_B\\ \{d_h-2\hat{k}+2z+2\cdot (z\mathrm{mod}2)\mid z\in [\hat{k}]\},& \text{if }i\in I_B,h\in I_A\\ \{d_h+2\hat{k}-2z-2\cdot (z\mathrm{mod}2)\mid z\in [\hat{k}]\},& \text{if }i\in I_A,h\in I_B\end{array}$$

$$d_i=i-1+\lfloor \frac{i-1}{8}\rfloor (2\hat{k}-4).$$

Full text

We focus here on the min-sum variant of Time Disjoint Walks, although most of our results carry over to the min-max case. We restrict our study to various subclasses of DAGs, and observe that there is a sharp complexity boundary between Time Disjoint Walks on oriented stars and on oriented stars with the central vertex replaced by a path. In particular, we present a poly-time algorithm for min-sum and min-max TDW on the former, but show that min-sum TDW on the latter is NP-hard.

Our main hardness result is that for DAGs with max degree $\Delta\leq 3$, min-sum Time Disjoint Walks is APX-hard. We present a natural approximation algorithm for the same class, and provide a tight analysis. In particular, we prove that it achieves an approximation ratio of $\Theta(k/\log k)$ on bounded-degree DAGs, and $\Theta(k)$ on DAGs and bounded-degree digraphs.

1 Introduction

1.1 Related work

Disjoint Paths is a classic problem in combinatorial optimization that asks: given an undirected graph $G$, and $k$ pairs of vertices, do there exist vertex-disjoint paths that connect each pair? This problem captures the general notion of connection without interference, and has subsequently received much attention due to its applicability in areas like VLSI design [KLPS90, Len90] and communication networks [Tor92, SM03].

These applications have motivated many variants of this basic problem. For example, one may choose the underlying graph to be undirected or directed, and the disjointness constraint to be over vertices or edges. As an optimization problem, one may consider the maximum number of pairs that can be connected with disjoint paths, the minimum number of rounds necessary to connect all pairs (where all paths in a round must be disjoint) [Kle96], or the shortest set of disjoint paths to connect all pairs (if all pairs can, in fact, be disjointly connected) [KS10].

A few flavors of Disjoint Paths are tractable: for example, if $k$ is fixed or $G$ has bounded tree-width, then there exists a poly-time algorithm for finding vertex-disjoint paths on undirected graphs [Sch94, RS95]. Many interesting variants of Disjoint Paths are, however, extremely difficult. Indeed, finding vertex-disjoint paths on undirected graphs is one of Karp’s NP-complete problems [Kar75]. Furthermore, nearly-tight hardness results are known for finding the maximum set of edge-disjoint paths in a directed graph with $m$ edges: there exists an $O(\sqrt{m})$-approximation algorithm [Kle96], and it is NP-hard to approximate within a factor of $m^{1/2-\epsilon}$, for any $\epsilon>0$ [GKR*+*03]. For detailed surveys on the complexity landscape of Disjoint Paths variants, see [Kle96, KS10].

1.2 Contributions

Despite the great variety of Disjoint Paths problems that have been considered in the literature, it appears that little attention has been given to variants that relax the disjointness constraint, even though many natural applications do not always require paths to be completely disjoint. Consider, for example, the application of safely routing a collection of fully autonomous (and obedient) vehicles through an otherwise empty road network. In such a situation, we can certainly prevent collisions by routing all vehicles on disjoint paths. However, it is not difficult to see that if we have full control over the vehicles, using disjoint paths is rarely necessary (and, in fact, can be highly suboptimal).

Applications of this flavor motivate a new variant of Disjoint Paths, which roughly asks: given a graph $G$ and $k$ pairs of vertices that each represent a trip demand, how should we assign a delay and a path to each trip so that (1) trips are completed as quickly as possible, and (2) no two trips collide (i.e., occupy the same location at the same time). While there are problems in the literature (that do not wield the name “Disjoint Paths”) that seemingly come close to capturing this goal, they exhibit some key differences. In particular, multicommodity flows over time [Sku09, GS12] and job shop scheduling [Gra66] seem, at first glance, very related to our problem. However, the former does not support “atomic” commodities (i.e., whose demand-satisfying flow must be unsplittable over the network and time), and the latter does not capture the flexibility of scheduling job operations over any appropriate walk in a network.

As such, we are motivated to formalize and study this new variant of Disjoint Paths that relaxes the classical disjointness constraint to a “time disjointness” constraint. In particular, our contributions are fourfold:

• •

We introduce a natural variant of Disjoint Paths, which we call Time Disjoint Walks (TDW). To the best of our knowledge, this is the first simple model that captures the notion of collision-free routing of discrete objects over a shared network.

• •

We give an intuitive sense for precisely when Time Disjoint Walks becomes hard, by showing that it can be exactly solved (under min-sum and min-max objectives) in poly-time on oriented stars, but is NP-hard (under the min-sum objective) on a slightly more expressive class.

• •

We prove that min-sum Time Disjoint Walks is APX-hard, by providing an L-reduction from a variant of SAT. In fact, our reduction shows that this result holds even for directed acyclic graphs (DAGs) of max degree three ($\Delta\leq 3$).

• •

We describe an intuitive approximation algorithm for min-sum Time Disjoint Walks, and provide a tight analysis: we show that it achieves an approximation ratio of $\Theta(k/\log k)$ on bounded-degree DAGs, and $\Theta(k)$ on DAGs and bounded-degree digraphs.

We formally introduce Time Disjoint Walks in Section 2. In Section 3, we present an exact poly-time algorithm for TDW on oriented stars, and show that min-sum TDW is NP-hard on a slightly more complex class. In Section 4 we provide some useful definitions regarding approximation. In Section 5 we prove our APX-hardness result. In Section 6 we describe our approximation algorithm, and provide bounds on its performance. In Section 7 we state our conclusions and present some open problems. A preliminary version of this paper appeared in [BGV18].

2 Time Disjoint Walks

We must first mention a few preliminaries: given $a,b\in\mathbb{Z}$, define $[a,b]:=\{x\in\mathbb{Z}\mid a\leq x\leq b\}$, and for $b\in\mathbb{Z}$, we write $[b]:=[1,b]$. Note that for $b<1$, $[b]=\emptyset$. We assume directed graphs (digraphs) have no parallel arcs in the same direction, and for a digraph $G$, we let $\Delta$ denote its max total degree (indegree and outdegree contribute to a vertex’s total degree). Given a digraph $G:=(V,E)$, and $u,v\in V$, we define a walk $W$ from $u$ to $v$ in $G$ as a tuple $(w_{1},w_{2},\dots,w_{l})$ of vertices such that $w_{1}=u,w_{l}=v$, and $(w_{i},w_{i+1})\in E$ for each $i\in[l-1]$. Note that a vertex may be repeated. Given a digraph $G$ with arc lengths $\lambda:E\rightarrow\mathbb{Z}_{\geq 1}$, and a walk $W=(w_{1},w_{2},\dots,w_{l})$ in $G$, we let $|W|:=l$ denote the cardinality of the walk, and we define for every $j\in[l]$ the length of the walk up to its $j^{th}$ vertex as

[TABLE]

For convenience, we let $\lambda(W):=\lambda(W,l)$ denote the total length of the walk, and if $W$ is a path (i.e., no repeated vertices), we use $\lambda(W,j)$ and $\lambda(W,w_{j})$ interchangeably.

Finally, given delays $d_{1},d_{2}\in\mathbb{Z}_{\geq 0}$ and walks $W_{1},W_{2}$ in $G$, we say that $(d_{1},W_{1})$ and $(d_{2},W_{2})$ are time disjoint if, intuitively, a small object traversing $W_{1}$ at constant speed after waiting $d_{1}$ units of time does not collide/interfere with a small object traversing $W_{2}$ at the same speed after waiting $d_{2}$ units of time. We consider walks that have not departed, and walks that have already ended, to no longer exist on the network (and thereby not occupy any vertices). Formally, we have: for every $j_{1}\in[|W_{1}|],j_{2}\in[|W_{2}|]$ such that the $j_{1}^{\text{th}}$ vertex of $W_{1}$ is equal to the $j_{2}^{\text{th}}$ vertex of $W_{2}$,

[TABLE]

We are now ready to formally define the problem examined in this paper:

Definition 1** (Time Disjoint Walks (TDW)).**

Let $G:=(V,E)$ be a digraph, let $\lambda:E\rightarrow\mathbb{Z}_{\geq 1}$ define arc lengths, and let $\mathcal{T}:=\{(s_{1},t_{1}),(s_{2},t_{2}),\dots,(s_{k},t_{k})\}\subseteq V^{2}$ define a set of demands across unique vertices. For each $i\in[k]$, find a delay $d_{i}\in\mathbb{Z}_{\geq 0}$ and walk $W_{i}$ from $s_{i}$ to $t_{i}$ such that the tuples in $\{(d_{i},W_{i})\mid i\in[k]\}$ are pairwise time disjoint, and such that $\sum_{i\in[k]}(d_{i}+\lambda(W_{i}))$ or $\max_{i\in[k]}(d_{i}+\lambda(W_{i}))$ is minimized.111We assume $G$ contains, for each $(s_{i},t_{i})$, at least one walk connecting the two vertices. We refer to the former as min-sum Time Disjoint Walks, and the latter as min-max Time Disjoint Walks.

We note that one can construct analogous problems by considering undirected graphs as input, edge lengths and delays that are real-valued, or a definition of time disjoint that requires large gaps between arrival times at common vertices (whereas the definition above simply requires a nonzero gap). We leave these variants to future work, noting that our primary goal in this paper is to study a basic flavor of this new combinatorial problem.

Furthermore, our selection of this variant is well-motivated by our original application of routing a collection of identical autonomous vehicles over an empty road network (which, for the sake of this futuristic application, we may assume was built specifically for these vehicles). In particular, we may (1) model the road network as a directed graph, (2) assume that all routed vehicles traverse their walk at the same constant velocity, (3) measure road lengths as the time necessary to traverse it at that velocity, and (4) assume that road lengths are integer multiples of the time length of each vehicle. Additionally, we may motivate our focus on the min-sum objective by the desire to find a socially optimal solution.

Finally, we emphasize the novelty of our time disjoint constraint by comparing it to the standard disjoint constraint used in classical variants of Disjoint Paths. In particular, observe that if we modify the definition of Time Disjoint Walks to use the latter constraint instead of the former, we arrive at the Shortest Disjoint Paths problem [KS10]. However, this constraint makes all the difference: given an instance of Time Disjoint Walks, it is often the case that a solution under the standard disjoint constraint is suboptimal if examined under the time disjoint constraint. Indeed, the optimal solution under the latter constraint may even include paths that repeat vertices - hence the name Time Disjoint Walks; see Figure 1, part (i). On the other hand, it is easy to construct an instance of Shortest Disjoint Paths that admits an obvious optimal solution under the time disjoint constraint, but does not yield any solution at all under the classical disjoint constraint; see Figure 1, part (ii).

These observations strongly suggest that there is no simple reduction, in either direction, between Time Disjoint Walks and Disjoint Paths. Furthermore, using time-expanded networks [Sku09] to reduce Time Disjoint Walks into Disjoint Paths appears to offer little hope: such reductions will approximately square the size of the original graph, and many variants of Disjoint Paths are hard to approximate within $m^{1/2-\epsilon}$, for any $\epsilon>0$ [GKR*+*03]. Thus, an approximation algorithm for Disjoint Paths, applied to a transformed Time Disjoint Walks instance, would likely fail to perform better than a trivial approximation algorithm for Time Disjoint Walks. These observations highlight the novelty of our problem and results.

3 A complexity boundary

In order to get an idea of the difficulty of Time Disjoint Walks, we show that min-sum TDW exhibits a sharp complexity boundary, in the sense that it is poly-time solvable on one subclass of DAGs, but becomes NP-hard if we make this class slightly more expressive. In particular, we consider the following two subclasses of DAGs:

Definition 2** (Oriented stars).**

A digraph $G$ is an oriented star if it is composed of a central vertex with any number of leaves attached by directed edges.

Equivalently, an oriented star on $n$ vertices is simply the complete bipartite graph $K_{1,n-1}$ with some orientation applied to the edges.

Definition 3** (Runways).**

A digraph $G$ is a runway if it is composed of a central directed path with any number of leaves attached (anywhere along the path) by directed edges.

One may think of a runway as an oriented star with the central vertex replaced by a directed path, or as a caterpillar graph with an orientation applied to the edges so as to produce a central directed path.

3.1 Time Disjoint Walks on oriented stars in polynomial time

We present poly-time Algorithm 1 for Time Disjoint Walks on oriented stars, and show that it in fact optimally solves both min-sum and min-max TDW. The main idea in this algorithm and its analysis is that each trip $i\in[k]$ is allocated a unique time slot during which it is “allowed” to utilize the central vertex of the oriented star (i.e., the only vertex it will share with other paths). We often toggle between reasoning about the delay assigned to a trip and the time slot (on the central vertex) assigned to a trip - note that these two notions are essentially equivalent, and that it only makes sense to assign a time slot to a trip $i$ if the time slot has value at least equal to the length of the first segment of trip $i$ (i.e., from the source to the central vertex).

It may help to visualize this algorithm as taking a histogram over $\mathbb{Z}_{\geq 0}$ of arrival times of each trip at the central vertex (under 0 delay), and drawing an arrow from each element (trip) of this histogram forward (i.e., to a number that is no smaller) to a distinct slot (element of $\mathbb{Z}_{\geq 0}$) during which that trip will pass through the central vertex. The length of this arrow is the delay assigned to that trip.

Note that for brevity, we have excluded from Algorithm 1 the pseudocode to check that $G$ is indeed an oriented star with central vertex $\mathsf{central\_vertex}(G)$, and the pseudocode to handle the case where some $s_{i}$ or $t_{i}$ is the central vertex (for such an $i$, $W_{i}$ should instead be set to $(s_{i},t_{i})$, and one of $a_{i},b_{i}$ should be set to 0, according to whether $s_{i}$ or $t_{i}$ is the central vertex). Also, we allow ties encountered when setting $i^{\ast}$ to be broken arbitrarily.222In our analyses that follow, we also assume all ties are broken arbitrarily. It is clear that the algorithm runs in polynomial time, and that its output is always feasible: $i^{\ast}$ is always defined (due to $\mathsf{min\_useful\_slot}$), all delays are nonnegative (by definition of $i^{\ast}$), and collisions - which can only occur at the central vertex - are avoided (due to $\mathsf{occupied\_slots}$). We now prove that Algorithm 1 optimally solves both min-sum and min-max TDW on oriented stars.

Theorem 1**.**

Algorithm 1* is an exact poly-time algorithm for min-sum Time Disjoint Walks on oriented stars.*

Proof.

Let $(G,\lambda,\mathcal{T})$ be a TDW instance, where $G$ is an oriented star with central vertex $x$. Let $(d_{1},W_{1}),\ldots,(d_{k},W_{k})$ be the solution outputted by Algorithm 1, and let $(d_{1}^{\ast},W_{1}^{\ast}),\ldots,(d_{k}^{\ast},W_{k}^{\ast})$ be an optimal solution under the min-sum objective. For each $i\in[k]$, define $a_{i}=a_{i}^{\ast}=\lambda(W_{i},x)$, $b_{i}=b_{i}^{\ast}=\lambda(W_{i})-\lambda(W_{i},x)$, and $y_{i}:=d_{i}+a_{i},y_{i}^{\ast}:=d_{i}^{\ast}+a_{i}^{\ast}$. Let $S:=\{y_{i}\mid i\in[k]\}$ denote the time slots during which the central vertex is busy under our algorithm’s solution, and let $S^{\ast}:=\{y_{i}^{\ast}\mid i\in[k]\}$ denote the same notion under a min-sum optimal solution. By the time-disjointness constraint of TDW, we know that $|S|=|S^{\ast}|=k$. Recall that the min-sum objective sums delays and walk lengths over all trips, and that a unique walk satisfies each demand in an oriented star. Using these, we know that our solution will have the same min-sum cost as the optimal min-sum cost if $S=S^{\ast}$.

Assume for contradiction that $S\neq S^{\ast}$. Let $\beta$ be the smallest element in the symmetric difference of $S$ and $S^{\ast}$. If $\beta\in S\setminus S^{\ast}$, then define $T:=\{i\in[k]\mid y_{i}\leq\beta\}$ to contain the trips that our algorithm schedules on a slot no later than $\beta$. Now, note that there must exist some $i\in T$ such that $y_{i}^{\ast}>\beta$, since $\beta$ is the smallest element at which $S,S^{\ast}$ differ, and $i\neq j\in T\implies y_{i}^{\ast}\neq y_{j}^{\ast}$, by the time-disjointness constraint of TDW. But this means that we can reset $d_{i}^{\ast}$ to $\beta-a_{i}^{\ast}=\beta-a_{i}$ (which is guaranteed to be nonnegative, by our algorithm description) and obtain a valid solution to this TDW instance that costs less than the optimal, which is a contradiction.

If $\beta\in S^{\ast}\setminus S$, then by almost identical reasoning as above, we know that if we define $T^{\ast}:=\{i\in[k]\mid y_{i}^{\ast}\leq\beta\}$, then there must exist some $i\in T^{\ast}$ such that $y_{i}>\beta$ and $\beta-a_{i}$ is nonnegative. But this would mean that during the iteration of the main while loop at which $i$ gets assigned a delay, $\beta\geq\mathsf{min\_useful\_slot}$ and $\beta\notin\mathsf{occupied\_slots}$ and $\beta<y_{i}$, yet $\mathsf{slot}$ is set to $y_{i}$, which contradicts the definition of the min function (in our algorithm description). This completes the proof. ∎

Theorem 2**.**

Algorithm 1* is an exact poly-time algorithm for min-max Time Disjoint Walks on oriented stars.*

Proof.

First, define the same variables as in the proof to Theorem 1, replacing the words “min-sum” with “min-max” as necessary. Our goal here will be to find a sequence of consecutive slots $Q:=[q_{\text{start}},q_{\text{end}}]\subseteq\mathbb{Z}_{\geq 0}$ with the following properties:

• •

$Q\subseteq S$.

• •

If we define $I_{Q}:=\{i\in[k]\mid d_{i}+a_{i}\in Q\}$, then $A_{Q}:=\{a_{i}\mid i\in I_{Q}\}\subseteq Q$.

• •

If we define $\gamma\in I_{Q}$ such that $d_{\gamma}+a_{\gamma}=q_{\text{end}}$, then $d_{\gamma}+a_{\gamma}+b_{\gamma}\geq d_{j}+a_{j}+b_{j}$, for all $j\in[k]$.

• •

For all $j\in I_{Q}$, we have $b_{j}\geq b_{\gamma}$.

Given such a $Q$, the first two properties ensure $|I_{Q}|=|Q|$ and that these $|Q|$ trips (indexed by $I_{Q}$), under 0 delay, would arrive at the central vertex at some time in $Q$. Thus, the min-max optimal solution (and, in general, any feasible solution) to the TDW instance must set, for some $h\in I_{Q}$, $d_{h}^{\ast}+a_{h}^{\ast}\geq q_{\text{end}}$ (otherwise, because delays are nonnegative, the pigeonhole principle shows that the optimal solution schedules two trips in $I_{Q}$ to share a slot in $Q$). The third and fourth property ensure that for this same $h\in I_{Q}$, $b_{h}^{\ast}=b_{h}\geq b_{\gamma}$ and thus $d_{h}^{\ast}+a_{h}^{\ast}+b_{h}^{\ast}\geq q_{\text{end}}+b_{\gamma}=d_{\gamma}+a_{\gamma}+b_{\gamma}\geq d_{j}+a_{j}+b_{j}$, for all $j\in[k]$. This shows that the max trip time in any solution to the TDW instance is at least the max trip time on the solution produced by our algorithm, proving that our algorithm is optimal under the min-max constraint. We construct such a $Q$, below.

First, define $\gamma:=\operatorname*{\arg\!\max}_{i\in[k]}(d_{i}+a_{i}+b_{i})$, and set $q_{\text{end}}:=d_{\gamma}+a_{\gamma}$. Define $\mathsf{anchor}:=\gamma,\mathsf{curr\_slot}:=q_{\text{end}}$, and repeat the following while $a_{\mathsf{anchor}}\neq\mathsf{curr\_slot}$: decrement $\mathsf{curr\_slot}$, let $\alpha\in[k]$ be the index such that $d_{\alpha}+a_{\alpha}=\mathsf{curr\_slot}$, and reset $\mathsf{anchor}$ to $\operatorname*{\arg\!\min}_{i\in\{\mathsf{anchor},\alpha\}}(a_{i})$. Finally, after quitting the loop, set $q_{\text{start}}:=a_{\mathsf{anchor}}$, and set $Q:=[q_{\text{start}},q_{\text{end}}]$.

We must argue that the above process is well-defined (in particular, that $\alpha$ is always defined and that the process terminates) and that $Q$ has all the properties we desire. To see the former, note that if we reach some $\mathsf{curr\_slot}$ such that there is no $\alpha\in[k]$ with $d_{\alpha}+a_{\alpha}=\mathsf{curr\_slot}$, then the description of Algorithm 1 is contradicted, because when this algorithm is picking a delay for trip $\mathsf{anchor}$, the above analysis suggests that it picks a delay larger than $\mathsf{curr\_slot}-a_{\mathsf{anchor}}$, even though $\mathsf{curr\_slot}\geq\mathsf{min\_useful\_slot}$ and $\mathsf{curr\_slot}\notin\mathsf{occupied\_slots}$. Thus, $\alpha$ is always defined, and so each iteration of the loop is well defined. Because $k$ is finite, the process must end.

Now, note that the well-definedness of $\alpha$ and the stopping condition of the loop also shows that $Q:=[q_{\text{start}},q_{\text{end}}]\subseteq S$. Next, $A_{Q}\subseteq Q$ by the setting of $\mathsf{anchor}$ and $q_{\text{start}}$. The third desirable property of $Q$ trivially holds by selection of $\gamma$. All that remains is to show that for all $j\in I_{Q}$, $b_{j}\geq b_{\gamma}$. To see this, consider any $j\in I_{Q}\setminus\{\gamma\}$ and the value of $\mathsf{anchor}$ during the $Q$-creation process right after $\alpha$ is set to $j$ (i.e., before $\mathsf{anchor}$ is potentially reset). Observe that $d_{j}+a_{j}<d_{\mathsf{anchor}}+a_{\mathsf{anchor}}$ and that $a_{j},a_{\mathsf{anchor}}\leq d_{j}+a_{j}$ by the while loop condition. Thus, by description of Algorithm 1, we must have that $b_{\mathsf{anchor}}\leq b_{j}$, for otherwise our algorithm would have preferred to set $d_{\mathsf{anchor}}$ to $d_{j}+a_{j}-a_{\mathsf{anchor}}$. Since $\mathsf{anchor}$ is initialized to $\gamma$, we have we have $b_{\gamma}\leq b_{j}$, $\forall j\in I_{Q}$. ∎

3.2 Min-sum Time Disjoint Walks on runways is NP-hard

We will reduce from min-sum coloring on interval graphs. We define this problem and state its NP-hardness,333Whenever we refer to an optimization problem as NP-hard, we mean the natural corresponding decision problem. below.

Definition 4** (Min-sum coloring).**

Given an undirected graph $G$, find a coloring $c:V(G)\to\mathbb{Z}_{\geq 1}$ such that adjacent vertices get different colors and $\sum_{v\in V}c(v)$ is minimized.

Definition 5** (Interval graphs).**

An undirected graph $G:=(V,E)$ such that each $v\in V$ may be identified with an interval $S_{v}:=[v_{\text{start}},v_{\text{end}}]\subseteq\mathbb{R}$ such that $xy\in E\iff S_{x}\cap S_{y}\neq\emptyset$.

Theorem 3** ([Szk99, Mar05]).**

Min-sum coloring of interval graphs is NP-hard, even for intervals taken over $\mathbb{Z}$.

We are now ready to prove our result.

Theorem 4**.**

Min-sum Time Disjoint Walks on runways is NP-hard.

Proof.

Given an interval graph $G$ and a parameter $q$ (for which we ask whether there is a coloring of $G$ whose sum adds up to at most $q$), we efficiently construct a TDW instance $(G^{\prime},\lambda,\mathcal{T})$ and parameter $q^{\prime}$ such that $G$ admits a solution of (sum-)cost at most $q$ if and only if $(G^{\prime},\lambda,\mathcal{T})$ admits a solution of (sum-)cost at most $q^{\prime}$.

Given an interval graph $G$ and parameter $q$, let $\{S_{v}:=[v_{\text{start}},v_{\text{end}}]\subseteq\mathbb{Z}\mid v\in V\}$ denote its interval representation, let $P=\bigcup_{v\in V}\{v_{\text{start}},v_{\text{end}}\}$ denote all the interval endpoints, and construct a bijection $\pi:P\to[|P|]$ that orders the endpoints such that $p_{1}\leq p_{2}\in P\implies\pi(p_{1})\leq\pi(p_{2})$. Clearly, we may equivalently represent $G$ as the intervals $\{S^{\prime}_{v}:=[\pi(v_{\text{start}}),\pi(v_{\text{end}})]\subseteq\mathbb{Z}_{\geq 1}\mid v\in V\}$.

Now, construct a runway digraph $G^{\prime}$ with arc lengths $\lambda:E(G^{\prime})\to\mathbb{Z}_{\geq 1}$ as follows: add to $V(G^{\prime})$ the vertices $x_{1},x_{2},\ldots,x_{|P|}$; turn these vertices into a directed path from $x_{1}$ to $x_{|P|}$ by adding the appropriate arcs to $E(G^{\prime})$; and let $\lambda$ assign a length of 1 to each such arc. Then, for each $v\in V(G)$: add to $V(G^{\prime})$ two distinct nodes $v_{L},v_{R}$; add to $E(G^{\prime})$ two distinct arcs $(v_{L},x_{\pi(v_{\text{start}})})$ and $(x_{\pi(v_{\text{end}})},v_{R})$; and set $\lambda(v_{L},x_{\pi(v_{\text{start}})}):=\pi(v_{\text{start}})$ and $\lambda(x_{\pi(v_{\text{end}})},v_{R}):=|P|+1-\pi(v_{\text{end}})$. Finally, define the set of demands $\mathcal{T}$ as $\{(v_{L},v_{R})\mid v\in V(G)\}$, and let $q^{\prime}:=|V(G)|\cdot|P|+q$. This completes the reduction.

To prove the correctness of our reduction, we first make several key observations. By construction, we have that for any $i\in[|P|]$, $W_{v}$ includes the vertex $x_{i}$ iff $i\in S_{v}^{\prime}$. Furthermore, for any $i\in[|P|]$ such that $x_{i}$ is hit by $W_{v}$, we have $\lambda(W_{v},x_{i})=i$. Thus, we see that two walks $W_{u},W_{v}$ share a vertex $x_{i}$ iff $S_{u}^{\prime}\cap S_{v}^{\prime}\neq\emptyset$ iff $uv\in E(G)$, and that for any such shared vertex $x$, $\lambda(W_{u},x)=\lambda(W_{v},x)$. Finally, note that for any $v\in V(G)$, $\lambda(W_{v})=|P|+1$.

Consider the case where $G$ has a solution of sum-cost at most $q$. Let $c:V(G)\to\mathbb{Z}_{\geq 1}$ be a proper coloring that achieves this sum. We can construct a solution $\{(d_{v},W_{v})\mid v\in V(G)\}$ to TDW instance $(G^{\prime},\lambda,\mathcal{T})$, where $(d_{v},W_{v})$ are the delay and walk for demand $(v_{L},v_{R})$, as follows: set $d_{v}=c(v)-1$, and let $W_{v}$ be the unique walk from $v_{L}$ to $v_{R}$ in $G^{\prime}$. By our key observations, we have $\sum_{v\in V(G)}(d_{v}+\lambda(W_{v}))=\sum_{v\in V(G)}(c(v)-1)+|V(G)|\cdot(|P|+1)\leq q+|V(G)|\cdot|P|=q^{\prime}$, and we know that if two walks $W_{u},W_{v}$ share a vertex $x$, then $c(u)\neq c(v)$ (by the validity of $c$), and so $d_{u}\neq d_{v}$. Thus, $d_{u}+\lambda(W_{u},x)\neq d_{v}+\lambda(W_{v},x)$, and so this solution to the TDW instance is valid.

Consider the case where $(G^{\prime},\lambda,\mathcal{T})$ has a solution of sum-cost at most $q^{\prime}$. Let $\{(d_{v},W_{v})\mid v\in V(G)\}$ be such a solution. We construct a solution $c:V(G)\to\mathbb{Z}_{\geq 1}$ to min-sum coloring instance $G$ by setting $c(v):=d_{v}+1$. By our key observations, we know that $uv\in V(G)\implies W_{u},W_{v}$ share some vertex $x$ where $\lambda(W_{u},x)=\lambda(W_{v},x)$; thus, by the validity of our TDW solution, we know that $d_{u}\neq d_{v}$, which means $c(u)\neq c(v)$. Thus, $c$ is a valid coloring of $V(G)$, and $\sum_{v\in V(G)}c(v)=\sum_{v\in V(G)}(d_{v}+1)\leq q^{\prime}-(|P|+1)\cdot|V(G)|+|V(G)|=q$. Thus, our reduction is correct, and it can clearly be done in poly time. ∎

4 Approximation preliminaries

Given an optimization problem $\mathcal{P}$, we let $I_{\mathcal{P}}$ denote the instances of $\mathcal{P}$, $SOL_{\mathcal{P}}$ map each $x\in I_{\mathcal{P}}$ to a set of feasible solutions, and let $c_{\mathcal{P}}$ assign a real cost to each pair $(x,y)$ where $x\in I_{\mathcal{P}}$ and $y\in SOL_{\mathcal{P}}(x)$. For $x\in I_{\mathcal{P}}$, we let $OPT_{\mathcal{P}}(x):=\min_{y^{\ast}\in SOL_{\mathcal{P}}(x)}c_{\mathcal{P}}(x,y^{\ast})$ if $\mathcal{P}$ is a minimization problem, and $OPT_{\mathcal{P}}(x):=\max_{y^{\ast}\in SOL_{\mathcal{P}}(x)}c_{\mathcal{P}}(x,y^{\ast})$ otherwise.

If $\mathcal{A}$ is a polynomial time algorithm with input $x\in I_{\mathcal{P}}$ and output $y\in SOL_{\mathcal{P}}(x)$, we say that $\mathcal{A}$ is a $\rho$-approximation algorithm, or has approximation ratio $\rho$, if $\mathcal{P}$ is a minimization problem and $c_{\mathcal{P}}(x,\mathcal{A}(x))/OPT_{\mathcal{P}}(x)\leq\rho$, or $\mathcal{P}$ is a maximization problem and $OPT_{\mathcal{P}}(x)/c_{\mathcal{P}}(x,\mathcal{A}(x))\leq\rho$, for all $x\in I_{\mathcal{P}}$. Note that $\rho\geq 1$.

The class APX contains all optimization problems that admit a $\rho$-approximation algorithm, for some constant $\rho>1$. An optimization problem is said to be APX-hard if every problem in APX can be reduced to it through an approximation-preserving reduction. One reduction of this type is the L-reduction:

Definition 6** (L-reduction).**

An L-reduction from an optimization problem $\mathcal{P}$ to an optimization problem $\mathcal{Q}$, denoted $\mathcal{P}\leq_{L}\mathcal{Q}$, is a tuple $(f,g,\alpha,\beta)$, where:

• •

For each $x\in I_{\mathcal{P}}$, $f(x)\in I_{\mathcal{Q}}$ and can be computed in polynomial time.

• •

For each $y\in SOL_{\mathcal{Q}}(f(x))$, $g(x,y)\in SOL_{\mathcal{P}}(x)$ and can be computed in polynomial time.

• •

$\alpha$* is a positive real constant such that for each $x\in I_{\mathcal{P}}$,*

[TABLE]

• •

$\beta$* is a positive real constant such that for each $x\in I_{\mathcal{P}},y\in SOL_{\mathcal{Q}}(f(x))$,*

[TABLE]

If a problem is APX-hard, it is NP-hard to $\rho$-approximate for some constant $\rho>1$; thus, showing APX-hardness is strictly stronger than showing NP-hardness. To show APX-hardness, one can simply L-reduce from a known APX-hard problem. We refer the reader to [ACG*+*99] for a good reference on approximation.

5 Hardness of approximation

To show the hardness of min-sum TDW on bounded-degree DAGs, we show an L-reduction from MAX-E2SAT(3), which is known to be APX-hard [BK99]. We remind the reader of the definition, below, and then proceed with our proof.

Definition 7** (MAX-E2SAT(3)).**

Let $\phi$ be a CNF formula in which (i) each clause contains exactly two literals on distinct variables, and (ii) each variable appears in at most three clauses. Find a truth assignment to the variables in $\phi$ that maximizes the number of satisfied clauses.

Theorem 5**.**

Min-sum Time Disjoint Walks is APX-hard, even for DAGs with $\Delta\leq 3$.

Proof.

We let $\mathcal{P}:=$ MAX-E2SAT(3), $\mathcal{Q}:=$ TDW with instances restricted to those containing DAGs with $\Delta\leq 3$, and show that $\mathcal{P}\leq_{L}\mathcal{Q}$. Below, we describe our L-reduction $(f,g,\alpha,\beta)$.

Description of $f$: Given an instance $\phi\in I_{\mathcal{P}}$ with $n$ variables and $m$ clauses, we let $X:=\{x_{1},\dots,x_{n}\}$ refer to its variables and $\mathcal{C}:=\{C_{1},\dots,C_{m}\}$ refer to its clauses. We let $L:=\{x_{1},\dots,x_{n},\overline{x}_{1},\dots,\overline{x}_{n}\}$ refer to its literals. For convenience, we define $e:L\to X$ that extracts the variable from a given literal; i.e., $e(x_{i})=e(\overline{x}_{i})=x_{i}$. We label the literals in clause $C_{j}$ as $l^{1}_{j},l^{2}_{j}$. For each $l\in L$, we let $S_{l}:=\{l^{a}_{j}\mid a\in[2],j\in[m],l^{a}_{j}=l\}$ capture all occurrences of literal $l$ in $\phi$. Finally, for each $l\in L$, we define an arbitrary bijection $\pi_{l}:S_{l}\to[|S_{l}|]$ to induce an ordering on $S_{l}$. We will let $\pi_{l}^{-1}$ denote its inverse: i.e., $\pi_{l}^{-1}(1)$ is the first element in $S_{l}$ in the order induced by $\pi_{l}$.

We may now describe $f$, which constructs an instance $(G,\lambda,\mathcal{T})\in I_{\mathcal{Q}}$ from $\phi$. We start with the construction of $G$ (see Figure 2), which closely follows the standard proof of NP-hardness for Disjoint Paths: for each clause $C_{j}=(l_{j}^{1}\lor l_{j}^{2})$ in $\phi$, we create a new clause gadget and add it to $G$. That is, for each clause $C_{j}$, we add the following vertex and arc set to our construction:

[TABLE]

Next, for each $x_{i}\in X$, we add an interleaving variable gadget as follows: first, we add two vertices $x_{i}^{s},x_{i}^{t}$ to $V(G)$. Then, we wish to create exactly two directed paths (walks), $W_{x_{i}}^{+},W_{x_{i}}^{-}$, from $x_{i}^{s}$ to $x_{i}^{t}$: we want $W_{x_{i}}^{+}$ to travel through all vertices corresponding to positive literals of $x_{i}$, and $W_{x_{i}}^{-}$ to travel through all vertices corresponding to negative literals of $x_{i}$. Formally, for each $l\in\{x_{i},\overline{x}_{i}\}$, we create a path from $x_{i}^{s}$ to $x_{i}^{t}$ as follows. First, if $|S_{l}|=0$, we add arc $(x_{i}^{s},x_{i}^{t})$ to $E(G)$. Otherwise, we add arcs $(x_{i}^{s},\pi_{l}^{-1}(1))$ and $((\pi_{l}^{-1}(|S_{l}|))^{\prime},x_{i}^{t})$ to $E(G)$, and then for each $j\in[|S_{l}|-1]$, we add arc $((\pi_{l}^{-1}(j))^{\prime},\pi_{l}^{-1}(j+1))$. Note that the prime symbols are merely labels, and are used in our construction to ensure that the max degree of $G$ remains at most three.

This completes our construction of $G$. We now define a set of $n+m$ demands, where each corresponds to a variable or a clause:

[TABLE]

Finally, we must define arc lengths $\lambda:E\rightarrow\mathbb{Z}_{\geq 1}$. We will do this in a way that for each $j\in[m],a\in[2]$, we have $\lambda(W_{c_{j}^{s}},l_{j}^{a})=\lambda(W_{x^{s}_{i}},l_{j}^{a})$, where $W_{c_{j}^{s}}$ is the unique walk in $G$ from $c_{j}^{s}$ to $l_{j}^{a}$, and $W_{x_{i}^{s}}$ is the unique walk in $G$ from $x_{i}^{s}=e(l_{j}^{a})^{s}$ to $l_{j}^{a}$. Call this property ($\ast$). To facilitate our analysis, we will also want every demand-satisfying path in $G$ to have the same length.

Since $\phi$ is an instance of MAX-E2SAT(3), we know that for each $i\in[n]$, each of the two paths between $x_{i}^{s}$ and $x_{i}^{t}$ passes through at most 3 clause gadgets. Thus, by our construction, each such path includes at most 7 arcs, and any path from a variable $x_{i}^{s}$ to some literal $l_{j}^{a}$ with $x_{i}=e(l_{j}^{a})$ can use at most 5 arcs. Thus, we can successfully force each demand-satisfying path in $G$ to have length 7 while maintaining property ($\ast$) by defining $\lambda:E\rightarrow\mathbb{Z}_{\geq 1}$ as follows, completing our construction of $(G,\lambda,\mathcal{T})\in I_{\mathcal{Q}}$:

[TABLE]

Description of $g$: Given a solution $y\in SOL_{\mathcal{Q}}(f(\phi))$, we construct a solution $g(\phi,y)\in SOL_{\mathcal{P}}(\phi)$ through two consecutive transformations: $z$, followed by $q$. That is, we will define transformations $z$ and $q$ such that $g$ is the composition $g(\phi,y):=q(\phi,z(y))$.

We define $z$ to transform solution $y$ into another solution $y^{\prime}\in SOL_{\mathcal{Q}}(f(\phi))$ such that $c_{\mathcal{Q}}(f(\phi),y^{\prime})\leq c_{\mathcal{Q}}(f(\phi),y)$ and such that $y^{\prime}$ assigns 0 delay to demands associated with interleaving variable gadgets. To accomplish this, recall that $y=\{(d_{1},W_{1}),\dots,(d_{n+m},W_{n+m})\}$, by definition of $SOL_{\mathcal{Q}}$. Without loss of generality, we may assume tuples indexed with $[n]$ correspond to demands on interleaving variable gadgets, and tuples indexed with $[n+m]\setminus[n]$ correspond to demands on clause gadgets.

Now, while there exists some $i\in[n]$ such that $d_{i}>0$ (and thus $d_{i}\geq 1$), we perform the following modification on $y$: first, we reset $W_{i}$ to be the path traveling through at most one clause gadget - the positive or negative path must have this property, because each variable appears in $\phi$ at most three times, by definition of MAX-E2SAT(3). Now, reset $d_{i}$ to 0. If $W_{i}$ shares a vertex with another walk $W_{j}$, we know $j\in[n+m]\setminus[n]$, by construction of $G$. In this case, reset $d_{j}$ to 1 if and only if $d_{j}$ is currently 0. By construction of $\lambda$, the walks remain time disjoint and the cost of the solution does not increase.

In the second transformation, $q$, we transform modified solution $y^{\prime}$ into an assignment $(A:X\rightarrow\{T,F\})\in SOL_{\mathcal{P}}(\phi)$ as follows: for each $i\in[n]$, set $A(x_{i})=T$ if and only if $W_{x_{i}}$, the walk from $x_{i}^{s}$ to $x_{i}^{t}$, takes the negative literal path.

Valid value for $\alpha$: We will show that for $\alpha=29$, $OPT_{\mathcal{Q}}(f(\phi))\leq\alpha\cdot OPT_{\mathcal{P}}(\phi)$. To see this, we make two observations. First observation: if $A:X\rightarrow\{T,F\}$ is a truth assignment for $\phi$, then we can construct a solution to $f(\phi)$ as follows: for each $i\in[n]$, connect demand $(x_{i}^{s},x_{i}^{t})$ using the negative literal path if $A(x_{i})=T$, and the positive literal path if $A(x_{i})=F$. Either way, assign a delay of 0. Then, for each $j\in[m]$ where clause $C_{j}$ is satisfied by assignment $A$, connect demand $(c_{j}^{s},c_{j}^{t})$ using a walk that goes through a literal that evaluates to true under $A$. Assign a delay of 0 to this demand. For each clause $C_{j}$ that isn’t satisfied by $A$, select an arbitrary walk to complete the corresponding demand $(c_{j}^{s},c_{j}^{t})$. Assign a delay of 1 to this demand. It is clear that this is a valid solution to $f(\phi)$. Furthermore, the cost of our solution is $7(n+m)+U(A,\phi)$, where $U(A,\phi)$ is the number of clauses in $\phi$ unsatisfied by $A$. Second observation: by linearity of expectation, if $\phi$ is an instance of MAX-E2SAT(3), then there must exist an assignment $A:X(\phi)\rightarrow\{T,F\}$ that satisfies at least $3/4$ of the clauses.

We may now prove the desired inequality for $\alpha=29$. From our first observation and the fact that $n\leq 2m$ (since each of the $m$ clauses has 2 literals),

[TABLE]

Now, by our second observation, we know $OPT_{\mathcal{P}}(\phi)\geq 3m/4$. Thus, we have:

[TABLE]

Valid value for $\beta$: We will show that for $\beta=1$ and any $y\in SOL_{\mathcal{Q}}(f(\phi))$, \big{(}OPT_{\mathcal{P}}(\phi)-c_{\mathcal{P}}(\phi,g(\phi,y))\big{)}\leq\beta\cdot\big{(}c_{\mathcal{Q}}(f(\phi),y)-OPT_{\mathcal{Q}}(f(\phi))\big{)}, as required. As a first step, we recall that transformations $z,q$ define $g$, and let $\gamma$ denote the number of clause gadget demands assigned a delay of 0 by solution $z(y)$ to $f(\phi)$. We make the following crucial claim:

[TABLE]

To see this, note the following: by construction, $z(y)$ is a valid solution to $f(\phi)$. Thus, if $z(y)$ assigns clause gadget demand $(c_{j}^{s},c_{j}^{t})$ a delay $d_{j}=0$ and walk $W_{j}$ that passes through literal $l$, then $l$ is a positive literal if and only if the walk selected for the interleaving variable gadget demand $(x_{i}^{s},x_{i}^{t})$ (where $x_{i}=e(l)$) does not travel through the positive literals of $x_{i}$. By definition of $q$, this occurs if and only if $g(\phi,y)$ assigns true to $x_{i}$. Thus, a clause gadget demand given 0 delay by $z(y)$ corresponds to a clause in $\phi$ satisfied by $g(\phi,y)$, thus proving Equation 2.

Next, by definition of $\gamma$ and $z$, we have:

[TABLE]

Combining Equations 2 and 3, we get:

[TABLE]

Finally, Equations 1 and 4 give us:

[TABLE]

for $\beta=1$, as desired. This completes the proof. ∎

Remark 1**.**

It is straightforward to tweak the above construction and analysis to show that min-max Time Disjoint Walks is NP-hard on DAGs with $\Delta\leq 3$.

6 Approximation algorithm

6.1 Algorithm

We present Algorithm 2, which approximates TDW by finding shortest paths to satisfy each demand, and then greedily assigning delays to each trip (with priority given to shorter trips). To simplify notation, we assume that the inputted terminal pairs are ordered by nondecreasing shortest path length (if not, we may simply sort the indices after finding the shortest demand-satisfying paths). The algorithm clearly runs in polynomial time, and the $\mathsf{bad\_delay}$ variables ensure the feasibility of its output. Next, we briefly note the following easy bound:

Proposition 1**.**

Algorithm 2* has an approximation ratio of $O(k)$ for min-sum Time Disjoint Walks on general digraphs.*

Proof.

Let $x:=(G,\lambda,\mathcal{T})\in I_{TDW}$, and let $\mathcal{A}(x)\in SOL_{TDW}$ be the output of Algorithm 2 on $x$. First, we show by induction that for each $i\in[k]$,

[TABLE]

For the base case $i=1$, note that $\mathsf{bad\_delays}_{i}=\emptyset$ and so $d_{i}$ = 0. For $i>1$, first observe that by definition of $\mathsf{bad\_delay}$, we have $d_{i}\leq 1+\max_{h\in[i-1]}(d_{h}+\lambda(W_{h}))$. Thus,

[TABLE]

completing the induction. Now, recallling that our algorithm uses the shortest paths to satisfy each demand, and that it assigns delays to shorter paths first, we can bound the approximation ratio as follows:

[TABLE]

∎

Remark 2**.**

It is straightforward to tweak the above analysis to show that for min-max Time Disjoint Walks, Algorithm 2 has an approximation ratio of $O(k)$ on general digraphs.

6.2 Analysis on bounded-degree DAGs

We now show that our algorithm is able to achieve a better approximation ratio on bounded-degree DAGs. In what follows, we call a directed graph a “$(2,l)$-in-tree” if it is a perfect binary tree of depth $l$, in which every arc points toward the root. Analogously, a “$(2,l)$-out-tree” is a perfect binary tree of depth $l$, in which every arc points away from the root.

Theorem 6**.**

Algorithm 2* achieves an approximation ratio of $\Theta(k/\log k)$ for min-sum Time Disjoint Walks on bounded-degree DAGs.*

Proof.

Upper bound: Let $x:=(G,\lambda,\mathcal{T})\in I_{TDW}$ such that $G$ is a bounded-degree DAG. Let $\mathcal{A}(x)\in SOL_{TDW}$ be the output of Algorithm 2 on $x$. We may assume $\Delta>1$, because otherwise it is straightforward to show $\mathcal{A}(x)$ is optimal. In what follows, we will justify the following string of inequalities that proves the upper bound:

[TABLE]

Equation 5 is clear, because our algorithm takes the shortest path to satisfy each demand. Equation 6 follows (by induction) from the following general observation: given $d_{1},d_{2}\in\mathbb{Z}_{\geq 0}$ and $\lambda_{1},\lambda_{2}\in\mathbb{Z}_{\geq 1}$, observe $d_{1}/\lambda_{1}\leq d_{2}/\lambda_{2}\implies(d_{1}+d_{2})/(\lambda_{1}+\lambda_{2})\leq d_{2}/\lambda_{2}$, and thus $(d_{1}+d_{2})/(\lambda_{1}+\lambda_{2})\leq\max(d_{1}/\lambda_{1},d_{2}/\lambda_{2})$.

To show Equation 7, we need two observations. We first observe that for each $i\in[k]$:

[TABLE]

To see this, suppose for contradiction that there exists some $h\in[i-1]$ with $W_{h}\cap W_{i}\neq\emptyset$ and $|\mathsf{bad\_delays}_{i,h}|>1$. Then, by definition of $\mathsf{bad\_delay}$, there exist vertices $u,v\in W_{h}\cap W_{i}$ and delays $\delta_{u}\neq\delta_{v}\in\mathbb{Z}_{\geq 0}$ such that:

[TABLE]

where the last equality follows from the first two. But because $\delta_{u}\neq\delta_{v}$, this implies that the length of the path that $W_{h}$ and $W_{i}$ use to travel between $u$ and $v$ is not the same. Because $G$ is a DAG, $W_{h}$ and $W_{i}$ must visit $u$ and $v$ in the same order, implying that one of these walks is not taking the shortest path from $u$ to $v$, which contradicts the definition of the algorithm. Because $|\mathsf{bad\_delays}_{i,h}|=0$ if $W_{h}\cap W_{i}=\emptyset$, we have $d_{i}\leq\mu_{i}$.

Next, we observe that:

[TABLE]

Showing $\mu_{i}\leq k$ is trivial, by definition of $\mu_{i}$ and because $i\in[k]$. To show $\mu_{i}\leq\Delta^{4\lambda(W_{i})}$, first note that in a digraph with max degree $\Delta$, the number of paths that (i) have $z$ arcs, (ii) start at distinct vertices, and (iii) all end at a common vertex, is upper bounded by $\Delta^{z}$ (this is easy to show by induction on $z$). Thus, the number of paths with $\leq z$ arcs, in addition to properties (ii) and (iii), is upper bounded by $\sum_{l=0}^{z}\Delta^{l}\leq\Delta^{z+1}$, for $\Delta>1$. Call this lemma ($\ast$).

Now, note that for each $h\in[i-1]$ we may consider each $W_{h}$ to terminate once it first hits a vertex in $W_{i}$ (i.e., cut off all vertices that are hit afterwards) without changing the value of $\mu_{i}$. Now, recall the following facts about our problem and algorithm: (I) each inputted demand has a unique source; (II) each edge in our digraph has length $\geq 1$; (III) for all $h\in[i-1]$, $\lambda(W_{h})\leq\lambda(W_{i})$. Thus, by (III) and lemma ($\ast$), each vertex in $W_{i}$ can be hit by at most $\Delta^{\lambda(W_{i})+1}$ walks in $\{W_{1},\dots,W_{i-1}\}$. Furthermore, (II) tells us that the number of vertices in $W_{i}$ is no more than $\lambda(W_{i})+1$. Thus, recalling that $\Delta>1$, and that no demands have the same source and destination, and (II), we see that

[TABLE]

as desired. We now note that we may assume $d_{i}$ is greater than any constant (otherwise, Equation 6 automatically proves a constant approximation ratio, completing the proof). Thus, from this and the above observations, we have $\log(d_{i})\leq 4\lambda(W_{i})\log(\Delta)$. This proves Equation 7, because our graph has bounded degree.

Equation 8 is not difficult: as stated above, we will always have $d_{i}\leq k$, and we may always assume $d_{i}\geq 3$. Basic calculus shows the function $x/\log x$ increases over $x\geq 3$.

Lower bound: We show $\forall l\in\mathbb{N}_{\geq 1},k:=2^{l}$, $\exists(G_{k},\lambda_{k},\mathcal{T}_{k})\in I_{TDW}$ such that $G_{k}$ is a bounded-degree DAG and Algorithm 2 achieves an approximation ratio of $\Omega(k/\log k)$. Construct $G_{k}$ by taking a $(2,l)$-in-tree $A_{S}$ and a $(2,l)$-out-tree $A_{T}$. Draw an arc from the root of the former to the root of the latter. Then, arbitrarily pair each leaf (source) in $A_{S}$ with a unique leaf (destination) in $A_{T}$. For each such pair, draw an arc from source to destination (called a “bypass arc”), and add a demand to $\mathcal{T}_{k}$. Finally, define $\lambda_{k}$ to assign length $1+2l$ to each “bypass” arc, and length 1 to all other arcs. We refer the reader to Figure 3, part (i).

We may assume our algorithm does not satisfy demands using the bypass arcs (as all demand-satisfying paths have length $2l+1$, and no tie-breaking scheme is specified). Thus, each demand-satisfying path uses the root of $A_{S}$, which incurs a total delay of $0+1+\ldots+(k-1)=\Omega(k^{2})$ and total path length of $k\cdot(1+2l)$. Had the bypass arcs been used, no delay would have been required, and the total path length would have still been $k\cdot(1+2l)$. Thus, our algorithm achieves an approximation ratio of $(\Omega(k^{2})+k\cdot(1+2l))/(k\cdot(1+2l))=\Omega(k/\log k)$. ∎

Remark 3**.**

It is straightforward to tweak the above analysis to show that for min-max Time Disjoint Walks, Algorithm 2 achieves an approximation ratio of $\Theta(k/\log k)$ on bounded-degree DAGs.

6.3 Analysis on DAGs

We show that if we no longer require the graph family in Theorem 6 to have bounded degree, our algorithm loses its improved approximation ratio.

Theorem 7**.**

Algorithm 2* has an approximation ratio of $\Theta(k)$ for min-sum Time Disjoint Walks on DAGs.*

Proof.

By Proposition 1, it suffices to construct a family of TDW instances on DAGs, defined over all $k\in\mathbb{N}_{\geq 1}$, for which our algorithm achieves an approximation ratio of $\Omega(k)$. Construct $G_{k}$ by fixing a “root” vertex and directly attaching $2k$ leaves. Orient half of these arcs towards the root, and half of the arcs away from the root. Call each vertex with out-degree 1 a source, and each vertex with in-degree 1 a destination. Then, arbitrarily pair each source with a unique destination. For each pair, add an arc from the source to the destination (called a “bypass arc”), and add a demand to $\mathcal{T}_{k}$. Finally, let $\lambda_{k}$ assign length 2 to each bypass arc, and length 1 to all other arcs. We refer the reader to Figure 3, part (ii).

We may assume our algorithm does not satisfy demands using the bypass arcs (as all demand-satisfying paths have length 2, and no tie-breaking scheme is specified). Thus, each demand-satisfying path uses the root vertex, which incurs a total delay of $0+1+\ldots+(k-1)=\Omega(k^{2})$ and total path length of $2k$. Had the bypass arcs been used, no delay would have been required, and the total path length would have still been $2k$. Thus, our algorithm achieves an approximation ratio of $(\Omega(k^{2})+2k)/(2k)=\Omega(k)$. ∎

Remark 4**.**

It is straightforward to slightly tweak the above analysis to show that for min-max Time Disjoint Walks, Algorithm 2 has an approximation ratio of $\Theta(k)$ on DAGs.

6.4 Analysis on bounded-degree digraphs

In this section, we show that if we no longer require the graph family in Theorem 6 to be acyclic, our algorithm loses its improved approximation ratio.

Theorem 8**.**

Algorithm 2* has an approximation ratio of $\Theta(k)$ for min-sum Time Disjoint Walks on bounded-degree digraphs.*

Proof.

By Proposition 1, it suffices to construct a family of TDW instances on bounded-degree digraphs, defined over all $l\in\mathbb{N}_{\geq 2}$ with $\hat{k}:=2^{l},k:=2\hat{k}$, for which our algorithm achieves an approximation ratio of $\Omega(k)$. Construct $G_{k}$ by taking two $(2,l)$-in-trees $A_{S}$ and $B_{S}$, and two $(2,l)$-out-trees $A_{T}$ and $B_{T}$. Call their roots $r_{A_{S}},r_{B_{S}},r_{A_{T}}$, and $r_{B_{T}}$, respectively. Then, add a “central path” $C$ consisting of vertices $\{c_{1},c_{2},\dots,c_{\hat{k}}\}$, “forward” arcs $\{(c_{i},c_{i+1})\mid i\in[\hat{k}-1]\}$, and “backward” arcs $\{(c_{j},c_{j-3})\mid j\in[4,\hat{k}],j\bmod 2=0\}$. Attach the directed trees to the central path with arcs $\{(r_{A_{S}},c_{1}),(r_{B_{S}},c_{\hat{k}-1}),(c_{\hat{k}},r_{A_{T}}),(c_{2},r_{B_{T}})\}$. Next, pair each leaf (source) in $A_{S}$ with an arbitrary, but unique, leaf (destination) in $A_{T}$. Do the same for $B_{S}$ and $B_{T}$. For each such pair, add an arc from the source to destination (called a “bypass arc”), and add a demand to $\mathcal{T}_{k}$. Finally, let $\lambda_{k}$ assign length $2\hat{k}+2l-1$ to each bypass arc, length $\hat{k}-1$ to arcs $(r_{B_{S}},c_{\hat{k}-1})$ and $(c_{\hat{k}},r_{A_{T}})$, and length $1$ to all other arcs. We refer the reader to Figure 3, part (iii).

Observe that for each demand, there exist two shortest demand-satisfying paths, each of length $2\hat{k}+2l-1$. In particular, observe that a demand between leaves of $A_{S}$ and $A_{T}$ may be satisfied by a bypass arc, or by a path that travels from the source in $A_{S}$, towards the root of $A_{S}$, onto the central path vertex $c_{1}$, along all forward arcs of $C$, onto the root of $A_{T}$, and towards the destination in $A_{T}$. Similarly, a demand between leaves of $B_{S}$ and $B_{T}$ may be satisfied by a bypass arc, or by a path that travels from the source in $B_{S}$, towards the root of $B_{S}$, onto the central vertex $c_{\hat{k}-1}$, across $C$ by alternating between forward and backward arcs (until arriving at $c_{2}$), onto the root of $B_{T}$, and towards the destination in $B_{T}$. We call the paths that do not use the bypass arcs the “meandering paths.”

Because our algorithm specifies no tie-breaking scheme, we may assume that it satisfies demands using the meandering paths, and that it alternates between assigning delays to demands from $A_{S}$ and assigning delays to demands from $B_{S}$ every four iterations. In other words, out of the $2\hat{k}$ demands created above and fed as input to our algorithm, we may assume that those from $A_{S}$ to $A_{T}$ are labeled with indices $I_{A}:=\{i\in[2\hat{k}]\mid\lfloor(i-1)/4\rfloor\equiv 0\pmod{2}\}$, while those from $B_{S}$ to $B_{T}$ are labeled with $I_{B}:=\{i\in[2\hat{k}]\mid\lfloor(i-1)/4\rfloor\equiv 1\pmod{2}\}$.

To understand the suboptimality of this situation, we make several observations that help us determine the values our algorithm assigns to each $d_{i}$. First, note that for each $i\in[2\hat{k}]$, $z\in[\hat{k}]$, the length of walk $W_{i}$ up to vertex $c_{z}$ on the central path is:

[TABLE]

Using this, we see that the details of Algorithm 2 give us the following relation, which is defined over $i\in[k],h\in[i-1]$:

[TABLE]

Because our algorithm defines $\mathsf{bad\_delays}_{i}:=\bigcup_{h\in[i-1]}\mathsf{bad\_delays}_{i,h}$ and $d_{i}:=\min(\mathbb{Z}_{\geq 0}\setminus\mathsf{bad\_delays}_{i})$, observe that the above relation is in fact a recurrence relation. As such, after noting that $d_{1}=0$, it is straightforward to use the above relation to show by induction that for all $i\in[2\hat{k}]$,

[TABLE]

Thus, our algorithm incurs a total delay of $\sum_{i\in[2\hat{k}]}(i-1+\lfloor(i-1)/8\rfloor(2\hat{k}-4))=\Omega(\hat{k}^{3})=\Omega(k^{3})$ and total walk length of $2\hat{k}\cdot(2\hat{k}+2l-1))=\Theta(\hat{k}^{2})=\Theta(k^{2})$. Had the algorithm opted to use the bypass arcs, no delay would have been required, and the total walk length would have been the same. Thus, our algorithm achieves an approximation ratio of $\Omega(k)$. ∎

Remark 5**.**

It is straightforward to slightly tweak the above analysis to show that for min-max Time Disjoint Walks, Algorithm 2 has an approximation ratio of $\Theta(k)$ on bounded-degree digraphs.

7 Conclusions

In this paper, we introduce Time Disjoint Walks, a new variant of (shortest) Disjoint Paths that similarly seeks to connect $k$ demands in a network, but relaxes the disjointness constraint by permitting vertices to be shared across multiple walks, as long as no two walks arrive at the same vertex at the same time. We present and analyze a poly-time exact algorithm for both min-sum and min-max TDW on oriented stars, and show that min-sum TDW becomes NP-hard on a slightly more expressive class of inputs. We show that min-sum Time Disjoint Walks is APX-hard, even for DAGs of max degree three. On the other hand, we provide a natural $\Theta(k/\log k)$-approximation algorithm for directed acyclic graphs of bounded degree. Interestingly, we also show that for general digraphs with just one of these two properties, the approximation ratio of our algorithm is bumped up to $\Theta(k)$.

An interesting future work is to tighten the gap between these inapproximability and approximability results for TDW on bounded-degree DAGs. We conjecture that our approximation algorithm is almost optimal, but that our hardness of approximation result can be strengthened to nearly match our algorithm’s approximation ratio of $\Theta(k/\log k)$. This belief is based on the observation that TDW is a complex problem that involves both routing and scheduling, and many problems of the latter variety (of size $n$) are NP-hard to approximate within a factor of $n^{1-\epsilon}$, for any $\epsilon>0$ [Zuc06]. One may also wish to explore similar complexity questions for the many variants of Time Disjoint Walks discussed in Section 2.