An Efficient Algorithm for the Fast Delivery Problem

TL;DR

This paper introduces a new efficient algorithm for the fast delivery problem involving autonomous agents on a graph, significantly reducing the computation time compared to previous methods.

Contribution

The paper presents an O(kn log n + km) time algorithm for package delivery with autonomous agents, improving upon the previous state-of-the-art algorithms.

Findings

The new algorithm reduces the delivery scheduling computation time.

It outperforms previous algorithms in terms of efficiency.

The approach is applicable to large-scale graph-based delivery problems.

Abstract

We study a problem where k autonomous mobile agents are initially located on distinct nodes of a weighted graph (with n nodes and m edges). Each autonomous mobile agent has a predefined velocity and is only allowed to move along the edges of the graph. We are interested in delivering a package, initially positioned in a source node s, to a destination node y. The delivery is achieved by the collective effort of the autonomous mobile agents, which can carry and exchange the package among them. The objective is to compute a delivery schedule that minimizes the delivery time of the package. In this paper, we propose an O(kn log n + km) time algorithm for this problem. This improves the previous state-of-the-art O(k^2 m + k n^2 + APSP) time algorithm for this problem, where APSP stands for the running-time of an algorithm for the All-Pairs Shortest Paths problem.

Full text

1 Introduction

Enterprises, such as DHL, UPS, Swiss Post, and Amazon, are now delivering goods and packages to their clients using autonomous drones [1, 16]. Those drones depart from a base (which can be static, such as a warehouse [14], or mobile, such as a truck or a van [15]) and deliver the package into their clients’ houses or in the street. However, packages are not delivered to a client that is too far from the drone’s base due to the energy limitations of such autonomous aerial vehicles.

In the literature, we find some proposals for delivering packages over a longer distance. One of them, proposed by Hong, Kuby, and Murray [14], is to install recharging bases in several spots, which allows a drone to stop, recharge, and continue its path. However, this strategy may result in a delayed delivery, because drones may stop several times to recharge during a single delivery.

A manner to overcome this limitation is to use a swarm of drones. The idea of this technique is to position drones in recharging bases all over the delivery area. Therefore, a package can be delivered from one place to another through the collective effort of such drones, which can exchange packets among them to achieve a faster delivery. One may note that, when not carrying a package, a drone is stationed in its recharging base, waiting for the next package arrival. The problem of computing a package delivery schedule with minimum delivery time for a single package is called the FastDelivery problem [4].

We can model the input to the FastDelivery problem as a graph $G=(V,E)$ with $|V|=n$ and $|E|=m$, with a positive length $l_{e}$ associated with each edge $e\in E$, and a set of $k$ autonomous mobile agents (e. g., autonomous drones) located initially on distinct nodes $p_{1},p_{2},\ldots,p_{k}$ of $G$. Each agent $i$ has a predefined velocity $v_{i}>0$. Mobile agent $i$ can traverse an edge $e$ of the graph in $l_{e}/v_{i}$ time. The package handover between agents can be done on the nodes of the graph or in any point of the graph’s edges, as exemplified in Fig. 1. The objective of FastDelivery is to deliver a single package, initially located in a source node $s\in V$, to a target node $y\in V$ while minimizing the delivery time $\mathcal{T}$.

Bärtschi et al. [4] also consider the case where each agent $i$ is additionally associated with a weight $\omega_{i}>0$ and consumes energy $\omega_{i}\cdot l_{e}$ when traversing edge $e$. For this model, the total energy consumption $\mathcal{E}$ of a solution becomes relevant as well, and one can consider the objective of minimizing $\mathcal{E}$ among all solutions that have the minimum delivery time $\mathcal{T}$ (or vice versa), or of minimizing a convex combination $\varepsilon\cdot\mathcal{T}+(1-\varepsilon)\cdot\mathcal{E}$ for a given $\varepsilon\in(0,1)$.

1.1 Related Work

The problem of delivering packages through a swarm of autonomous drones has been studied in the literature. The work of Bärtschi et al. [3] considers the problem of delivering packages while minimizing the total energy consumption of the drones. In their work, all drones have the same velocity but may have different weights, and the package’s exchanges between drones are restricted to take place on the graph’s nodes. They show that this problem is NP-hard when an arbitrary number of packages need to be delivered, but can be solved in polynomial time for a single package, with complexity $\mathcal{O}(k+n^{3})$.

When minimizing only the delivery time $\mathcal{T}$, one can solve the problem of delivering a single package with autonomous mobile agents with different velocities in polynomial-time: Bärtschi et al. [4] gave an $\mathcal{O}(k^{2}m+kn^{2}+\mathrm{APSP})$ algorithm for this problem, where $\mathrm{APSP}$ stands for the time complexity of the All-Pairs Shortest Paths problem.

Some work in the literature considered the minimization of both the total delivery time and the energy consumption. It was shown that the problem of delivering a single package with autonomous agents of different velocities and weights is solvable in polynomial-time when lexicographically minimizing the tuple ($\mathcal{E},\mathcal{T}$) [5]. On the other hand, it is NP-hard to lexicographically minimize the tuple ($\mathcal{T},\mathcal{E}$) or a convex combination of both parameters [4].

A closely related problem is the Budgeted Delivery Problem (BDP) [8, 7, 2], in which a package needs to be delivered by a set of energy-constrained autonomous mobile agents. In BDP, the objective is to compute a route to deliver a single package while respecting the energy constraints of the autonomous mobile agents. This problem in weakly NP-hard in line graphs [8] and strongly NP-hard in general graphs [7]. A variant of this problem is the Returning Budgeted Delivery Problem (RBDP) [2], which has the additional constraint that the energy-constrained autonomous agents must return to their original bases after carrying the package. Surprisingly, this new restriction makes RBDP solvable in polynomial time in trees. However, it is still strongly NP-hard even for planar graphs.

1.2 Our Contribution

This paper deals with the FastDelivery problem. We focus on the first objective, i.e., computing delivery schedules with the minimum delivery time. We provide an $\mathcal{O}(kn\log n+km)$ time algorithm for FastDelivery, which is more efficient than the previous $\mathcal{O}(k^{2}m+kn^{2}+\mathrm{APSP})$ time algorithm for this problem [4].

Preliminaries are presented in Sect. 2. We then describe our algorithm to solve FastDelivery in Sect. 3. The algorithm uses as a subroutine, called once for each edge of $G$, an algorithm for a problem that we refer to as FastLineDelivery, which is presented in Sect. 4.

2 Preliminaries

As mentioned earlier, in the FastDelivery problem we are given an undirected graph $G=(V,E)$ with $n=|V|$ nodes and $m=|E|$ edges. Each edge $e\in E$ has a positive length $l_{e}$. We assume that a path can start on a node or in some point in the interior of an edge. Analogously, it can end on another node or in some point in the interior of an edge. The length of a path is equal to the sum of the lengths of its edges. If a path starts or ends at a point in the interior of an edge, only the portion of its length that is traversed by the path is counted. For example, a path that is entirely contained in an edge $e=\{u,v\}$ of length $l_{e}=10$ and starts at distance $2$ from $u$ and ends at distance $5$ from $u$ has length $3$.

We are also given $k$ mobile agents, which are initially located at nodes $p_{1},p_{2},\ldots,p_{k}\in V$. Each agent $i$ has a positive velocity (or speed) $v_{i}$, $1\leq i\leq k$. A single package is located initially (at time [math]) on a given source node $s\in V$ and needs to be delivered to a given target node $y\in V$. An agent can pick up the package in one location and drop it off (or hand it to another agent) in another one. An agent with velocity $v_{i}$ takes time $d/v_{i}$ to carry a package over a path of length $d$. The objective of FastDelivery is to determine a schedule for the agents to deliver the package to node $y$ as quickly as possible, i.e., to minimize the time when the package reaches $y$.

We assume that there is at most one agent on each node. This assumption can be justified by the fact that, if there were several agents on the same node, we would use only the fastest one among them. Therefore, as already observed in [4], after a preprocessing step running in time $\mathcal{O}(k+|V|)$, we may assume that $k\leq n$.

The following lemma from [4] establishes some useful properties of an optimal delivery schedule for the mobile agents.

Lemma 1** (Bärtschi et al., 2018).**

For every instance of FastDelivery, there is an optimum solution in which $(i)$ the velocities of the involved agents are strictly increasing, and $(ii)$ no involved agent arrives on its pick-up location earlier than the package (carried by the preceding agent).

3 Algorithm for the Fast Delivery Problem

Bärtschi et al. [4] present a dynamic programming algorithm that computes an optimum solution for FastDelivery in time $\mathcal{O}(k^{2}m+kn^{2}+\mathrm{APSP})\subseteq\mathcal{O}(k^{2}n^{2}+n^{3})$, where $\mathrm{APSP}$ denotes the time complexity of an algorithm for solving the all-pairs shortest path problem. In this paper we design an improved algorithm with running time $\mathcal{O}(km+kn\log n)\subseteq\mathcal{O}(n^{3})$ by showing that the problem can be solved by adapting the approach of Dijkstra’s algorithm for edges with time-dependent transit times [9, 11].

For any edge $\{u,v\}$, we denote by $a_{t}(u,v)$ the earliest time for the package to arrive at $v$ if the package is at node $u$ at time $t$ and needs to be carried over the edge $\{u,v\}$. We refer to the problem of computing $a_{t}(u,v)$, for a given value of $t$ that represents the earliest time when the package can reach $u$, as FastLineDelivery. In Sect. 4, we will show that FastLineDelivery can be solved in $\mathcal{O}(k)$ time after a preprocessing step that spends $\mathcal{O}(k\log k)$ time per node. Our preprocessing calls PreprocessReceiver$(v)$ once for each node $v\in V\setminus\{s\}$ at the start of the algorithm. Then, it calls PreprocessSender$(u,t)$ once for each node $u\in V$, where $t$ is the earliest time when the package can reach $u$. Both preprocessing steps run in $\mathcal{O}(k\log k)$ time per node. Once both preprocessing steps have been carried out, a call to FastLineDelivery$(u,v,t)$ computes $a_{t}(u,v)$ in $\mathcal{O}(k)$ time.

Algorithm 1 shows the pseudo-code for our solution for FastDelivery. Initially, we run Dijkstra’s algorithm to solve the single-source shortest paths problem for each node where an agent is located initially (line 2). This takes time $\mathcal{O}(k(n\log n+m))$ if we use the implementation of Dijkstra’s algorithm with Fibonacci heaps as priority queue [12] and yields the distance $d(p_{i},v)$ (with respect to edge lengths $l_{e}$) between any node $p_{i}$ where an agent is located and any node $v\in V$. From this we compute, for every node $v$, the earliest time when each mobile agent can arrive at that node: The earliest possible arrival time of agent $i$ at node $v$ is $a_{i}(v)=d(p_{i},v)/v_{i}$. Then, we create a list of the arrival times of the $k$ agents on each node (line 3). For each node, we sort the list of the $k$ agents by ascending arrival time in $\mathcal{O}(k\log k)$ time, or $\mathcal{O}(nk\log k)$ in total for all nodes. We then discard from the list of each node all agents that arrive at the same time or after an agent that is strictly faster. If several agents with the same velocity arrive at the same time, we keep one of them arbitrarily. Let $A(v)$ denote the resulting list for node $v$. Those lists will be used in the solution of the FastLineDelivery problem described in Sect. 4.

For each node $v$, we maintain a value $\mathit{dist}(v)$ that represents the current upper bound on the earliest time when the package can reach $v$ (lines 5 and 6). The algorithm maintains a priority queue containing nodes that have a finite $\mathit{dist}$ value, with the $\mathit{dist}$ value as the priority (line 8). In each step, a node $u$ with minimum $\mathit{dist}$ value is removed from the priority queue (lines 10 and 11), and the node becomes final (line 12). Nodes that are not final are called non-final. The $\mathit{dist}$ value of a final node will not change any more and represents the earliest time when the package can reach the node (line 16). After $u$ has been removed from the priority queue, we compute for each non-final neighbor $v$ of $u$ the time $a_{t}(u,v)$, where $t=\mathit{dist}(u)$, by solving the FastLineDelivery problem (line 19). If $v$ is already in $Q$, we compare $a_{t}(u,v)$ with $\mathit{dist}(v)$ and, if $a_{t}(u,v)<\mathit{dist}(v)$, update $\mathit{dist}(v)$ to $\mathit{dist}(v)=a_{t}(u,v)$ and adjust the priority of $v$ in $Q$ accordingly (line 23). On the other hand, if $v$ is not yet in $Q$, we set $\mathit{dist}(v)=a_{t}(u,v)$ and insert $v$ into $Q$ (line 25).

Let $t_{s}$ be the earliest time when an agent reaches $s$ (or [math], if an agent is located at $s$ initially). Let $i^{\prime}$ be that agent. As the package must stay at $s$ from time [math] to time $t_{s}$, we can assume that $i^{\prime}$ brings the package to $s$ at time $t_{s}$. Therefore, we initially set $\mathit{dist}(s)=t_{s}$ and insert $s$ into the priority queue $Q$ with priority $t_{s}$. The algorithm terminates when $y$ becomes final (line 14) and returns the value $\mathit{dist}(y)$, i.e., the earliest time when the package can reach $y$. The schedule that delivers the package to $y$ by time $\mathit{dist}(y)$ can be constructed in the standard way, by storing for each node $v$ the predecessor node $u$ such that $\mathit{dist}(v)=a_{\mathit{dist}(u)}(u,v)$ and the schedule of the solution to FastLineDelivery$(u,v,\mathit{dist}(u))$.

Theorem 2**.**

Algorithm 1 runs in $\mathcal{O}(kn\log n+km)$ time and computes an optimal solution to the FastDelivery problem.

Proof.

First, we note that it is easy to see that $a_{t}(u,v)\leq a_{t^{\prime}}(u,v)$ holds for $t^{\prime}\geq t$ in our setting: If the package arrives at $u$ at time $t$ and if we had $a_{t^{\prime}}(u,v)<a_{t}(u,v)$ for some $t^{\prime}>t$, the package could simply wait at $u$ until time $t^{\prime}$ and then get transported to $v$ in the same way as if it had reached $u$ at time $t^{\prime}$. The package would reach $v$ at time $a_{t^{\prime}}(u,v)$, contradicting the assumption that $a_{t^{\prime}}(u,v)<a_{t}(u,v)$. Thus, the network has the FIFO property (or non-overtaking property), and it is known that the modified Dijkstra algorithm is correct for such networks [11].

Furthermore, we can observe that concatenating the solutions of FastLineDelivery (which are computed by Algorithm 4 in Sect. 4 and which are correct by Theorem 3 in Sect. 4) over the edges of the shortest path from $s$ to $y$ determined by Algorithm 1 indeed gives a feasible solution to FastDelivery: Assume that the package reaches $u$ at time $t$ while being carried by agent $i$ and is then transported from $u$ to $v$ over edge $\{u,v\}$, reaching $v$ at time $a_{t}(u,v)$. The only agents involved in transporting the package from $u$ to $v$ in the solution returned by FastLineDelivery$(u,v,t)$ will have velocity at least $v_{i}$ because agent $i$ arrives at $u$ before time $t$, i.e., $a_{i}(u)\leq t$, and hence no slower agent would be used to transport the package from $u$ to $v$. These agents have not been involved in transporting the package from $s$ to $u$ by property (i) of Lemma 1, except for agent $i$ who is indeed available at node $u$ from time $t$.

The running time of the algorithm consists of the following components: Computing standard shortest paths with respect to the edge lengths $l_{e}$ from the locations of the agents to all other nodes takes $\mathcal{O}(k(n\log n+m))$ time. The time complexity of the Dijkstra algorithm with time-dependent transit times for a graph with $n$ nodes and $m$ edges is $\mathcal{O}(n\log n+m)$. The only extra work performed by our algorithm consists of $\mathcal{O}(k\log k)$ pre-processing time for each node and $\mathcal{O}(k)$ time per edge for solving the FastLineDelivery problem, a total of $\mathcal{O}(nk\log k+mk)=\mathcal{O}(kn\log n+km)$ time. ∎

4 An Algorithm for Fast Line Delivery

In this section we present the solution to FastLineDelivery that was used as a subroutine in the previous section. We consider the setting of a single edge $e=\{u,v\}$ with end nodes $u$ and $v$. The objective is to deliver the package from node $u$ to node $v$ over edge $e$ as quickly as possible. In our illustrations, we use the convention that $v$ is drawn on the left and $u$ is drawn on the right. We assume that the package reaches $u$ at time $t$ (where $t$ is the earliest possible time when the package can reach $u$) while being carried by agent $i_{0}$.

As discussed in the previous section, let $A(v)=(a_{1},a_{2},\ldots,a_{\ell})$ be the list of agents arriving at node $v$ in order of increasing velocities and increasing arrival times. For $1\leq i\leq\ell$, denote by $t_{i}$ the time when $a_{i}$ reaches $v$, and by $v_{i}$ the velocity of agent $a_{i}$. We have $t_{i}<t_{i+1}$ and $v_{i}<v_{i+1}$ for $1\leq i<\ell$.

Let $B(u)=(b_{1},b_{2},\ldots,b_{r})$ be the list of agents with increasing velocities and increasing arrival times arriving at node $u$, starting with the agent $i_{0}$ whose arrival time is set to $t$. The list $B(u)$ can be computed from $A(u)$ in $\mathcal{O}(k)$ time by discarding all agents slower than $i_{0}$ and setting the arrival time of $i_{0}$ to $t$. For $1\leq i\leq r$, let $t_{i}^{\prime}$ denote the time when $b_{i}$ reaches $w$, and let $v_{i}^{\prime}$ denote the velocity of $b_{i}$. We have $t_{i}^{\prime}<t_{i+1}^{\prime}$ and $v_{i}^{\prime}<v_{i+1}^{\prime}$ for $1\leq i<r$.

As $k$ is the total number of agents, we have $\ell\leq k$ and $r\leq k$. In the following, we first introduce a geometric representation of the agents and their potential movements in transporting the package from $u$ to $v$ (Sect. 3) and then present the algorithm for FastLineDelivery (Sect. 4.2).

4.1 Geometric Representation and Preprocessing

Figure 2 shows a geometric representation of how agents $a_{1},\ldots,a_{\ell}$ move towards $u$ if they start to move from $v$ to $u$ immediately after they arrive at $v$. The vertical axis represents time, and the horizontal axis represents the distance from $v$ (in the direction towards $u$ or, more generally, any neighbor of $v$). The movement of each agent $a_{i}$ can be represented by a line with the line equation $y=t_{i}+{x}/{v_{i}}$ (i.e., the $y$ value is the time when agent $a_{i}$ reaches the point at distance $x$ from $v$). After an agent is overtaken by a faster agent, the slower agent is no longer useful for picking up the package and returning it to $v$, so we can discard the part of the line of the slower agent that lies to the right of such an intersection point with the line of a faster agent. After doing this for all agents (only the fastest agent $a_{\ell}$ does not get overtaken and will not have part of its line discarded), we obtain a representation that we call the relevant arrangement $\Psi$ of the agents $a_{1},\ldots,a_{\ell}$. In the relevant arrangement, each agent $a_{i}$ is represented by a line segment that starts at $(0,t_{i})$, lies on the line $y=t_{i}+{x}/{v_{i}}$, and ends at the first intersection point between the line for $a_{i}$ and the line of a faster agent $a_{j}$, $j>i$. For the fastest agent $a_{\ell}$, there is no faster agent, and so the agent is represented by a half-line. One can view the relevant arrangement as representing the set of all points where an agent from $A(v)$ travelling towards $u$ could receive the package from a slower agent travelling towards $v$.

The relevant arrangement has size $\mathcal{O}(k)$ because each intersection point can be charged to the slower of the two agents that create the intersection. It can be computed in $\mathcal{O}(k\log k)$ time using a sweep-line algorithm very similar to the algorithm by Bentley and Ottmann [6] for line segment intersection. The relevant arrangement is created by a call to PreprocessReceiver$(v)$ (see Algorithm 2).

For the agents in the list $B(u)=(b_{1},\ldots,b_{r})$ that move from $u$ towards $v$, we use a similar representation. However, in this case we only need to determine the lower envelope of the lines representing the agents. See Fig. 3 for an example. The lower envelope $L$ can be computed in $\mathcal{O}(k\log k)$ time (e.g., using a sweep-line algorithm, or via computing the convex hull of the points that are dual to the lines [10, Sect. 11.4]). The call PreprocessSender$(u,t)$ (see Algorithm 3) determines the list $B(u)$ from $A(u)$ and $t$ in $\mathcal{O}(k)$ time and then computes the lower envelope of the agents in $B(u)$ in time $\mathcal{O}(k\log k)$. When we consider a particular edge $e=\{u,v\}$, we place the lower envelope $L$ in such a way that the position on the $x$-axis that represents $u$ is at $x=l_{e}$. We say in this case that the lower envelope is anchored at $x=l_{e}$. Algorithm 3 creates the lower envelope anchored at $x=0$, and the lower envelope anchored at $x=l_{e}$ can be obtained by shifting it right by $l_{e}$.

4.2 Main Algorithm

Assume we have computed the relevant arrangement $\Psi$ of the agents in the list $A(v)=(a_{1},\ldots,a_{\ell})$ and the lower envelope $L$ of the lines representing the agents in the list $B(u)=(b_{1},b_{2},\ldots,b_{r})$.

The lower envelope $L$ of the agents in $B(u)$ represents the fastest way for the package to be transported from $u$ to $v$ if only agents in $B(u)$ contribute to the transport and these agents move from $u$ towards $v$ as quickly as possible. At each time point during the transport, the package is at the closest point to $v$ that it can reach if only agents in $B(u)$ travelling from $u$ to $v$ contribute to its transport. We say that such a schedule where the package is as close to $v$ as possible at all times is fastest and foremost (with respect to a given set of agents).

The agents in $A(v)$ can potentially speed up the delivery of the package to $v$ by travelling towards $u$, picking up the package from a slower agent that is currently carrying it, and then turning around and moving back towards $v$ as quickly as possible. By considering intersections between $L$ and the relevant arrangement $\Psi$ of $A(v)$, we can find all such potential handover points. More precisely, we trace $L$ from $u$ (i.e., $x=d(u,v)$) towards $v$ (i.e., $x=0$). Assume that $q$ is the first point where a handover is possible. If a faster agent $j$ from $A(v)$ can receive the package from a slower agent $i$ at point $q$ of $L$, we update $L$ by computing the lower envelope of $L$ and the half-line representing the agent $j$ travelling from point $q$ towards $v$. If the intersection point is with an agent $j$ from $A(v)$ that is not faster than the agent $i$ that is currently carrying the package, we ignore the intersection point. We then continue to trace $L$ towards $v$ and process the next intersection point in the same way. We repeat this step until we reach $v$ (i.e., $x=0$). The final $L$ represents an optimum solution to the FastLineDelivery problem, and the $y$-value of $L$ at $x=0$ represents the arrival time of the package at $v$. See Algorithm 4 for pseudo-code of the resulting algorithm.

An illustration of step 4 of Algorithm 4, which updates $L$ by incorporating a faster agent from $A(v)$, is shown in Fig. 4. Note that the time for executing this step is $\mathcal{O}(g)$, where $g$ is the number of segments removed from $L$ in the operation. As a line segment corresponding to an agent can only be removed once, the total time spent in executing step 4 (over all executions of step 4 while running Algorithm 4) is $\mathcal{O}(k)$.

Finally, we need to analyze how much time is spent in finding intersection points with line segments of the relevant arrangement $\Psi$ while following the lower envelope $L$ from $u$ to $v$. See Fig. 5 for an illustration. We store the relevant arrangement using standard data structures for planar arrangements [13], so that we can follow the edges of each face in clockwise or counter-clockwise direction efficiently (i.e., we can go from one edge to the next in constant time) and move from an edge of a face to the instance of the same edge in the adjacent face in constant time. This representation also allows us to to trace the lower envelope of $\Psi$ in time $\mathcal{O}(k)$.

First, we remove from $\Psi$ all line segments corresponding to agents that are not faster than $i_{0}$ (recall that $i_{0}$ is the agent that brings the package to node $u$ at time $t$). Then, in order to find the first intersection point $q_{1}$ between $L$ and $\Psi$, we can trace $L$ and the lower envelope of $\Psi$ from $u$ towards $v$ in parallel until they meet. One may observe that $L$ cannot be above the lower envelope of $\Psi$ at $u$ because otherwise an agent faster than $i_{0}$ reaches $u$ before time $t$, and that agent could pick up the package from $i_{0}$ before time $t$ and deliver it to $u$ before time $t$, a contradiction to $t$ being the earliest arrival time for the package at $u$. This takes $\mathcal{O}(k)$ time. After computing one intersection point $q_{i}$ (and possibly updated $L$ as shown in Fig. 4), we find the next intersection point by following the edges on the inside of the next face in counter-clockwise direction until we hit $L$ again at $q_{i+1}$. This process is illustrated by the blue arrow in Fig. 5, showing how $q_{2}$ is found starting from $q_{1}$. Hence, the total time spent in finding intersection points is bounded by the initial size of $L$ and the number of edges of all the faces of the relevant arrangement, which is $\mathcal{O}(k)$.

Theorem 3**.**

Algorithm 4 solves FastLineDelivery$(u,v,t)$ and runs in $\mathcal{O}(k)$ time, provided that PreprocessReceiver$(v)$ and PreprocessSender$(u,t)$, which take time $\mathcal{O}(k\log k)$ each, have already been executed.

Proof.

The claimed running time follows from the discussion above. Correctness follows by observing that the following invariant holds: If the algorithm has traced $L$ up to position $(x_{0},y_{0})$, then the current $L$ represents the fastest and foremost solution for transporting the package from $u$ to $v$ using only agents in $B(u)$ and agents from $A(v)$ that can reach the package by time $y_{0}$. ∎

Acknowledgments

Iago A. Carvalho was financed in part by the Coordenação de Aperfeiçoamento de Pessoal de Nível Superior - Brasil (CAPES) - Finance Code 001.