An FPTAS for Dynamic Multiobjective Shortest Path Problems

: The Dynamic Multiobjective Shortest Path problem features multidimensional costs that can depend on several variables and not only on time; this setting is motivated by ﬂight planning applications and the routing of electric vehicles. We give an exact algorithm for the FIFO case and derive from it an FPTAS for both, the static Multiobjective Shortest Path (MOSP) problems and, under mild assumptions, for the dynamic problem variant. The resulting FPTAS is computationally efﬁcient and beats the known complexity bounds of other FPTAS for MOSP problems.


Introduction
We consider in this paper the solution of the Dynamic Multiobjective Shortest Path (Dyn-MOSP) problem that generalizes the standard shortest path problem in two ways. First, each arc of the graph bears more than one attribute (e.g., length, duration, consumption...); this produces the (static) Multiobjective Shortest Path (MOSP) problem. Second, generalizing arc attributes to functions gives rise to the Dyn-MOSP problem. In it, each arc function is evaluated along a path in a dynamic (programming) fashion, i.e., a time dependent function is evaluated based on passed time, a consumption dependent function based on resource consumption etc. We will refer to all arc and path attributes simply as cost. The goal in MOSP problems and Dyn-MOSP problems is then to find paths from a source node to all other nodes in the input graph that are minimal w.r.t. their costs.
Our setting is motivated by Flight Planning Problems (FPP), in which optimal aircraft routes have to be determined in an airway network, considering multiple and dynamic optimization criteria. The most important scenario is the simultaneous minimization of flight time and fuel consumption. The flight time depends on the weather, in particular, the wind, which changes over time and hence depends on the flight time itself. Similarly, the fuel consumption depends on the weight of the aircraft and hence, again, on the consumption so far. Another application with similar dynamics is the routing of electric vehicles through mountainous terrains with varying traffic congestion. Here, the traffic depends on the time of day, and the battery's state of (dis)charge is non-linear.
In multiobjective optimization it is common to refer to optimal solutions using the terms efficient or Pareto optimal. Already the static MOSP problem is known to be intractable because of the possibly exponential cardinality of the solution set that, in this case, contains so called efficient paths (cf. Hansen [1]). This intrinsic difficulty of all multiobjective optimization problems can be circumvented by restricting attention to a polynomially sized subset of efficient solutions with an a priori bound on the quality loss w.r.t. the complete solution set. This idea lead to the development of Fully Polynomial Time Approximation Schemes (FPTAS) for MOSP problems in recent years (cf. Tsaggouris and Zaroliagis [2], Breugem et al. [3], or Bökler and Chimani [4]).
property. An extensive analysis of the implications of this condition on the solvability of single-objective Time-Dependent Shortest Path problems is given by Foschini et al. [21].

Outline
In Section 2, we formulate the Dyn-MOSP problem, and in Section 3, we explain how the Multiobjective Dijkstra Algorithm can be used to solve Dyn-MOSP instances if the arc cost functions fulfill the FIFO property. The analysis of the algorithm's asymptotic run time is done using a black-box dominance check whose complexity varies depending on the number of objectives and the partial order used to define minimality of paths. We use this abstract representation in Section 4 to introduce the new MD-FPTAS. It divides the outcome space of MOSP and Dyn-MOSP instances into polynomially many buckets, each of them allowing the storage of at most one path. The correctness of the resulting FPTAS is first proven for the case of static arc costs. Then, we derive a condition on dynamic arc cost functions that ensures that the MD-FPTAS also works for Dyn-MOSP instances. Finally, in Section 5 we test our algorithms against a state of the art FPTAS for the MOSP problem.

Multiobjective Shortest Path Problems
We start this section with a combinatorial definition of the Dyn-MOSP problem. Its components will be explained immediately afterwards.
Definition 1 (Dynamic Multiobjective Shortest Path Problem). Given a directed graph G = (V, A), a start node s ∈ V, an initial cost vector τ 0 ∈ R d ≥0 , a dimension d ∈ N, and an arc cost function c : A → F d (see Equation (1)), the d dimensional Dynamic Multiobjective Shortest Path Problem is to find either a minimum or a maximum complete set of efficient (s, v)-paths in G for all v ∈ V (which type of set is output depends on the partial order used to define the minimality of paths).

Graph terminology
We refer to the end-nodes of an arc a ∈ A as the tail and the head nodes of a. Given two nodes u, v ∈ V, a (u, v)-path in G is a sequence (a 1 , . . . , a k ), k ∈ N, of arcs such that u is the tail node of a 1 and v is the head node of a k . Additionally, the head node of a i coincides with the tail node of a i+1 for any i ∈ {1, . . . , k − 1}. We denote by p |l for any l ∈ {1, . . . , k} the leading subpath of p consisting of the first l arcs of p.

The arc cost function c
In a d-dimensional Dyn-MOSP instance I, each arc a ∈ A bears d independent real valued cost functions c a,i : R ≥0 → R ≥0 , i ∈ {1, . . . , d}; these will be used to propagate costs along the paths. The propagation can be described conveniently in terms of cost propagation functionsĉ a,i := id + c a,i : R ≥0 → R ≥0 , i ∈ {1, . . . , d}. Then, given a cost vector τ ∈ R d ≥0 , its cost component τ i is propagated along arc a to becomeĉ a,i (τ i ) := τ i + c a,i (τ i ), i ∈ {1, . . . , d}, and along path p = (a 1 , . . . , a k ) to become c i (p, τ i ) =ĉ a k ,i (ĉ a k−1 ,i (· · ·ĉ a 2 ,i (ĉ a 1 ,i (τ i )))), i ∈ {1, . . . , d}. Throughout this paper, we will consider paths starting at a source node s with arbitrary, but fixed, starting costs τ 0,i , i ∈ {1, . . . , d}; for such paths let us omit the starting costs τ 0,i from the notation and abbreviate c i (p, τ 0,i ) by c i (p).
Arc costs of this type arise in applications where multidimensional "state flows" evolve through a graph. For example, in the Flight Planning problem that we will discuss in Section 5.1, the costs τ v at a node v of a path p are interpreted as the aircraft state, i.e., a tuple consisting of the flight time, the fuel consumption, the distance etc. from the source node until v, andĉ v,w (τ v ) = τ v + c (v,w) (τ v ) are the costs (in this example, the aircraft state) at the successor node w of v in p. We use τ to denote the costs because one of the costs is typically time. Note also that in the static case, the arc cost functions are constant and hence, we can write c a,i instead of c a,i (τ).
If we denote by F the set of functions from R ≥0 to R ≥0 , we can denote the arc cost function c and the arc cost propagation functionĉ of I in vector and function notation by Then, given a cost vector τ ∈ R d ≥0 , the costs for traversing an arc a starting with costs τ at a's tail node are c a (τ) , and costs τ are propagated along arc a to becomeĉ a (τ) Let p be a (u, v)-path with k arcs that starts at u with costs τ ∈ R d ≥0 . Then the costs of any leading subpath p |l , l ∈ {2, . . . , k}, of p are recursively given by Finally, using p = p |k , the d-dimensional costs of path p starting with cost τ are denoted by c(p, τ), or, if the starting state τ is clear, by c(p). In the static case, the costs of p are c(p) := ∑ k j=1 c a j , where a j denotes the jth arc of p.

Efficiency of paths
In Multiobjective Optimization, optimal feasible solutions are called efficient solutions (cf. [6]). The feasible solutions to any MOSP instance are paths and hence, we seek to find efficient (s, v)-paths with initial costs τ 0 ∈ R d ≥0 for every v ∈ V. Efficiency is defined in terms of a (strict) partial order on R d ≥0 (cf. [5]). For our exact Multiobjective Dijkstra algorithm discussed in Section 3, we will use the following notion of efficiency and dominance: This definition carries over to the set of feasible paths in a natural way: given two (s, v)-paths p and q, p is said to D -dominate q (p D q) if and only if c(p) D c(q). An (s, v)-path is called D -efficient if it is not D -dominated by any other (s, v)-path. Note that the set of efficient cost vectors of a Dyn-MOSP instance I is unique. However, for every such point in R d ≥0 , there might be multiple efficient paths. The maximum complete set of efficient paths is the set that contains all paths whose cost vector is efficient, i.e., the set may contain paths with identical costs. If the widely used strict partial Pareto order is used to define dominance, the output of a Dyn-MOSP instance would be the maximum complete set. This order is the same as the one in Definition 2 but enforces that at least one of the inequalities is strict, hence not allowing x to dominate y if x = y. In this paper we compute the minimum complete set of efficient paths that is induced by D and allows exactly one efficient path per efficient cost vector. Example 1. Figures 1 and 2 show an example of a biobjective Dyn-MOSP instance and how the costs of two paths evolve through the corresponding graph. We assume that at the nodes u and v there are paths (red and green) ending with costs τ = (τ 1 , τ 2 ) and τ = (τ 1 , τ 2 ), respectively, and that these paths are now extended towards node x via node w. The plots to the left and in the middle show the costs for traversing the corresponding arc starting with costs τ and τ , respectively. After the extension along the arcs (u, w) and (v, w) both paths meet at node w with costs τ w =ĉ a 1 (τ) and τ w =ĉ a 2 (τ ). The plots on the right show the arc cost functions corresponding to the arc a 3 = (w, x). Furthermore, on the same diagram, the dominance relationship between both paths at w becomes clear since τ w,1 < τ w,1 and τ w,2 > τ w,2 . This means that none of the paths ending at w dominates the other one.  Figure 2.
τ w,2 Figure 2. These plots show the two arc cost functions corresponding to the three arcs of the graph in Figure 1: the leftmost functions correspond to the arc a 1 = (u, w); the functions in the middle to the arc a 2 = (v, w); the rightmost functions to the arc a 3 = (w, x).

The Multiobjective Dijkstra Algorithm for Dynamic MOSP Problems
In this section, we discuss Algorithm 1, an adaptation of the Multiobjective Dijkstra Algorithm (MD-A) presented in [16,17] that is extended here to work with dynamic costs. We will see that for the dynamics discussed in this paper, the solvability of MOSP and Dyn-MOSP instances mirrors the well known relationship from the single objective case: if a path p dominates a path p at a node v, their extensions inherit this dominance relationship. This characteristic of the cost functions is known as the FIFO property and defined formally in Section 3.2.

Description of the Algorithm
Whenever we use arrays in our algorithms, we will use an operator [·] to access its elements. To be able to do this on arrays that are indexed according to the nodes or the arcs of G, we assume that these have unique ids from 0 to |V| − 1 and from 0 to |A| − 1, respectively. Then, if for example ∆ is an array with one entry per arc in G, ∆[a] denotes the content of ∆ at the position specified by the id of the arc a ∈ A.

Paths and Labels
In Algorithm 1, paths are considered according to the lexicographically increasing costs. A point x ∈ R d ≥0 is said to be lexicographically smaller than a point y ∈ R d ≥0 (x < lex y) if and only if x i < y i in the first dimension i ∈ {1, . . . , d} in which x i = y i , and we say that a path p is lexicographically smaller than another path p if c(p) < lex c(p ). We will store paths using labels, i.e., by an implicit representation. Let p be an (s, v)-path (starting at s with costs τ 0 ) whose last arc is (u, v) ∈ A. The label corresponding to p is a tuple = (v, c := c(p), u ), where u is a pointer to the label representing the (s, u)subpath of p. Note that c =ĉ (u,v) (c u ), which, incurring in an abuse of notation that increases the readability, can be put as c =ĉ (u,v) ( u ). For every node v ∈ V the set L v contains the labels corresponding to the efficient (s, v)-paths found during the algorithm. We will see that the label sets L v will only increase; a label ∈ L v is therefore also called a permanent label. Additionally, a lexicographically sorted priority queue Q stores at most one tentative label per node. Tentative labels correspond to paths that have been explored during the algorithm but are not yet known to be efficient. For a node v, the label stored in Q corresponds to the lexicographically minimal (s, v)-path that has not yet been made permanent and is not dominated by any label in L v (we write L v D v ).

Algorithm 1: Multiobjective Dijkstra Algorithm (MD-A)
Blue code only for the MD-FPTAS described in Section 4.

Input
: . Additional FPTAS Input : Vector of approximation ratios ε ∈ R d−1 ≥0 . // The output is a minimum complete set in the exact scenario and a (1 + ε)-cover (see Section 4) if the algorithm is used as an FPTAS.

Output
: We present the pseudocode of Algorithm 1 in an abstract way, i.e., without specifying the partial order used to define dominance. Instead, we call a function BLACK_BOX_DOM that returns TRUE only if a newly found candidate path is dominated by the set of permanent paths at a node, i.e., if this set contains a path that dominates the candidate path. This allows us to use the same pseudocode for the exact algorithm presented in this section and for the MD-FPTAS presented in Section 4. Algorithms 2 and 3 show the function BLACK_BOX_DOM used for the exact MD-A.

Iterations
At the beginning, a tentative label init = (s, τ 0 , NULL) is inserted into Q. The main loop of the algorithm retrieves labels from Q; makes them permanent, possibly inserting new labels into Q for the node for which a label was retrieved; propagates their costs, possibly inserting new labels into Q for the successors of this node, and ends once Q becomes empty. Iterations start with the extraction of the lexicographically minimal label * v from Q, which is added to the end of L v since it is guaranteed to correspond to an efficient path. Since this is the only way labels are added to the lists L v , these sets are also sorted in lexicographically increasing order. The main trick in the algorithm is that the queue Q stores at any time at most one label for any node, namely, a lexicographically minimal one that is not dominated by any permanent label at the corresponding node. This makes the algorithm efficient by eliminating any search for non-dominated labels in Q-a tedious task that so far was common to all label setting MOSP algorithms in the literature.
After making * v permanent, each iteration pursues two main tasks. The first task is to find a new tentative label for v. This is necessary since the priority queue Q stores at most one label for node v at any time. If such a label exists, is not dominated by any label in L v and is lexicographically minimal among the labels gained from the extension of labels in L u , u ∈ δ − (v), along the arc (u, v) (see nextCan-didateLabel). This label l new v has to be built every time a label for v is extracted from Q; this is the price for storing at most one label per node. However, it is not necessary to traverse the entirety of the lists L u every time. Instead, labels in L u whose extension along (u, v) were already dominated at L v the last time a new label for v was built, do not have to be considered. To take advantage of this observation, we store the indices lastProcessedLabel(u, v) for any arc (u, v). These refer to the last checked position in L u when looking for a label for v and define where a search for v's next candidate label has to start. If a new label l new v for v is found, it is added to Q. The second task in each iteration is the propagation of * v along the outgoing arcs of v. The algorithm builds the and adds them to Q only if L w D w . If w is lexicographically smaller than w's current label in Q, the latter is replaced by w . In case there is no label for w in Q, w is just inserted into Q (see propagate).
Procedure nextCandidateLabel Blue lines only for the MD-FPTAS described in Section 4.
/* Only for MD-FPTAS. */ // Next time a label for v is searched in L u , the search starts where the current one ends.
Additionally, it has to be lex. minimal. Procedure propagate Blue lines only for the MD-FPTAS described in Section 4.

Input
: else if w is lex. smaller than w's heap label then 7 Replace w's label in Q with w ; ; /* This is a decrease_key operation on Q. */

return Q;
Example 2. Going back to the example shown in Figure 2, assume that the labels with costs τ at u and with costs τ at v are in the queue Q and τ < lex τ . Then, is extracted earlier from Q and in the same iteration, Procedure propagate is called to extend along the arc a 1 = (u, w) and obtain the tentative label w = (w, τ w =ĉ (u,w) (τ), ). We assume that no label for w exists, neither in Q nor in L w , and hence, w is added to Q. Suppose that in the next iteration of Algorithm 1, the label with costs τ at v is extracted. During its extension towards w in propagate, the label w = (w, τ w =ĉ (v,w) (τ ), ) is created. As we can see in the rightmost plot in Figure 2, τ w,1 < τ w,1 and hence, τ w < lex τ w . Since the conditions in Lines 3 and 6 of propagate are fulfilled, the label w is replaced by w , which becomes the new label for w in Q. This however does not discard w ! Some iterations later, w is extracted from Q and in the same iteration, nextCandidateLabel is called to build a new tentative label for w in Q out of the permanent labels of the predecessor nodes of w. It is in this search where w is found again and since it is not dominated (Line 8 of nextCandidateLabel) by any permanent label at w (currently L w only contains ), it is added to Q. Indeed, as shown in the rightmost plot in Figure 2, τ w D τ w and τ w D τ w meaning that both labels have to be added to L w . Later, the label with costs τ w is extracted from Q and finally made permanent. The extension of both labels towards x along (w, x) works in the same way.

Correctness
As noted in the beginning of the section, we require the arc cost functions c a,i , to fulfill the FIFO property: The correctness of Algorithm 1 relies on the Bellman-Principle [22] of optimality. In the context of MOSP problems, it states that an efficient (s, v)-path contains only efficient subpaths. Given that the arc cost functions are FIFO, Bellman's principle holds for efficient paths of the Dyn-MOSP problem. In particular, the following statement holds. Lemma 1. Given a Dyn-MOSP instance with FIFO arc cost functions, consider two (s, v)-paths p, p such that c(p) D c(p ). Then, for the extensions of p and p along a (v, w)-path q in G there holds c(p • q) D c(p • q).
Proof. Since c(p) D c(p ), we know that c j (p) ≤ c j (p ) for any j ∈ {1, . . . , d}. Due to the FIFO property of the arc cost functions, this implies that after q's first arc, say a ∈ A, there holds This argument can be repeated along every arc of q until we reach the paths' end point, The consequence of Lemma 1 is that during Algorithm 1, dominated labels/paths can be neglected since they will not become efficient later on. Hence, for a Dyn-MOSP instance whose arc cost function has the FIFO property in every dimension, Algorithm 1 computes a minimal complete set of efficient paths. The rest of the correctness proof proceeds along standard lines as in the static case (cf. [16,17]).

Complexity
The running time of Algorithm 1 is dominated by the running time of nextCandidate-Label and propagate, that both depend on the complexity of the oracle BLACK_BOX_DOM. It implements the dominance checks that are applied in the different versions of the MD-A that we discuss throughout the paper. In the exact biobjective algorithm, the dominance check (see Algorithm 2) can be implemented in constant time. The reason is that the sets L v are sorted in lexicographically increasing order and contain only efficient labels. Indeed, the first cost component is sorted in increasing order, while the second cost component is sorted in decreasing order. Thus, a new tentative label that is lexicographically greater than all elements of L v must only be compared with the last element. This observation seems to be not very widespread in the literature, but given the possibly exponential number of efficient paths at any node, the possibility of checking dominance in constant time has a big impact in theory and practice (cf. [16,17,23]). For d ≥ 3 the complexity is linear in the number of labels contained in L v , since in the worst case, the tentative label has to be compared with all existing ones (see Algorithm 3). In our analysis, we will denote the complexity of the dominance check, i.e., of the function BLACK_BOX_DOM, by C. We assume that Q is a Fibonacci-Heap [24] to get constant time complexity for the update and the insertion of labels. The label extraction is performed in O(log n), since the size of Q is at most n. We set N max := max v∈V |L v | to be the maximal number of labels at a single node at the end of the algorithm. N := ∑ v∈V |L v | is the total number of computed efficient labels.

Remark 1.
Note that we assume that the evaluation of the arc cost functions can be done in constant time. This is for example the case, when the functions are piecewise linear/constant and the breakpoints are distributed equidistantly. This assumption is common in the literature on Time-Dependent Shortest Paths problems. However, note that logarithmic running times have to be assumed if the breakpoints are spaced without regularity (binary search to find the neighboring breakpoints), or even worse complexities if the functions cannot be easily parametrized. Additionally, we assume that the dimension d of the problem is a constant.

Complexity of nextCandidateLabel
For a node v ∈ V nextCandidateLabel is called every time a label for v is made permanent, i.e., |L v | + 1 times. The use of the lastProcessedLabel pointers for every arc (u, v) ∈ A guarantees that the list L u of permanent labels at each predecessor node u of v is traversed exactly once. During each call, a dominance check between the extension along (u, v) of the considered predecessor labels and L v is performed. This results in a running time of which summing over all nodes v ∈ V, can be put as O(mN max C).

Complexity of propagate
In total, |L u | labels are propagated along an arc (u, v) ∈ A. Every time a label is propagated from u along (u, v), we have to check if the resulting label is dominated by any label in L v . Summing over all nodes, we get an overall complexity of Note that since Q contains at most one label per node, we can have constant time access (e.g., via a pointer) to a node's heap label. We make use of it in Lines 4 and 6 of propagate.
Algorithm 1 performs one iteration per permanent label, i.e., N iterations in total. In addition to nextCandidateLabel and propagate, a label is extracted in every iteration. All in all, the running time of Algorithm 1 is In Table 1, we list the complexity C of the dominance check for the different variants of the MD-A that we consider during the paper. It is clear that the space consumption of Algorithm 1 is O(N + m) if we assume that d is fixed. More in depth discussions of these running time bounds for the exact versions of Algorithm 1 can be found in [16,17]. Table 1. Complexity C of the dominance checks.

A New FPTAS for the Multiobjective Shortest Path Problem
In this section, we introduce the MD-FPTAS, a new FPTAS for MOSP problems. Basically the MD-FPTAS is Algorithm 1 with a new partial order on the cost vectors, i.e., with a new notion of efficiency. As used for the first time in [2], the main idea is to divide the outcome space into a polynomial number of cells, each of them holding at most one path. The correspondence of a path to a cell is defined via the path's cost vector. For ease of exposition, we will focus on the static version first. In Section 4.1, we show that the FPTAS also works on Dyn-MOSP instances if some extra assumptions are made about the arc cost functions.
Consider an α ∈ R d ≥1 and two (s, v)-paths p, q. Then, p α-covers q if c j (p) ≤ α j c j (q) for all j ∈ {1, . . . , d}. Let X be the set of all feasible paths of a (Dyn-)MOSP instance. A subsetX ⊆ X is an α-cover of X if and only if for any x ∈ X there is ax ∈X that α-covers x. If we denote the all-ones vector (initially in d dimensions) by 1, a Fully Polynomial Time Approximation Scheme (FPTAS) for the (Dyn)-MOSP problem is a family of algorithms that computes, for any ε > 0, a (1 + ε1)-cover of X . Furthermore, its space requirements and running time are polynomial in the size of the used instance as well as in 1 ε (note that we could define ε as a vector and get different approximation ratios for every component. However, this would not give deeper insights into the used techniques and is also not used in the experiments presented in Section 5). Additionally, we assume that ε ≤ 1 such that ln (1 + ε) = Θ(ε) and set c min As in the FPTAS presented in [2,3], ours is exact in one dimension. In our case, we choose the first cost component to be exact meaning that we compute a (1, 1 + ε1)-cover of X , with 1 ∈ R d−1 . The MD-FPTAS assigns a (d − 1)-dimensional tensor T v to each node v ∈ V. The entries of each tensor in the (j − 1) th dimension, j ∈ {2, . . . d}, are indexed from 0 to log r (nC j ) , for an approximation factor r = (1 + ε) (s, v)-path is stored in each entry of T v . With our choice of r, this guarantees the desired polynomial running time and space consumption.
The bound on the space consumption can be derived from the size of T v : the length of T v,j becomes n ε log(nC j ) for any node v ∈ V and j ∈ {2, . . . , d} such that, in total, T v stores at most ∏ d i=2 |T v,i |, a term that is polynomial in the size of the graph and in 1 ε . If we allow our FPTAS to only store one (simple) path per entry in the vector, we guarantee the polynomial space consumption of the MD-FPTAS. The position of a (s, v)-path p ∈ X in T v is computed using the function pos : This justifies the size of the tensors since efficient (simple) paths have at most (n − 1) arcs and hence, c j (p) ≤ (n − 1)c max j .
We incorporate the subdivision of the outcome space into Algorithm 1 and, in particular, into the dominance checks made therein. To do so, we consider the blue parts in the pseudocodes from Section 3. In the MD-FPTAS any label representing a path p additionally stores pos(c(p)) = pos (c ). For ease of exposition, we will write pos(p) and pos( ) from now on. Labels continue to be sorted lexicographically in the priority queue Q but the dominance checks are done using the labels' pos values: if two distinct labels , at a node v ∈ V fulfill c ,1 ≤ c ,1 and pos j ( ) ≤ pos j ( ) for j ∈ {2, . . . d}, we say that pos -dominates and write pos . The new checks are shown in Algorithms 4 and 5. No further modifications w.r.t. Algorithm 1 are needed to obtain the MD-FPTAS from the MD-A. Hence, the MD-FPTAS makes labels permanent after extracting them from the heap. It is guaranteed that at the moment of extraction of a label v at a node v ∈ V, there is no label v in L v such that v pos v and thus, no two labels with the same pos values will be stored, i.e., nextCandidateLabel and propagate.
pos v then return TRUE; 3 return FALSE The following example shows how efficient labels can be rejected by the MD-FPTAS if they are pos -dominated by permanent labels. Figure 3 visualizes the situation at the end of each of three subsequent iterations of MD-FPTAS. As in Examples 1 and 2, the illustrated graph is a subgraph of a larger graph with n = 10 nodes and we set ε = 0.5. To illustrate how our FPTAS works, dynamic arc cost functions are not needed. Instead, each arc has d = 2 static cost components. Labels are represented only by their cost vector; their correspondence to nodes is made clear by their positioning. The example starts with a permanent label with costs (80, 131) at node x and tentative labels for u and v in Q with costs (100, 100) and (100, 101), respectively.

Example 3.
In the first iteration, the label for u is extracted from Q and no new candidate label for u is found. Then, during the propagation of the label (100, 100), the resulting label with costs (120, 120) at node w is inserted into Q. In the second iteration, the label with costs (101, 100) is extracted from the heap and no new candidate label for v is found. This label is then propagated to node w, where the resulting tentative label with costs (140, 119) is rejected, as w's current heap label has costs (120, 120) and is lexicographically smaller. So far, the MD-A and the MD-FPTAS would have done exactly the same. In the third iteration, the label with costs (120, 120) at node w is extracted from the heap. When nextCandidateLabel is called, the extension of v's permanent label towards w yields costs (140, 119). Hence, it would not be dominated by the new permanent label with costs (120, 120) at w in the exact scenario. However, in the MD-FPTAS, it is rejected since 120 < 140 and pos(120) = 107 = pos(119). The iteration continues and considers the tentative label with costs (130, 130) at node x. It is also rejected despite it would be made permanent in the exact scenario, since 80 < 130 and pos(130) = 109 = pos(131).  The following Lemma holds for any version of Algorithm 1 presented so far. We need it to prove the correctness of the MD-FPTAS. We denote the set of permanent labels at node v found until iteration i ∈ {1, . . . , N } (including the i th iteration) by L i v . Thus, L v ≡ L N v is used only to denote the final set of permanent labels at v.

Lemma 2.
A label v for a node v ∈ V is considered at most |L v | + 1 times before it is made permanent or finally discarded. If it is discarded, there is a permanent label in L v that (pos-)dominates v .
Proof. Let u be the permanent predecessor label of v at node u ∈ δ − (v). v is considered for the first time during a call to propagate in the iteration i ∈ {1, . . . , N } in which u is extracted from H and added to L i u . Let k ∈ {i + 1, . . . , N } be the next iteration wherein a label v for node v is extracted from Q. If v = v , we are done since v was considered just once before it is made permanent. In case v = v , v was either rejected in iteration i because a lex. smaller label for v existed in Q or v was replaced in Q by a lex. smaller label for v (Line 7 of propagate) that was not (pos -)dominated by any permanent label at v. Note that multiple such updates to v's heap label could have happened until v is extracted and made permanent. The k th iteration proceeds with a call to nextCandidateLabel, where at least one permanent label per predecessor node of v is considered. Since the current iteration is the first time that nextCandidateLabel is called for v since l u 's insertion, lastProcessedLabel(u, v) points at a label in L k u that is not after l u . We want to prove an upper bound on the number of times that v is considered, so we assume w.l.o.g. that u is considered during the current search for v's new label in Q, i.e., lastProcessedLabel(u, v) advances at least until u 's position in L k u . Hence, u is extended along the arc (u, v), generating v as a candidate to enter Q in iteration k. According to Line 8 in nextCandidateLabel, lastProcessedLabel(u, v) is increased if there is a label in L k v that (pos-)dominates v . If this happens, later searches for a new tentative label for v no longer consider u as a possible predecessor label and hence, ignore v . In case L k v D v , lastProcessedLabel(u, v) will not be altered and the next search for a new tentative label for v will consider v again. Since such searches only happen when a label for v is made permanent, v will be considered at most |L v | times during calls to nextCandidateLabel.
The following theorem proves the correctness of the MD-FPTAS for the static case. Its proof is similar to the one given in [3]. Recall that efficient paths can have at most n − 1 arcs since the arc cost functions are positive. Theorem 1. Consider a node v ∈ V and an efficient (s, v)-path p * = (a 1 , . . . , a k ). Then, the MD-FPTAS finds an (s, v)-pathp s.t. c(p) ≤ r k c(p * ).
Proof. We prove the statement by induction over k, the number of arcs of p * . W.l.o.g. we assume that no parallel arcs exist in G. In the base case, we consider an efficient single-arc path p * = ((s, v)). In the first iteration of Algorithm 1, the label * corresponding to p * will be added to Q during propagate. Consider the first iteration in which a label for node v is extracted from Q. If = * , we are done since * itself is made permanent. In case = * , Lemma 2 implies that * will be made permanent later or be discarded. If it is discarded, Algorithms 4 and 5 guarantee the existence of a permanent label˜ ∈ L v corresponding to an (s, v)-pathp such that and pos(p) ≤ pos(p * ).
For j ∈ {2, . . . , d}, we can derive log r (c j (p)) − 1 ≤ log r (c j (p * )) from (6b) and this in turn can be restated as c j (p) ≤ rc j (p * ), which, coupled with (6a), proves the statement. In the induction hypothesis, we assume that holds for any k ∈ {2, . . . n − 1} and efficient paths p * with k − 1 arcs. Induction Step: Let p * be an efficient (s, v)-path with k arcs and let (u, v) be its last arc. Due to subpath efficiency, the (s, u)-subpath p * u of p * is efficient. In addition, the induction hypothesis guarantees the existence of a pathp u with corresponding permanent label˜ u such that (7) holds forp u and p * u . When˜ u is extracted and made permanent, the label := (v, c˜ u + c (u,v) ,˜ u ) is analyzed in propagate. For the (s, v)-pathp corresponding to˜ , we have From the proof of the base case and from Lemma 2, we know that˜ is going to either be made permanent in a later iteration or be discarded. In case˜ is made permanent, we have c(p) ≤ r k−1 c(p * ) ≤ r k c(p * ) and we are done. If˜ is discarded, there exists a permanent label ∈ L v corresponding to an (s, v)-path p such that c 1 (p) ≤ c 1 (p) and pos(p) ≤ pos(p). The latter inequality implies c j (p) ≤ rc j (p) for j ∈ {2, . . . , d} and, for j = 1, c 1 (p) ≤ rc 1 (p) is trivially given. Combining this with Euqation (8), we get which finishes the proof.

FPTAS for Dyn-MOSP Problems
From now on we restrict the set F of arc cost functions in Dyn-MOSP instances to contain only continuous, piecewise linear FIFO functions. In this case, the proof of Theorem 1 works if the intercepts of the affine functions describing the pieces of the arc cost functions are non-negative. Note that in the proof of Theorem 1 we needed the arc cost vectors only in Equation (8).
Using the notation for dynamic cost, what needs to hold is To prove the following Lemma, we consider a function f ∈ F with k ∈ N breakpoints and describe the affine functions that build the pieces of f by aff i (x) := a i x + b i , i ∈ {1, . . . , k − 1}.
Lemma 3. Let f ∈ F be a piecewise affine function with k ∈ N breakpoints and α ∈ R >1 a constant. Then, for points x, y ∈ R ≥0 with x ≤ αy there holds x + f (x) ≤ α(y + f (y)) if the intercepts b i of the affine functions building f are non-negative for all i ∈ {1, . . . , k − 1}.

Proof.
We consider three different cases to prove the statement.
Case 1: Together with x ≤ αy this proves the statement.
Case 2: x < y and f (x) ≥ f (y). In this case, the FIFO property and α > 1 can be used to get: Case 3: y < x and f (x) > f (y). Let aff i be the affine function with aff i (y) = f (y) and aff j the one with aff j (x) = f (x). There holds i ≤ j and we define aff l , l ∈ {i, . . . , j}, to be the affine function corresponding to the steepest piece of f between y and x, i.e., the one with the biggest a l . This choice implies f (x) ≤ aff l (x) and aff l (y) ≤ f (y). Additionally, as for any affine function with positive intercept we have aff l (αy) ≤ α(a l y + b l ) = α aff l (y). All in all, we can conclude Together with x ≤ αy this proves the statement. Now we set c (u,v),j = f , c j (p) = x, c j (p * ) = y, and r k−1 = α to get that Equation (9) holds under the given assumptions. This enables us to formulate our main Theorem: Theorem 2 (FPTAS for Dyn-MOSP problems). Let I be a Dyn-MOSP instance with continuous piecewise linear and positive arc cost functions that fulfill the FIFO property. Additionally, for any arc a ∈ A let the functions c a,j , j ∈ {2, . . . , d} have only non-negative intercepts. Then, the MD-FPTAS computes a (1 + ε)-cover of the minimum complete set of efficient paths for I computed by the MD-A.
Proof. The proof is analogous to that of Theorem 1 using Equation (9) instead of Equation (8) in the induction step.

Complexity of the MD-FPTAS
In this section, we set C := max j∈{2,...,d} C j . Then, each tensor T v can store at most T := ( n ε log(nC) ) d−1 paths and when analyzing the MD-FPTAS in terms of N max and N as in Section 3, we get Recall that the lists L v contain permanent labels that are sorted in lexicographically increasing order. In the biobjective case this implies that they will be sorted increasingly according to the first cost component and simultaneously, decreasingly w.r.t. their pos value (Note that for d = 2, pos(·) maps to R ≥0 so it is well defined to talk about a label's pos value). There are two reasons for this. On one hand we have the monotonicity of the log function and on the other hand, the already discussed fact that for d = 2 efficient labels that are sorted lexicographically have an increasing second cost component. Hence, as in the exact case, the complexity C of the pos -dominance checks (Algorithms 4 and 5) is constant in the biobjective case and linear (O(T )) for d ≥ 3. Table 2 shows the time complexity of the different FPTAS for the MOSP problem that we are discussing in this paper. , and T denotes the size of the tensors T v , i.e., the max. number of paths to be stored at each node.

Storing Tensors Explicitly
While the complexity of the MD-FPTAS is lower than that of the Martins-FPTAS, the FPTAS presented in [2] (TZ-FPTAS) is yet to be undercut. This algorithm works similar to the well known Bellman Ford algorithm for the One-to-All Shortest Path Problem and stores the tensor T v for every node v ∈ V. In iteration i ∈ {1, . . . , n − 1}, the algorithm computes (s, v)-paths with at most i edges and does no proper dominance check. Instead, for a newly found path p, the entry pos (p) in T v is checked: if it is empty, p is added; if a path already exists, only the one with the lowest costs in the exact dimension (in [2] it is the dth one) is kept. Since the dominance checks are costly, storing the tensors T v and checking only the current position yields a great advantage when it comes to the algorithmic complexity.
We can adapt the MD-FPTAS such that at every node a tensor T v is stored. The entries of T v are 0 or 1 depending on whether a path with the corresponding pos value has already been stored in L v . Let v be a tentative label for a node v computed in Line 6 of nextCan-didateLabel or in Line 2 of propagate. Instead of calling the function BLACK_BOX_DOM, we check if T v [pos ( v )] == 0. In case the tensor entry is indeed set to 0, we add v to L v and set T v [pos ( v )] = 1. If the tensor entry is set to 1, we neglect v since there is a lex. smaller label in L v with the same pos than v , hence pos -dominating v .
The suggested adaption increases the space complexity of the MD-FPTAS. Moreover, in general, it will compute more labels than before since checking dominance using pos is more restrictive than checking pos -equality. However, as in the TZ-FPTAS, the construction of the tensors T v still guarantees that the number of paths and iterations stays polynomially bounded. As a consequence, the running time of this variant of the MD-FPTAS for d ≥ 3 objectives becomes O((nlogn + m)T ).
As shown in Table 2, this is the best known running time bound for an FPTAS for MOSP problems.

Computational Results
In this section we provide evince the computational efficiency of the MD-FPTAS in comparison to Martins-FPTAS as presented in [3]; the latter turned out to be faster than the TZ-FPTAS of [2]. Martins-FPTAS is based on the classical label setting algorithm for the MOSP problem by Martins [15]. The data structures are similar to those of the MD-FPTAS. Instead of having at most one label per node in the priority queue, it stores all tentative labels therein until they are extracted or deleted because a label entering the queue dominates them. This iteration through the queue to possibly delete labels is more costly than the searches for a node's next candidate label performed in the MD-FPTAS. Table 2 shows the complexity of Martins-FPTAS.

Test Instances
We perform experiments considering 2 and 3 objective functions. In the biobjective static case we use the same instances that were used in [3]. The first group of such instances consists of graphs that contain only efficient paths. These graphs were first described in [1] and are suitable to check the impact of the used approximation techniques (see Figure 4).
. . . We call these instances EXP; the corresponding graphs have 3 to 51 nodes. The second group of instances, denoted by GRID, are 33 undirected grid graphs of varying size. All instances within GRID have a number of nodes that varies between 1202 and 40,002 and a number of arcs that varies between 4720 and 159,600. The search starts at an artificial node connected to all nodes in the first column of the grid. The costs on the arcs are generated randomly between 0 and 10. The third group of instances are 15 so called NetMaker graphs. They have 3000 nodes and between 30,000 and 80,000 arcs. The source node is always the node with id 0. Both the GRID and NET instances were first used in [25].
In the 3-dimensional case, we consider a subset of the instances used in [17]. The first set of instances are again NetMaker graphs with an extra cost component. These NET3D instances have 5000 to 15,000 nodes and 40,045 to 344,189 arcs. In total, we consider 35 such graphs. Again, the source node is always the one with id 0. We also consider grids with 3 objectives. The undirected 100 × 100 grid graph remains unchanged among all instances; we consider 10 different 3-dimensional arc cost functions. These instances are the only ones for which we consider a One-to-One scenario. Trying to solve the One-to-All MOSP problem on these grids was not possible without violating the time limit. Hence, we added the pruning techniques for One-to-One MOSP instances described in [17] to Algorithm 1. It is easy to see that they are compatible with the approximation techniques used in this paper. In total, the GRID − 3D instance set contains 300 One-to-One MOSP instances with varying L 1 norm between the source and the target node.
The last test instance is a Dyn-MOSP instance motivated by the Horizontal Flight Planning Problem (HFPP) introduced in [26,27]. The directed graph in this instance has 410, 387 nodes and 878, 902 arcs and is called an airway network. The arcs are the direct connections between pre-defined coordinates (the graph's nodes) along which commercial aircraft are allowed to fly (on www.skyvector.com Sky-Vector an airway network can be displayed). We define two cost functions on each arc. The first one encodes the duration of the traversal of an arc depending on the time point at which the tail of the arc is reached. The duration is influenced by weather conditions and we evaluate the weather information we have every 3h to get 10 data points per arc. The second function models the aircraft is fuel consumption along an arc depending on the aircraft is weight at the arc's tail node. In our model we get 171 initial weights per arc and the corresponding consumption for each weight. The difference between two consecutive weights is 500 kg. In both functions, datapoints are interpolated linearly, hence obtaining two continuous piecewise linear functions. The single pieces of the duration function can have positive or negative slopes depending on the wind but the FIFO property still holds as shown in [26]. The consumption function yields an always positive slope since clearly, a higher initial weight will cause a higher consumption. It is therefore also FIFO and, more importantly, the intercepts of its affine pieces are positive, hence fulfilling the requirements from Lemma 3. In total, we have randomly chosen 380 airports as the initial nodes s and compute the (pos )-efficient paths to all nodes reachable with the full tank of a long-haul aircraft.

Results
The experiments were ran on a machine with an Intel Xeon CPU E5-2670 v2 @ 2.50 GHz processor. It has two CPUs per node and 10 cores per CPU. The available RAM was 128 GB. All algorithms were implemented in C and compiled with the version 7.5 of the GCC compiler with compiler optimization level set at 03. For the priority queues, we used our own implementation of a binary heap. The only difference between the heaps used for the implementations of Martins's algorithm and those used in the implementations of the MD algorithms is that in the former we took extra care of guaranteeing fast access to a node's heap labels. This is needed because every time a label for a node v is added to Q, labels for v in Q that are dominated by the new one have to be removed. All lists of permanent labels are modelled as arrays, allowing all algorithms to share the code used for the dominance checks. We set a time limit of 5400 s for all algorithms. Whenever we report averages, we consider instances that were solved by all algorithms involved in the comparison. The min and max values consider only the results obtained by single algorithms. Table 3 summarizes the results of the biobjective MOSP instances. On average, the BDA is 3450 times faster than Martins's algorithm in the EXP instance set. The average number of permanent labels on these instances is 338, 611 and the maximum is 1, 572, 862. We computed (1 + ε)-covers for the EXP instances with different values for ε and the average speedup decreases steadily as ε grows: ×30 for ε = 0.05, ×2.4 for ε = 0.5, and ×1, 84 for ε = 1. This is because 1.10%, 0.17%, and 0.11% of the labels from the exact solution sets are computed for the mentioned ε values.  Figure 5 gives a visual impression of the running times: on the left hand side we compare the BDA with the FPTAS-BDA and notice how the solution time of the exact algorithm grows exponentially with the number of computed paths. The FPTAS is not faster than the exact algorithms when the number of labels is similar, but on the bigger EXP graphs it saves a lot of labels. On the right hand side we compare the Martins-FPTAS and the BDA-FPTAS. We can see that the running time growth of the BDA is much slower. The biobjective GRID and NET instances unveil the major drawback of the used approximation techniques: on graphs with a realistic/practical amount of nodes, the value of r = (1 + ε) 1 n−1 is very close to 1 and the pos values of any two different paths are almost always distinct. Hence, the exact algorithms are faster than the FPTAS since the computation time of pos is non negligible in practice and no labels are saved. In [3] the authors overcome this problem by choosing huge values for ε. Then, they compute an a posteriori approximation that always turns out to be much better than ε but there is no guarantee for it. Instead, we focus on values for ε that are consistent with the assumption ε ≤ 1 that we made in Section 4. The consequence is indeed that the average FPTAS speedup for ε = 0.05 on GRID is ×1.66 and on NET instances it is ×3.23, i.e., in both cases a slowdown. On both instance sets the FPTAS solutions contained almost all exact solutions and even increasing ε up to 1 did not have a noteworthy impact. All algorithms were able to solve all instances in these two sets within the time limit. Figure 6 compares both FPTAS and consolidate the impression gained from the EXP instances: the running time advantage of the MD-FPTAS gets bigger as the number of efficient paths grows.

Static Three Objective Results
Instances with three objectives are much harder to solve. In Table 4, we summarize the results obtained from the One-to-One queries ran on GRID3D instances and from the One-to-All queries ran on NET3D instances. We observe the same behavior as in the 2D instances: a solid running time advantage for the MD-FPTAS on average (×1.70 on GRID3D instances and ×1.46 on NET3D instances) for ε = 0.05 but slower running times than in the exact counterparts. In these experiments all algorithms always computed always the same amount of labels per instance. Figure 7 shows the comparison of both FPTAS' running times depending on the number of computed paths. In both instance sets the Martins-FPTAS failed to solve bigger instances within the time limit. The overall trend mirrors the biobjective results as the running time of the MD-FPTAS grows considerably slower than that of the Martins-FPTAS.

Our Implementation of Martins's Algorithm
Note that our implementation of Martins's (exact) Algorithm and of the Martins-FPTAS is competitive compared to other relevant publications. For example, our biobjective implementation is up to ×10 5 faster than the one used in [3] when solving EXP instances. We believe that the reason is that-as already mentioned-we are using a constant time dominance check in the biobjective case. However, an in depth comparison of the performance of both implementations is not possible: we restricted ourselves to instances that use an approximation factor ε ≤ 1. This matches the assumption that we made in Section 4 to ensure that (1 + ε) = Θ(ε).
The direct comparison of our implementation of Martins's algorithm with the one used in [4] is even harder because the used instances do not coincide. However, the authors try to use C + + vectors whenever possible and use a lexicographically sorted binary heap to store the tentative labels. These choices are similar to ours (we use C arrays) and the reported running times on instances with three cost components are comparable to ours. In Table 5, we depicted some geographically distant departure airports and show the impact of the FPTAS when computing routes to all reachable nodes. We finish our computational experiments showing the least consumption and fastest routes from Berlin to Yekaterinburg in Figure 9. Even though consumption and time are correlated objectives, this example shows that both have to be considered since the routes vary considerably.

Conclusions
We have proven that Dynamic Multiobjective Shortest Path (Dyn-MOSP) problems can be solved by a generalization of the static Multiobjective Dijkstra Algorithm (MD-A) if the arc cost functions are FIFO and have independent dynamics (e.g., weight and time; time and state of charge). Our main contribution was to adapt the techniques used in the seminal work by Tsaggouris and Zaroliagis [2] to derive a new FPTAS for MOSP problems that is based on the label setting MD-A. The running time of the resulting MD-FPTAS is the number of computed paths multiplied by the running time of the classical Dijkstra algorithm and is thus-to the best of our knowledge-the most efficient FPTAS for MOSP problems in the literature. Even better, it also works for Dyn-MOSP instances if the arc cost functions are FIFO, continuous, and piecewise linear, having only positive intercepts. These requirements are not very restrictive in practice.
We corroborated the theoretical efficiency of our algorithms computationally. On a test set of standard bidimensional and 3-dimensional instances, our MD-FPTAS was faster than the Martins-FPTAS introduced by Breugem et al. [3]. In the static case, we faced the same problem as the authors in [2,3]: the FPTAS does not avoid the computation of paths unless ε is chosen very large. The reason is that, so far, most instances used in the literature to test MOSP algorithms have integer costs, causing efficient cost vectors to lie at least one cost unit apart from each other. In Dyn-MOSP instances the evaluation of continuous, piecewise linear functions is likely to generate labels with rational cost. This is the case in the Flight Planning instances that we considered. Furthermore, indeed, using realistic values for ε, we computed (1 + ε)-covers for these instances and saved 21% in terms of running time and 35% in terms of labels.