On the Enumeration and Counting of Bicriteria Temporal Paths

TL;DR

This paper explores the complexity of enumerating and counting efficient bicriteria paths in weighted temporal graphs, providing polynomial algorithms for enumeration and Pareto set computation, but proving counting is #P-complete.

Contribution

It introduces polynomial-time algorithms for enumerating and identifying Pareto-optimal paths in weighted temporal graphs with positive or nonnegative costs, and proves counting is #P-complete.

Findings

Polynomial delay enumeration of efficient paths with positive costs

Polynomial-time computation of Pareto-optimal solutions with nonnegative costs

Counting efficient paths is #P-complete

Abstract

We discuss the complexity of path enumeration and counting in weighted temporal graphs. In a weighted temporal graph, each edge has an availability time, a traversal time and some real cost. We introduce two bicriteria temporal min-cost path problems in which we are interested in the set of all efficient paths with low cost and short duration or early arrival time, respectively. However, the number of efficient paths can be exponential in the size of the input. For the case of strictly positive edge costs we are able to provide algorithms that enumerate the set of efficient paths with polynomial time delay and polynomial space. If we are only interested in the set of Pareto-optimal solutions and not in the paths themselves, then these can be determined in polynomial time if all edge costs are nonnegative. In addition, for each Pareto-optimal solution, we are able to find an efficient path in polynomial time. On the negative side, we prove that counting the number of efficient paths is #P-complete, even in the non-weighted single criterion case.

Equations

$$a(P_{s,z})\in \{\alpha \mid \alpha :=t_e+{\lambda }_e\text{ with }e=(u,z,t_e,{\lambda }_e,c)\in {\delta }^{-}(z)\}\text{.}$$

$$E_{\tau }:=\{(u,v,i,1)\mid (u,v)\in E,1\le i\le \tau \}\cup \{(t,z,n,1)\}\text{,}$$

Full text

1 Introduction

A weighted temporal graph $G=(V,E)$ consists of a set of vertices and a set of temporal edges. Each temporal edge $e\in E$ is associated with an edge cost and is only available (for departure) at a specific integral point in time. Traversing an edge takes a specified amount of traversal time. We can imagine a temporal graph as a sequence of $T\in\mathbb{N}$ graphs $G_{1},G_{2},\ldots,G_{T}$ sharing the common set of vertices $V$, and each graph $G_{i}$ has its own set of edges $E_{i}$. Therefore, $G$ can change its structure over a finite sequence of integral time steps.

Given a directed weighted temporal graph $G=(V,E)$, a source $s\in V$ and a target $z$111We use $t$ to denote time steps and $z$ for the target vertex.$\in V$, our goal is to find earliest arrival or fastest $(s,z)$-paths with minimal costs. A motivation can be found in typical queries in (public) transportation networks. Here, each vertex represents a bus stop, metro stop or a transfer point and each edge a connection between two such points. In this model, the availability time of an edge is the departure time of the bus or metro, the traversal time is the time a vehicle takes between the two transfer points, and the edge cost represents the ticket price. Two natural occurring problems are the following: (1) Minimize the costs and the arrival times, or (2) minimize the costs and the total travel time.

In general, there is no path that minimizes both objectives simultaneously, and therefore we are interested in the set of all efficient paths. A path is called efficient if there is no other path that is strictly better in one of the criteria and at least as good concerning both criteria. In other words, a path is efficient iff its cost vector is Pareto-optimal.

McfEnum and MceaEnum denote the enumeration problems, in which the task is to enumerate exactly all efficient paths w.r.t. cost and duration or cost and arrival time, respectively. We show, that there can be an exponential number of efficient paths. So one cannot expect to find polynomial time algorithms for these problems. However, Johnson, Yannakakis, and Papadimitriou [12] have defined complexity classes for enumeration problems, where the time complexity is expressed not only in terms of the input size but also in the output size. We use the output complexity model to analyze the proposed enumeration problems and show that they belong to the class of polynomial time delay with polynomial space (PSDelayP). If we are only interested in the sets of Pareto-optimal solutions and not the paths themselves, we show that these problems can be solved in polynomial time for nonnegative edge weights. In these cases, we can also provide an associated path with each solution. On the negative side, we show that counting the number of efficient paths is not easier than their enumeration, i.e., determining the number of efficient paths is hard.

Contribution – In this paper we show the following:

McfEnum and MceaEnum are in PSDelayP for weighted temporal graphs with strictly positive edge costs. 2. 2.

In case of nonnegative edge costs, finding the Pareto-optimal set of cost vectors is possible in polynomial time (thus the set of Pareto-optimal solutions is polynomially bounded in the size of the input), and for each Pareto-optimal solution we can find an efficient path in polynomial time. 3. 3.

The decision versions that ask if a path is efficient, are in P. Deciding if there exists an efficient path with given cost and duration or arrival time is possible in polynomial time. 4. 4.

The counting versions are #P-complete, even for the single criterion unweighted case.

Our paper has the following structure. In the remainder of this section we discuss the related work. In Section 2 we provide all necessary preliminaries. Next, in Section 3 structural results are presented. These are the foundation of the algorithms for McfEnum and MceaEnum in the following Sections 4 and 5, respectively. Section 6 discusses the complexity of counting efficient paths. Finally, in Section 7 conclusions are drawn and we state further open problems.

Related Work – Temporal graphs and related problems are discussed in several recent works. For a general overview there are a number of nice introductions, e.g., [3, 10, 11, 14]. An early work on graphs with time-depended travel times is from Cooke and Halsey [4], in which they provide a generalized formulation for the Bellman iteration scheme [2] in order to support varying travel times. Kempe et al. [13] analyze connectivity problems with respect to temporal paths. Xuan et al. [21] discuss communication in dynamic and unstable networks. They introduce algorithms for finding a fastest path, an earliest arrival path and a path that uses the least number of edges. Wu et al. [20] further discuss the fastest, shortest and earliest arrival path problems in temporal graphs and introduce the latest-departure path problem. Their algorithm for calculating an earliest arrival $(s,v)$-path has time complexity $\mathcal{O}(n+m)$ and space complexity $\mathcal{O}(n)$, where $n$ denotes the number of vertices and $m$ the number of edges in the given temporal graph. Furthermore, they present an algorithm that finds a fastest $(s,v)$-path in $\mathcal{O}(n+m\log c)$ time and $\mathcal{O}(\min\{n\cdot\mathcal{S},n+m\})$ space. Here, $\mathcal{S}$ is the number of distinct availability times of edges leaving vertex $s$, and $c$ the minimum of $\mathcal{S}$ and the maximal in-degree over all vertices of $G$. The algorithm uses a label setting approach to find a fastest $(s,v)$-path for each $v\in V$. Both, [21] and [20], consider only non-weighted temporal graphs.

Hansen [9] introduces bicriteria path problems in static graphs, and provides an example for a family of graphs for which the number of efficient paths grows exponentially with the number of vertices. Meggido shows that deciding if there is an path that respects an upper bound on both objective functions is NP-complete (Meggido 1977, private communication with Garey and Johnson [7]). Martins [15] presents a label setting algorithm based on the well known Dijkstra algorithm for the bicriteria shortest path problem, that finds the set of all efficient $(s,v)$-paths for all $v\in V$. Ehrgott and Gandibleux [6] provide a good overview of the work on bi- and multicriteria shortest path problems. Hamacher et al. [8] propose an algorithm for the bicriteria time-dependent shortest path problem in networks in which edges have time dependent costs and traversal times. The traversal time of an edge is given as a function of the time upon entering the edge. Moreover, each edge has a two-dimensional time dependent cost vector. Waiting at a vertex may be penalized by additional bicriteria time dependent costs. They propose a label setting algorithm that starts from the target vertex and finds the set of all efficient paths to each possible start vertex. Disser et al. [5] discuss a practical work on the multi-criteria shortest path problem in time-dependent train networks. To this end, they introduce foot-paths and special transfer rules to model realistic train timetables.

We are not aware of any work discussing the enumeration or counting of the set of efficient paths in weighted temporal graphs.

2 Preliminaries

A static, directed graph $G=(V,E)$ consists of a finite set of vertices $V$ and finite set $E\subseteq\{(u,v)\in V\times V\mid u\neq v\}$ of directed edges. A weighted temporal graph ${G}=(V,{E})$ consists of a set $V$ of $n\in\mathbb{N}$ vertices and a set $E$ of $m\in\mathbb{N}$ weighted and directed temporal edges. A weighted and directed temporal edge $e=(u,v,t,\lambda,c)\in{E}$ consists of the starting vertex $u\in V$, the end vertex $v\in V$ (with $u\neq v$), availability time $t\in\mathbb{N}$, traversal time $\lambda\in\mathbb{N}$ and cost $c\in\mathbb{R}_{\geq 0}$. Each edge $e=(u,v,t,\lambda,c)\in{E}$ is only available for entering at its availability time $t$ and traversing $e$ takes $\lambda$ time. For $T\coloneqq\max\{t\mid(u,v,t,\lambda,c)\in{E}\}$, we can view ${G}$ as a finite sequence $G_{1},G_{2},\ldots,G_{T}$ of static graphs over the common set of vertices $V$. Each $G_{i}$ has its own set of edges $E_{i}\coloneqq\{(u,v,\lambda,c)\mid e=(u,v,i,\lambda,c)\in{E}\}$. Figure 1 shows an example. We denote the set of incoming (outgoing) temporal edges of a vertex $v\in V$ by $\delta^{-}(v)$ ($\delta^{+}(v)$). Note that in general for temporal graphs the number of edges is not bounded by a function in the number of vertices, i.e. we may have arbitrarily more temporal edges than vertices. In the following, we use a stream representation of temporal graphs. A temporal graph is given as a sequence of its $m$ edges, which is ordered by the availability time of the edges in increasing order with ties being broken arbitrarily.

2.1 Temporal Path Problems

A temporal $(u,v)$-walk $P_{u,v}$ is a sequence $(e_{1},\ldots,e_{i}=(v_{i},v_{i+1},t_{i},\lambda_{i},c_{i}),\ldots,e_{k})$ of edges with $e_{i}\in{E}$ for $1\leq i\leq k$, and with $v_{1}=u$, $v_{k+1}=v$ and $t_{i}+\lambda_{i}\leq t_{i+1}$ for $1\leq i<k$. If a temporal $(u,v)$-walk visits each $w\in V$ at most once, it is simple and we call it $(u,v)$-path. We denote by $s(P_{u,v})\coloneqq t_{1}$ the starting time, and by $a(P_{u,v})\coloneqq t_{k}+\lambda_{k}$ the arrival time of $P_{u,v}$. Furthermore, we define the duration as $d(P_{u,v})\coloneqq a(P_{u,v})-s(P_{u,v})$. A path $P_{u,v}$ is faster than a path $Q_{u,v}$ if $d(P_{u,v})<d(Q_{u,v})$. The cost of a path $P=(e_{1},\ldots,e_{k})$ is the sum of the edge cost, i.e. $c(P)\coloneqq\sum_{i=1}^{k}c_{i}$. Finally, for a path $P=(e_{1},\ldots,e_{i},\ldots,e_{k})$, we call $(e_{1},\ldots,e_{i})$ prefix-path and $(e_{i},\ldots,e_{k})$ suffix-path of $P$. In Figure 1 the $(s,z)$-path $((s,b,1,1,2),(b,z,2,1,1))$ has arrival time $3$, duration $2$ and cost $3$. The $(s,z)$-path $((s,z,3,1,3))$ also has cost $3$, but it has a later arrival time of $4$ and is faster with a duration of only $1$.

For the discussion of bicriteria path problems, we use the following definitions. Let $\mathcal{X}$ be the set of all feasible $(s,z)$-paths, and let $f(P)$ be the temporal value of $P$, i.e. either arrival time $f(P)\coloneqq a(P)$ or duration $f(P)\coloneqq d(P)$. We call a path $P\in\mathcal{X}$ efficient if there is no other path $Q\in\mathcal{X}$ with $c(Q)<c(P)$ and $f(Q)\leq f(P)$ or $c(Q)\leq c(P)$ and $f(Q)<f(P)$. We map each $P\in\mathcal{X}$ to a vector $(f(P),c(P))$ in the two-dimensional objective space which we denote by $\mathcal{Y}$. Complementary to efficiency in the decision space, we have the concept of domination in the objective space. We say $(f(P),c(P))\in\mathcal{Y}$ dominates $(f(Q),c(Q))\in\mathcal{Y}$ if either $c(P)<c(Q)$ and $f(P)\leq f(Q)$ or $c(P)\leq c(Q)$ and $f(P)<f(Q)$. We call $(f(P),c(P))$ nondominated if and only if $P$ is efficient. We define the bicriteria enumeration problems McfEnum and MceaEnum as follows.

Min-Cost Fastest Paths Enumeration Problem (McfEnum)

Given: A weighted temporal graph ${G}=(V,{E})$ and $s,z\in V$.

Task: Enumerate all and only $(s,z)$-paths that are efficient w.r.t. duration and costs.

Min-Cost Earliest Arrival Paths Enumeration Problem (MceaEnum)

Given: A weighted temporal graph ${G}=(V,{E})$ and $s,z\in V$.

Task: Enumerate all and only $(s,z)$-paths that are efficient w.r.t. arrival time and costs.

We denote by Mcf and Mcea the optimization versions, in which the task is to find a single efficient $(s,z)$-path. The counting versions #Mcea and #Mcf ask for the number of solutions.

2.2 Complexity Classes for Enumeration and Counting Problems

Bi- and multicriteria optimization problems are often not easily comparable using the traditional notion of worst-case complexity, due to their potentially exponential number of efficient solutions. We use the output complexity model as proposed by Johnson, Yannakakis, and Papadimitriou [12]. Here, the time complexity is stated as a function in the size of the input and the output.

Definition 1**.**

Let $\mathcal{E}$ be an enumeration problem. Then $\mathcal{E}$ is in

DelayP (Polynomial Time Delay)* if the time delay until the output of the first and between the output of any two consecutive solutions is bounded by a polynomial in the input size, and* 2. 2.

PSDelayP (Polynomial Time Delay with Polynomial Space)* if $\mathcal{E}$ is in DelayP and the used space is also bounded by a polynomial in the input size.*

In Sections 4 and 5 we show that McfEnum and MceaEnum are both in PSDelayP if the input graph has strictly positive edge costs. We provide algorithms that enumerate the set of all efficient paths in polynomial time delay and use space bounded by a polynomial in the input size.

By enumerating the set of all efficient paths, we are also able to count them, i.e., enumeration is at least as hard as counting. Naturally, the question arises, if we can obtain the number of efficient paths more easily. Valiant [18] introduced the class #P. We use the following definitions from Arora and Barak [1].

Definition 2**.**

A function $f:\{0,1\}^{*}\rightarrow\mathbb{N}$ is in #P if there exists a polynomial $p:\mathbb{N}\rightarrow\mathbb{N}$ and a deterministic polynomial time Turing machine $M$ such that for every $x\in\{0,1\}^{*}$ $f(x)=|\{y\in\{0,1\}^{p(x)}:M(x,y)=1\}|\text{,}$ where $M(x,y)=1$ iff $M$ accepts $x$ with certificate $y$.

In other words, the class #P consists of all functions $f$ such that $f(x)$ is equal to the number of computation paths from the initial configuration to an accepting configuration of a polynomial time non-deterministic Turing machine $M$ with input $x$.

In the following, we use the notion of oracle Turing machine where the oracles are not limited to answer only boolean, but arbitrary, polynomially bounded functions. Let $f:\{0,1\}^{*}\rightarrow\{0,1\}^{*}$ be such a function. We define $\textbf{FP}^{f}$ as the class of functions that can be computed by a polynomial time Turing machine with constant-time access to $f$.

Definition 3**.**

A function $f$ is #P-complete iff it is in #P and $\emph{{\#P}}\subseteq\textbf{FP}^{f}$.

A polynomial time algorithm for a #P-complete problem would imply $\textbf{P}=\textbf{NP}$. To show #P-completeness for a counting problem $\mathcal{C}$, we verify that $\mathcal{C}\in\textbf{\#P}$ and reduce a #P-complete problem $\mathcal{C}^{\prime}$ to $\mathcal{C}$, using a polynomial Turing reduction. Valiant [18] showed that calculating the permanent of a $(0,1)$-matrix is #P-complete. This is especially interesting because the permanent of a $(0,1)$-matrix corresponds to the number of perfect matchings in a bipartite graph. Deciding if a bipartite graph has a perfect matching is possible in polynomial time. Moreover, Valiant [19] proved #P-completeness for ST-Path. The input of ST-Path is a static, directed graph ${G}=(V,E)$ and $s,t\in V$, the output is the number of $(s,t)$-paths. In Section 6, we give a reduction from ST-Path to the non-weighted earliest arrival temporal path counting problem.

3 Structural Results

We show that it is possible to find an efficient $(s,z)$-path for the Min-Cost Earliest Arrival Path Problem (Mcea) in a graph $G$, if we are able to solve the Min-Cost Fastest Path Problem (Mcf). We use a transformed graph $G^{\prime}$, in which a new source vertex and a single edge is added. The reduction is from a search problem to another search problem. We show that it preserves the existence of solutions and we also provide a mapping between the solutions. This is also known as Levin reduction.

Lemma 1**.**

There is a Levin reduction from Mcea to Mcf.

Proof.

Let $I=(G=(V,E),s,z)$ be an instance of Mcea. We construct the Mcf instance $I^{\prime}=(G^{\prime}=(V\cup\{s^{\prime}\},E\cup\{e_{0}=(s^{\prime},s,0,0,0)\}),s^{\prime},z)$. Furthermore, let $\mathcal{X}_{I}$ be the sets of all $(s,z)$-paths for $I$, and $\mathcal{X}_{I^{\prime}}$ be the sets of all $(s^{\prime},z)$-paths for $I^{\prime}$. We define $g:\mathcal{X}_{I}\rightarrow\mathcal{X}_{I^{\prime}}$ as bijection that prepends edge $e_{0}$ to the paths in $\mathcal{X}_{I}$, i.e., $g((e_{1},\ldots,e_{k}))=(e_{0},e_{1},\ldots,e_{k})$. We show that $P\in\mathcal{X}_{I}$ is efficient (for Mcea) iff $g(P)\in\mathcal{X}_{I^{\prime}}$ is efficient (for Mcf).

Let $P=(e_{1},\ldots,e_{k})$ be an efficient $(s,z)$-path in $G$ w.r.t. costs and arrival time. Then $Q\coloneqq g(P)=(e_{0},e_{1},\ldots,e_{k})$ is an $(s^{\prime},z)$-path in $G^{\prime}$ with $a(Q)=a(P)$ and $c(Q)=c(P)$. Now, assume $Q$ is not efficient w.r.t. costs and duration in $G^{\prime}$. Then there is a path $Q^{\prime}$ with less costs and at most the duration of $Q$ or with shorter duration and at most the same costs of $Q$. Path $Q^{\prime}$ also begins with edge $e_{0}$, and $G$ contains a path $P^{\prime}$ that uses the same edges as $Q^{\prime}$ with exception of edge $e_{0}$. Then, at least one of the following two cases holds.

• •

Case $c(Q^{\prime})\leq c(Q)$ and $d(Q^{\prime})<d(Q)$: Since the costs of $e_{0}$ are [math], it follows that $c(P^{\prime})=c(Q^{\prime})\leq c(Q)=c(P)$. Because the paths start at time [math] and for each path $d(P)=a(P)-s(P)$, it follows $d(Q^{\prime})=a(Q^{\prime})=a(P^{\prime})<a(P)=a(Q)=d(Q)$.

• •

Case $c(Q^{\prime})<c(Q)$ and $d(Q^{\prime})\leq d(Q)$: Analogously, here we have $c(P^{\prime})=c(Q^{\prime})<c(Q)=c(P)$. And $a(P^{\prime})=a(Q^{\prime})\leq a(Q)=a(P)$.

Either of these two cases leads to a contradiction to the assumption that $P$ is efficient.

Let $Q=(e_{0},e_{1},\ldots,e_{k})$ and assume it is an efficient $(s^{\prime},z)$-path in $G^{\prime}$ w.r.t. to cost and duration. Then there exists an $(s,z)$-path $P=(e_{1},\ldots,e_{k})$ in $G$ such that $g(P)=Q$, $a(Q)=a(P)$ and $c(Q)=c(P)$. Now, assume that $P$ is not efficient. Then there is a path $P^{\prime}$ with less costs and not later arrival time than $P$ or with earlier arrival time and at most the costs of $P$. In $G^{\prime}$ exists the path $Q^{\prime}=g(P^{\prime})$ that uses the same edges as $P^{\prime}$, and additionally the edge $e_{0}$ as prefix-path from $s^{\prime}$ to $s$. We have the cases $c(P^{\prime})<c(P)$ and $a(P^{\prime})\leq a(P)$ or $c(P^{\prime})\leq c(P)$ and $a(P^{\prime})<a(P)$. Again, either of them leads to a contradiction to the assumption that $Q$ is efficient. ∎

Based on this result, we first present an algorithm for McfEnum in Section 4 that we use in a modified version to solve MceaEnum in Section 5. In the rest of this section, we focus on graphs with strictly positive edge costs.

Observation 1**.**

Let $G=(V,E)$ be a weighted temporal graph. If for all edges $e=(u,v,t,\lambda,c)\in{E}$ it holds that $c>0$, then all efficient walks for MceaEnum and McfEnum are simple, i.e., are paths.

Similar to the non-temporal static case, it is possible to delete the edges of a cycle contained in the non-simple walk. We denote the two special cases for graphs with strictly positive edge costs by ($$c$$>[math]$)$-McfEnum and ($$c$$>[math]$)$-MceaEnum. Our enumeration algorithms use a label setting technique. A label $l=(b,a,c,p,v,r,\Pi)$ at vertex $v\in V$ corresponds to an $(s,v)$-path and consists of the following entries:

[TABLE]

Moreover, each label is uniquely identifiable by an additional identifier and has a reference to the edge that lead to its creation (denoted by $l.edge$). The proposed algorithms process the edges in order of their availability time. When processing an edge $e=(u,v,t,\lambda,c_{e})$, all paths that end at vertex $u$ can be extended by pushing labels over edge $e$ to vertex $v$. Pushing a label $l=(b,a,c,p,u,r,\Pi)$ over $e$ means that we create a new label $l_{new}=(b,t+\lambda,c+c_{e},l,v,t,\cdot)$ at vertex $v$.

If we would create and store a label for each efficient path, we possibly would need exponential space in the size of the input. The reason is that the number of efficient paths can be exponential in the size of the input.

Figure 2 shows an example for McfEnum and MceaEnum, which is similar to the one provided by Hansen [9], but adapted to the weighted temporal case. $G$ has $n=\frac{2m}{3}+1$ vertices and $m>3$ edges. There are two paths from $s$ to $v_{3}$, four paths from $s$ to $v_{5}$, eight paths from $s$ to $v_{7}$ and so on. All $(s,v)$-paths for $v\in V$ are efficient. In total, there are $2^{\lfloor\frac{n}{2}\rfloor}$ efficient $(s,z)$-paths to be enumerated. However, the following lemma shows properties of the problems that help us to achieve polynomial time delay and a linear or polynomial space complexity. Let $\mathcal{Y}_{A}$ ($\mathcal{Y}_{F}$) denote the objective space for MceaEnum (McfEnum, respectively). Moreover, we define $\mathcal{S}$ to be the number of distinct availability times of edges leaving the source vertex $s$.

Lemma 2**.**

For MceaEnum, the number of nondominated points in $\mathcal{Y}_{A}$ is in $\mathcal{O}(m)$. For McfEnum, the number of nondominated points in $\mathcal{Y}_{F}$ is in $\mathcal{O}(\mathcal{S}\cdot m)=\mathcal{O}(m^{2})$.

Proof.

Let $G=(V,E)$ be a weighted temporal graph and $s,z\in V$. First we show that the statement holds for MceaEnum. The possibilities for different arrival times at vertex $z$ is limited by the number of incoming edges at $z$. For each path $P_{s,z}$ we have

[TABLE]

Consequently, there are at most $|\delta^{-}(z)|\in\mathcal{O}(m)$ different arrival times. For each arrival time $a$, there can only be one nondominated point $(a,c)\in\mathcal{Y}_{A}$ that has the minimum costs of $c$, and which represents exactly all efficient paths with arrival time $a$ and costs $c$.

Now consider the case for McfEnum. The number of distinct availability times of edges leaving the source vertex $\mathcal{S}$ is bounded by $|\delta^{+}(s)|\in\mathcal{O}(m)$. Because the duration of any $(s,z)$-path $P$ equals $a(P)-s(P)$, there are at most $\mathcal{S}\cdot|\delta^{-}(z)|\in\mathcal{O}(m^{2})$ different durations possible at vertex $z$. For each duration, there can only be one nondominated point $(d,c)\in\mathcal{Y}_{F}$ having minimum costs $c$. ∎

Note that for general bicriteria optimization (path) problems there can be an exponential number of nondominated points in the objective space. Skriver and Andersen [17] give an example for a family of graphs with an exponential number of nondominated points for a bicriteria path problem. The fact that in our case the number of nondominated points in the objective space is polynomially bounded, allows us to achieve polynomial time delay and space complexity for our algorithms. The idea is to consider equivalence classes of labels at each vertex, such that we only have to proceed with a single representative for each class. First, we define the following relations between labels.

Definition 4**.**

Let $l_{1}=(b_{1},a_{1},c_{1},p_{1},v,r_{1},\Pi_{1})$ and $l_{2}=(b_{2},a_{2},c_{2},p_{2},v,r_{2},\Pi_{2})$ be two labels at vertex $v$.

Label $l_{1}$ is equivalent to $l_{2}$ iff $c_{1}=c_{2}$ and $b_{1}=b_{2}$. 2. 2.

Label $l_{1}$ predominates $l_{2}$ if $l_{1}$ and $l_{2}$ are not equivalent, $b_{1}\geq b_{2}$, $a_{1}\leq a_{2}$ and $c_{1}\leq c_{2}$ with at least one of the inequalities being strict. 3. 3.

Finally, label $l_{1}$ dominates $l_{2}$ if $a_{1}-b_{1}\leq a_{2}-b_{2}$ and $c_{1}\leq c_{2}$ with at least one of the inequalities being strict.

For each class of equivalent labels, we have a representative $l$ and a list $\Pi_{l}$ that contains all equivalent labels to $l$. For each vertex $v\in V$, we have a set $R_{v}$ that contains all representatives. The algorithms consist of two consecutive phases:

• •

Phase 1 calculates the set of non-equivalent representatives $R_{v}$ for every vertex $v\in V$ such that every label in $R_{v}$ represents a set of equivalent paths from $s$ to $v$. For each of the nonequivalent labels $l\in R_{v}$ we store the list $\Pi_{l}$ that contains all labels equivalent to $l$.

• •

Phase 2 recombines the sets of equivalent labels in a backtracking fashion, such that we are able to enumerate exactly all efficient $(s,z)$-paths without holding the paths in memory.

A label in $\Pi_{l}$ at vertex $v$ represents all $(s,v)$-paths that are extension of all paths represented by its predecessor, and $l\in R_{v}$ is a representative for all labels in $\Pi_{l}$. The representative itself is in $\Pi_{l}$ and has minimum arrival time among all labels in $\Pi_{l}$.

We have to take into account that a prefix-path $P_{s,w}$ of an efficient $(s,z)$-path may not be an efficient $(s,w)$-path.

Figure 3 (a) shows an example for a weighted temporal graph with a non-optimal prefix-path. Consider the following paths:

• •

$P^{*}_{s,z}=((s,w,2,3,2),(w,z,5,1,1))$ with arrival time $6$ and duration $4$

• •

$P^{1}_{s,w}=((s,w,2,3,2))$ with arrival time $5$ and duration $3$

• •

$P^{2}_{s,w}=((s,u,1,2,1),(u,w,2,1,1))$ with arrival time $3$ and duration $3$

• •

$P^{3}_{s,w}=((s,v,5,1,1),(v,w,6,1,1))$ with arrival time $7$ and duration $2$

All $(s,z)$-paths have cost $3$ and all $(s,w)$-paths have cost $2$. Path $P^{*}_{s,z}$ is efficient for McfEnum and MceaEnum. For MceaEnum the prefix-path $P^{1}_{s,w}$ is not efficient, because $P^{2}_{s,w}$ arrives earlier. However, for McfEnum the only efficient $(s,w)$-path is $P^{3}_{s,w}$. Consequently, we cannot discard a non-efficient path that possibly is a prefix-path of an efficient path. We use the predomination relation to remove all labels that do not represent prefix-paths of efficient paths.

Lemma 3**.**

Let $l_{1}=(b_{1},a_{1},c_{1},p_{1},v,r_{1},\Pi_{1})$ and $l_{2}=(b_{2},a_{2},c_{2},p_{2},v,r_{2},\Pi_{2})$ be two distinct labels at vertex $v\in V$. If $l_{1}$ predominates $l_{2}$, then $l_{2}$ cannot be a label representing a prefix-path of any efficient path.

Proof.

There are two distinct paths $P^{1}_{s,v}$ and $P^{2}_{s,v}$ from $s$ to $v$ corresponding to $l_{1}$ and $l_{2}$. Due to the predomination of $l_{1}$ over $l_{2}$ it follows that $a_{1}=a(P^{1}_{s,v})\leq a(P^{2}_{s,v})=a_{2}$, $b_{1}=s(P^{1}_{s,v})\geq s(P^{2}_{s,v})=b_{2}$ and $c_{1}=c(P^{1}_{s,v})\leq c(P^{2}_{s,v})=c_{2}$ with at least one of the later two relations being strict, due to the fact that the labels are not equivalent. Let $P_{s,w}$ be a path from $s$ to some $w\in V$ such that $P^{2}_{s,v}$ is prefix-path of $P_{s,w}$, and assume that $P_{s,w}$ is efficient. Let $P^{\prime}_{s,w}$ be the path where the prefix-path $P^{2}_{s,v}$ is replaced by $P^{1}_{s,v}$. This is possible because $a(P^{1}_{s,v})\leq a(P^{2}_{s,v})$. Now, since $s(P^{1}_{s,v})\geq s(P^{2}_{s,v})$ and $c(P^{1}_{s,v})\leq c(P^{2}_{s,v})$ with at least one of the inequalities being strict, it follows that $a(P^{\prime}_{s,w})-s(P^{\prime}_{s,w})\leq a(P_{s,w})-s(P_{s,w})$ and $c(P^{\prime}_{s,w})\leq c(P_{s,w})$ also with one of the inequalities being strict. Therefore, $P^{\prime}_{s,w}$ dominates $P_{s,w}$, a contradiction to the assumption that $P_{s,w}$ is efficient. ∎

Figure 3 (b) shows an example for a non-predominated label of a prefix-path that we cannot discard. Although path $P_{1}=((s,u,5,5,5))$ dominates path $P_{2}=((s,u,1,6,6))$, we cannot discard $P_{2}$. The reason is that the arrival time of $P_{1}$ is later than the availability time of the only edge from $u$ to $z$. Therefore, $P_{2}$ is the prefix-path of the only efficient path $((s,u,1,6,6),(u,z,8,1,1))$.

4 Min-Cost Fastest Path Enumeration Problem

In this section, we present the algorithm for McfEnum. Algorithm 1 expects as input a weighted temporal graph with strictly positive edge costs in the edge stream representation, the source vertex $s\in V$ and the target vertex $z\in V$.

First, we insert an initial label $l_{init}$ into $R_{s}$ and $\Pi_{l_{init}}$. The algorithm then successively processes the $m$ edges in order of their availability time. For each edge $e=(u,v,t,\lambda,c)$, we first determine the set $S\subseteq R_{u}$ of labels with distinct starting times, minimal costs and an arrival time less or equal to $t$ at vertex $u$ (line 5). Next, we push each label in $S$ over $e$. We check for predomination and equivalence with the other labels in $R_{v}$ and discard all predominated labels. In case the new label is predominated, we discard it and continue with the next label in $S$. In case that the new label $l_{new}$ is equivalent to a label $l=(a,c,p,v,t_{e},\Pi)\in R_{v}$, we add $l_{new}$ to $\Pi$. If $l_{new}$ arrives earlier at $v$ than the arrival time of $l$, we replace the representative $l$ with $l_{new}$ in $R_{v}$. If the new label is not predominated and not equivalent to any label in $R_{v}$, we insert $l_{new}$ into $R_{v}$ and $\Pi_{l_{new}}$. In this case, $l_{new}$ is a new representative and we initialize $\Pi_{l_{new}}$ (which contains only $l_{new}$ at this point). For the following discussion, we define the set of all labels at vertex $v\in V$ as $L_{v}\coloneqq\bigcup\limits_{l\in R_{v}}\Pi_{l}$.

Lemma 4**.**

Let $P_{s,v}$ be an efficient path and $P_{s,w}$ a prefix-path of $P_{s,v}$. At the end of Phase 1 of Algorithm 1, $R_{w}$ contains a label representing $P_{s,w}$.

Proof.

We show that each prefix-path $P_{0},P_{1},\ldots,P_{k}$, with $P_{0}=P_{s,s}$ and $P_{k}=P_{s,v}$ is represented by a label at the last vertex of each prefix-path by induction over the length $h$. Note that all prefix-paths have the same starting time $b=s(P_{s,v})$. For $h=0$ we have $P_{0}=P_{s,s}$ and since $s$ does not have any incoming edges, the initial label $l_{init}=l_{0}$ representing $P_{0}$ is in $L_{s}$ after Phase 1 finishes. Assume the hypothesis is true for $h=i-1$ and consider the case for $h=i$ and the prefix-path $P_{i}=P_{s,v_{i+1}}=(e_{1},\ldots,e_{i}=(v_{i},v_{i+1},t_{i},\lambda_{i},c_{i}))$, which consists of the prefix-path $P_{i-1}=P_{s,v_{i}}=(e_{1},\ldots,e_{i-1}=(v_{i-1},v_{i},t_{i-1},\lambda_{i-1},c_{i-1}))$ and edge $e_{i}=(v_{i},v_{i+1},t_{i},\lambda_{i},c_{i})$. Due to the induction hypothesis, we conclude that $L_{v_{i}}$ contains a label $l_{i-1}=(b,a_{i-1},c_{i-1},p_{i-1},v_{i},r_{i-1},\Pi_{i-1})$ that represents $P_{i-1}$. Because $P_{i-1}$ is a prefix-path of $P_{s,v}$ the representing label $l_{i-1}$ must have the minimum cost in $L_{v_{i}}$ under all labels with starting time $b$ before edge $e_{i}$ arrives. Else, it would have been predominated and replaced by a cheaper one (Lemma 3). The set $S$ contains a label that represents $l_{i-1}$, because the representative of $\Pi_{i-1}$ has an arrival time less or equal to $a_{i-1}$. Therefore, the algorithm pushes $l_{new}=(b,t_{i}+\lambda_{i},c_{i-1}+c_{i},l_{i-1},v_{i+1},t_{i},\cdot)$ over edge $e_{i}$. If $R_{v_{i+1}}$ is empty the label $l_{new}$ gets inserted into $R_{v_{i+1}}$ and $\Pi_{l_{new}}$. Otherwise we have to check for predomination and equivalence with every label $l^{\prime}=(b^{\prime},a^{\prime},c^{\prime},p^{\prime},v_{i+1},r^{\prime},\Pi^{\prime})\in R_{v_{i+1}}$. There are the following cases:

$l_{new}$ predominates $l^{\prime}$: We can remove $l^{\prime}$ from $R_{v_{i+1}}$ because it will never be part of an efficient path (Lemma 3). The same is true for each label in $\Pi^{\prime}$ and therefore we delete $\Pi^{\prime}$. However, we keep $l_{new}$ and continue with the next label. 2. 2.

$l_{new}$ and $l^{\prime}$ are equivalent: We add $l_{new}$ to $\Pi^{\prime}$. In this case we represent the path $P_{i}$ by the representative of $\Pi^{\prime}$. Consequently, the path is represented by a label in $L_{v_{i+1}}$.

If neither of these two cases apply for any label in $R_{v_{i+1}}$, we add $l_{new}$ to $R_{v_{i+1}}$ and to $\Pi_{l_{new}}$. The case that a label $l$ is not equivalent to $l_{new}$ and predominates $l_{new}$ cannot be for the following reason. If $l$ predominates $l_{new}$, there is a path $P^{\prime}$ from $s$ to $v_{i+1}$ with less costs or later starting time (because $l$ and $l_{new}$ are not equivalent) and a not later arrival time. Replacing the prefix-path $P_{i}$ with $P^{\prime}$ in the path $P_{s,v}$ would lead to an $(s,v)$-path with less costs and/or shorter duration. This contradicts our assumption that $P_{s,v}$ is efficient. Therefore, after Phase 1 finished, the label $l_{new}$ representing the prefix-path $P_{i}$ is in $L_{v_{i}}$. It follows that if $P_{s,v}=(e_{1},\ldots,e_{k})$ is an efficient path, then after Phase 1 the set $R_{v}$ contains a label representing $P_{s,v}$ (possibly, such that a label in $R_{v}$ represents a list of equivalent labels, that contains the label representing $P_{s,v}$). ∎

After all edges have been processed, the algorithm continues with Phase 2. First, the algorithm marks all nondominated labels in $R_{z}$. For each marked label $l$ the algorithm iterates over the list of equivalent labels $\Pi_{l}$ and calls the output procedure for each label in $\Pi_{l}$. We show that all and only efficient paths are enumerated.

Theorem 1**.**

Let $G=(V,E)$ be a weighted temporal graph with strictly positive edge costs and $s,z\in V$ an instance of McfEnum. Algorithm 1 outputs exactly all efficient $(s,z)$-paths.

Proof.

Lemma 4 implies that for each efficient path $P_{s,z}$ there is a corresponding representative label in $R_{z}$ after Phase 1 is finished. Note that there might also be labels in $L_{z}$ that do not represent efficient paths. First, we mark all nondominated labels in $R_{z}$. For every marked representative $l^{\prime}=(b,a,c,p,z,r,\Pi_{l^{\prime}})$ in $R_{z}$ we proceed by calling the output procedure for all labels $l\in\Pi_{l^{\prime}}$ with minimal arrival time. Each such label $l$ represents at least one efficient $(s,z)$-path and we call the output procedure with $l$ and the empty path $P$. Let path $Q=(e_{1}\ldots,e_{k})$ be an efficient $(s,z)$-paths represented by $l$. We show that the output procedure successively constructs the suffix-paths $P_{k-i+1}=(e_{k-i+1},\ldots,e_{k})$ of $Q$ for $i\in\{1,\ldots,k\}$ and finally outputs $Q=P_{1}=(e_{1},\ldots,e_{k})$.

We use induction over the length $i\geq 1$ of the suffix-path. For $i=1$ the statement is true. $P_{k}=(e_{k})$ is constructed by the first instruction which prepends the last edge of $Q$ to the initially empty path. Assume the statement holds for a fixed $i<k$, i.e., the suffix-path $P_{k-i+1}$ of $Q$ with length $i$ has been constructed, by calling the output procedure with $P_{k-i+2}$ and label $\tilde{l}=(b,a,c,p,v_{k-i+1},r,\Pi)$. Now, for $i+1$, the suffix-path $P_{k-i}=(e_{k-i},\ldots,e_{k})$ equals suffix-path $P_{k-i+1}$ with the additional edge $e_{k-i}=(v_{k-i},v_{k-i+1},t,\lambda,c)$ prepended and where $v_{k-i+1}$ is the first vertex of $P_{k-i+1}$. If label $\tilde{l}$ has a predecessor $p=(b,a_{p},c_{p},p_{p},v_{k-i},r_{p},\Pi^{\prime})$, the algorithm recursively calls the output procedure for each label in the list of equivalent labels $\Pi^{\prime}$ that has an arrival time less or equal to the time $r$ of the edge that lead to the creation of $\tilde{l}$. Due to Lemma 4 and the induction hypothesis, the algorithm particularly calls the output procedure for the label $l^{\prime}$ that represents the beginning of the suffix-path $P_{k-i}$. Because $Q$ is a temporal path the arrival time at $v_{k-i}$ is less or equal to the time of the edge that lead to the label $\tilde{l}$. Consequently, there is a call of the output procedure that constructs $P_{k-i}$. If label $\tilde{l}$ does not have a predecessor, the algorithm arrived at vertex $s$ and the algorithm outputs the complete path $Q=P_{1}$. Therefore, all efficient paths are enumerated.

We still have to show that only efficient paths are enumerated. In order to enumerate a non-efficient $(s,z)$-path $Q^{\prime}$, there has to be a label $l_{q}$ in $L_{z}$ for which the output procedure is called and which represents $Q^{\prime}$. For $Q^{\prime}$ to be non-efficient there has to be at least one label $l_{d}$ in $L_{z}$ that dominates $l_{q}$. In line 25 the algorithm marks all nondominated labels in $R_{z}$. This implies that $l_{d}$ and $l_{q}$ have the same cost and starting times and that they are in the same list, let this list be $\Pi_{x}$ for some label $x\in R_{z}$. Because $l_{q}$ is dominated by $l_{d}$ the arrival time of $l_{d}$ is strictly earlier than the the arrival time of $l_{q}$. However, we call the output procedure only for the labels in $\Pi_{x}$ with the minimal arrival time. Consequently, it is impossible that the non-efficient path $Q^{\prime}$ is enumerated. Finally, because all edge costs are strictly positive and due to 1 only paths are enumerated. ∎

Example:

Figure 4 shows an example for Algorithm 1 at the end of Phase 1. The indices of the edges are according to the position in the sequence of the edge stream. The representative labels at the vertices only show the starting time, arrival time and cost. The lists $\Pi$ of equivalent labels are not shown. All of them contain only the representative, with exception of $\Pi_{l}$ represented by label $l$ in $R_{w}$. The list $\Pi_{l}$ contains label $l=(3,7,4)^{T}$ representing path $((s,w,3,4,4))$ and the equivalent label $(3,8,4)^{T}$ representing path $((s,u,3,3,3),(u,w,6,1,1))$. There are three efficient paths. Starting the output procedure from vertex $z$ with the label $(7,10,6)^{T}$ yields path $(e_{5},e_{8})$, and starting with label $(3,9,5)^{T}$ yields the two paths $(e_{1},e_{4},e_{7})$ and $(e_{2},e_{7})$. Notice that label $(7,9,2)^{T}$ in $R_{w}$ which dominates label $(3,7,4)^{T}$, is not part of an efficient $(s,z)$-path, due to its late arrival time.

Lemma 5**.**

Phase 1 of Algorithm 1 has a time complexity of $\mathcal{O}(\mathcal{S}\cdot m^{2})$.

Proof.

The outer loop iterates over $m$ edges. For each edge $e=(u,v,t_{e},\lambda_{e},c_{e})$ we have to find the set $S\subseteq R_{u}$ consisting of all labels with minimal cost, distinct starting times and arrival time less or equal to $t_{e}$ (see line 5). This can be done in $\mathcal{O}(m)$ time. For each label in $S$ we have to check for predominance or equivalence with each label in $R_{v}$ in $\mathcal{O}(S\cdot m)$ total time. Since we have $|S|\leq\mathcal{S}$, we get a total time of $\mathcal{O}(\mathcal{S}\cdot m^{2})$. ∎

The following lemma shows that the number of labels is polynomially bounded in the size of the input.

Lemma 6**.**

The total number of labels generated and hold at the vertices in Algorithm 1 is less than or equal than $\mathcal{S}\cdot m+1$.

Proof.

We need one initial label $l_{init}$. For each incoming edge $e=(u,v,t,\lambda,c)$ in the edge stream we generate at most $|S|\leq\mathcal{S}$ new labels which we push over $e$ to vertex $v$. Therefore, we generate at most $\mathcal{S}\cdot m+1$ labels in total. ∎

Theorem 2**.**

($$c$$>[math]$)$-McfEnum $\in$ PSDelayP.

Proof.

Phase 1 takes only polynomial time in size of the input, i.e., number of edges (Lemma 5). In Phase 2 of Algorithm 1, we first find and mark all nondominated labels in $R_{z}$ in $\mathcal{O}(m^{2})$ time. For each nondominated label, we call the output procedure which visits at most $\mathcal{O}(m^{2})$ labels and outputs at least one path. It follows that the time between outputting two consecutively processed paths is also bounded by $\mathcal{O}(m^{2})$. Therefore, ($$c$$>[math]$)$-McfEnum is in DelayP. The space complexity is dominated by the number of labels we have to manage throughout the algorithm. Due to Lemma 6, the number of labels is in $\mathcal{O}(m^{2})$. Consequently, ($$c$$>[math]$)$-McfEnum is in PSDelayP. ∎

Notice that if we allow zero-weighted edges the algorithm enumerates walks. However, removing zero-weighted cycles to obtain only paths could repeatedly lead to same path, such that we would not be able to guarantee that the time between outputting two successive efficient paths is polynomially bounded. However, the following problems are easy to decide, even if we allow zero weighted edges.

Theorem 3**.**

Given a weighted temporal graph $G=(V,E)$, $s,z\in V$ and

an $(s,z)$-path $P$, deciding if $P$ is efficient for McfEnum, or 2. 2.

$c\in\mathbb{R}_{\geq 0}$* and $d\in\mathbb{N}$, deciding if there exists an $(s,z)$-path $P$ with $d(P)\leq d$ and $c(P)\leq c$ is possible in polynomial time.*

Proof.

We use Phase 1 of Algorithm 1 and calculate the set $\mathcal{N}\subseteq\mathcal{Y}$ of nondominated points. Due to the possibility of edges with cost [math], there may be non-simple paths, i.e., walks, that have zero-weighted cycles. Nonetheless, Phase 1 terminates after processing the $m$ edges. If there exists an efficient $(s,z)$-walk $W$ with $(c(W),a(W))$, then there also exists a simple and efficient $(s,z)$-path $Q$ with the same cost vector. $Q$ is the same path as $W$ but without the zero-weighted cycles. In order to decide if the given path $P$ is efficient, we first calculate the cost vector $(c(P),a(P))$, and then validate if $(c(P),a(P))\in\mathcal{N}$. For 2., we only need to compare $(c,d)$ to the points in $\mathcal{N}$. The size of $\mathcal{N}$ is polynomially bounded (Lemma 2). Phase 1 and calculating the cost of $P$ takes polynomial time. ∎

We can find a maximal set of efficient paths with pairwise different cost vectors in polynomial time.

Corollary 1**.**

Given a temporal graph $G=(V,E)$ and $s,z\in V$, a maximal set of efficient $(s,z)$-paths with pairwise different cost vectors for McfEnum can be found in $\mathcal{O}(\mathcal{S}\cdot m^{2})$.

Proof.

We use Phase 1 of Algorithm 1 and calculate the set $\mathcal{N}\subseteq\mathcal{Y}$ of nondominated points in $\mathcal{O}(\mathcal{S}\cdot m^{2})$ time. Furthermore, we use a modified output procedure, that stops after outputting the first path. We call the procedure for each nondominated label in $R_{z}$, and if a walk is found we additionally remove all zero-weighted cycles. Finding the walk and removing the cycles is possible in linear time, since the length of a walk is bounded by $m$. ∎

5 Min-Cost Earliest Arrival Path Enumeration Problem

Based on the reduction of Lemma 1 presented in Section 3, we modify Algorithm 1 to solve ($$c$$>[math]$)$-MceaEnum. Let $(G=(V,E),s,z)$ be the instance for ($$c$$>[math]$)$-MceaEnum and $(G^{\prime}=(V^{\prime},E^{\prime}),s^{\prime},z)$ be the transformed instance in which all paths start at time [math] at the new source $s^{\prime}$. Although edge $(s,s^{\prime},0,0,0)$ has costs [math], because $s^{\prime}$ has no incoming edges any efficient walk in the transformed instance is simple, i.e., a path. With all paths starting at [math], there are the following consequences for the relations between labels defined in Definition 4. First, consider the equivalence and let $l_{1}=(0,a_{1},c_{1},p_{1},v,r_{1},\Pi_{1})$ and $l_{2}=(0,a_{2},c_{2},p_{2},v,r_{2},\Pi_{2})$ be two labels at vertex $v$. Because the starting time of both labels is [math], the labels are equivalent if $c_{1}=c_{2}$. It follows, that label $l_{1}$ predominates $l_{2}$ if $a_{1}\leq a_{2}$ and $c_{1}<c_{2}$, hence there is no distinction between domination and predomination.

Algorithm 2 shows a modified version of Algorithm 1, that sets all starting times to [math]. The modified algorithm only needs a linear amount of space and less running time for Phase 1. The reasons for this are, that in line 5 it only needs to find a single label with the minimum costs, instead of the set ${S}$. And at each vertex $v$ it only has one representative $l$ in $R_{v}$ with minimal costs (w.r.t. the other labels in $R_{v}$), due to the equivalence of labels that have the same costs. Furthermore, in Phase 2 we do not need to explicitly find the nondominated labels in $R_{z}$. Because each label $l$ in $R_{z}$ has a unique cost value, we consider each represented class $\Pi_{l}$ and call the output procedure with the labels that have the minimum arrival time in $\Pi_{l}$.

Theorem 4**.**

Algorithm 2 outputs exactly all efficient $(s,z)$-paths w.r.t. arrival time and costs.

Proof.

Lemma 4 implies that for each efficient path $P_{s,z}$ there is a corresponding representative label in $R_{z}$ after Phase 1 is finished. For every representative $l^{\prime}=(0,a,c,p,z,r,\Pi)$ in $R_{z}$, it holds by construction that all labels in $\Pi_{l^{\prime}}$ have the same costs. Therefore, we only need to consider the nondominated labels with minimal arrival time $a_{min}$ over all labels in $\Pi_{l^{\prime}}$. Hence, for each $l^{\prime}\in R_{z}$ we call the output procedure for every label in $l\in\Pi_{l^{\prime}}$ if $l$ has minimal arrival time $a_{min}$ in $\Pi_{l^{\prime}}$. ∎

Algorithm 2 uses a linear number of labels.

Lemma 7**.**

The total number of labels generated and hold at the vertices in Algorithm 2 is at most $m+1$.

Proof.

We need one initial label $l_{init}$ at the source vertex $s$. For each incoming edge $e=(u,v,t,\lambda,c)$ in the edge stream, in line 4 we choose the label $l$ with minimal costs and arrival time at most $t$. We only push $l$ and generate at most one new label $l_{new}$ at vertex $v$. Therefore, we generate at most $m+1$ labels in total. ∎

Lemma 8**.**

Phase 1 of Algorithm 2 has a time complexity of $\mathcal{O}(m^{2})$.

Proof.

The outer loop iterates over $m$ edges. In each iteration we have to find the representative label $l\in R_{u}$ with minimum costs and arrival time $a\leq t_{e}$. This is possible in constant time, since we always keep the label with the earliest arrival time of each equivalence class as representative in $R_{u}$. We only need to check if the arrival time of this label is earlier than the availability time of the current edge. Next we have to check the domination and equivalence between $l_{new}$ and each label $l^{\prime}\in R_{v}$. Each of the cases takes constant time, and there are $\mathcal{O}(m)$ labels in $R_{v}$. Altogether, a time complexity of $\mathcal{O}(m^{2})$ follows. ∎

Algorithm 2 lists all efficient paths in polynomial delay and uses only linear space.

Theorem 5**.**

($$c$$>[math]$)$-MceaEnum $\in$ PSDelayP.

Using Algorithm 2, also the results of Theorem 3 and Corollary 1 can be adapted for the earliest arrival case.

Theorem 6**.**

Given a weighted temporal graph $G=(V,E)$, $s,z\in V$ and

an $(s,z)$-path $P$, deciding if $P$ is efficient for MceaEnum, or 2. 2.

$c\in\mathbb{R}_{\geq 0}$* and $a\in\mathbb{N}$, deciding if there exists an $(s,z)$-path $P$ with $a(P)\leq a$ and $c(P)\leq c$ is possible in polynomial time.*

Corollary 2**.**

Given a temporal graph $G=(V,E)$ and $s,z\in V$, a maximal set of efficient $(s,z)$-paths with pairwise different cost vectors for MceaEnum can be found in time $\mathcal{O}(m^{2})$.

6 Complexity of Counting Efficient Paths

In this section, we discuss the complexity of counting efficient paths and show that the counting versions #Mcf and #Mcea are both #P-complete. First, we show that already the unweighted earliest arrival temporal path problem is #P-complete.

earliest Arrival $(s,z)$-Paths Counting Problem (#Eap)

Input: A temporal graph ${G}=(V,{E})$ and $s,z\in V$.

Output: Number of fastest $(s,z)$-paths?

Lemma 9**.**

#Eap* is #P-complete.*

Proof.

We provide a polynomial time Turing reduction from ST-Path to #Eap. #Eap is the special case of #Mcea where all edge costs are [math]. It is possible to decide if a path $P$ is efficient for Mcea in polynomial time. This implies, that #Eap is in #P. Input of ST-Path is a static, directed graph $G=(V,E)$ and two vertices $s,t\in V$. The output is the number of simple paths from $s$ to $t$. Valiant [19] showed that the problem is #P-complete. Given a static, directed graph $G=(V,E)$ with $n\coloneqq|V|$ and two vertices $s,t\in V$, we iteratively construct $n-1$ temporal graphs $G_{\tau}=(V\cup\{z\},E_{\tau})$ with temporal edges

[TABLE]

for $\tau\in\{1,\ldots,n-1\}$. Figure 5 shows an example of the construction. Each temporal $(s,z)$-path in $G_{\tau}$ ends with edge $(t,z,n,1)$. This construction allows to determine all temporal $(s,z)$-paths of lengths $2\leq\ell\leq\tau+1$ in $G_{\tau}$, with $\tau+1$ being the maximal length of any path in $G_{\tau}$. For each $\tau\in\{1,\ldots,n-1\}$ let $y_{\tau}$ be the total number of earliest arrival $(s,z)$-paths in $G_{\tau}$. Note that $y_{\tau}$ equals the number of $(s,z)$-paths that use at most $\tau+1$ edges, because each edge traversal takes one time step. Each temporal $(s,z)$-path in $G_{\tau}$ corresponds to exactly one $(s,t)$-path in the static graph $G$ consisting of the same sequence of edges but the last edge. Let $x_{\tau}$ be the number of temporal $(s,z)$-paths that use exactly $\tau+1$ edges. Then it holds that the number of $(s,t)$-paths in $G$ equals $\sum_{\tau=1}^{n-1}x_{\tau}$.

A path consisting of exactly $\tau+1$ edges in $G_{\tau}$ does not have waiting time at any vertex, beside possibly at vertex $t$. But a path of length $\ell\leq\tau$ can wait for $\tau+1-\ell$ time steps at one or more vertices that it visits beside vertex $t$. In order to derive the value $x_{\tau}$ from $y_{\tau}$ we have to account for all paths of length $\ell\leq\tau$ that have such waiting times. Consider a path of length $\ell$ in $G_{\tau}$ with $\ell\leq\tau$. From the $\tau$ time steps, we choose $\ell$ time steps in which we do not wait and traverse an edge. Consequently, knowing that there exist $x_{\ell}$ paths of length $\ell$ in $G_{\ell}$, it follows that there are $x_{\ell}\cdot{\tau\choose\ell}$ paths of length $\ell$ with waiting times in $G_{\tau}$. Based on these observations, the Algorithm 3 calculates $x_{1},\ldots,x_{n-1}$, given an oracle for #Eap in polynomial time.

The algorithm iteratively determines the number $x_{\tau}$ of $(s,z)$-path with length $\tau+1$ for $\tau\in\{1,\ldots,n-1\}$. Each of these paths corresponds to exactly one $(s,t)$-path of length $\tau$ in $G$. Summing up all $x_{i}$ for $1\leq i\leq n-1$ leads exactly to the number of $(s,t)$-path in $G$. ∎

Now consider the Fastest $(s,z)$-Path Counting Problem (#Fp). Both problems #Eap and #Fp are special case of the weighted versions #Mcea and #Mcf. The parsimonious reduction of Lemma 1 implies that also #Fp is #P-complete. Consequently, it follows Theorem 7.

Theorem 7**.**

#Mcf* and #Mcea are #P-complete.*

7 Conclusion and Open Problems

We discussed the bicriteria optimization problems Min-Cost Earliest Arrival Paths Enumeration Problem (MceaEnum) and Min-Cost Fastest Paths Enumeration (McfEnum). We have shown that enumerating exactly all efficient paths with low costs and early arrival time or short duration is possible in polynomial time delay and linear or polynomial space if the input graph has strictly positive edge costs. In case of nonnegative edge costs, it is possible to determine a maximal set of efficient paths with pairwise different cost vectors in $\mathcal{O}(m^{2})$ time or $\mathcal{O}(\mathcal{S}\cdot m^{2})$ time, respectively, where $\mathcal{S}$ is the number of distinct availability times of edges leaving the source vertex $s$. We can find an efficient path for each nondominated point in polynomial time.

For the cases of zero-weighted or even negative edge weights, we cannot guarantee polynomial time delay for our algorithms to solve McfEnum or MceaEnum. However, the proposed algorithms can be used to determine all efficient $(s,z)$-walks in polynomial time delay. Because each edge in a temporal graph can only be used for departure at a certain time, the number of different walks is finite and the algorithms terminate. So far, we are not aware of a way to ensure that only simple paths are enumerated without loosing the property that the delay between the output of two paths stays polynomially bounded.

Counting temporal paths is hard even in the unweighted single criterion case. We showed #P-completeness for all discussed counting problems. However, we are not aware of a reduction of a #P-complete problem to the special case in which only strictly positive edge costs are allowed.