Fast Heuristics For Continuous Dynamic Shortest Paths and All-Or-Nothing Assignment

FAST HEURISTICS FOR CONTINUOUS DYNAMIC SHORTEST
PATHS AND ALL-OR-NOTHING ASSIGNMENT
Guido Gentile, Lorenzo Meschini, Natale Papola

Dipartimento di Idraulica Trasporti e Strade - Università degli Studi di Roma “La Sapienza”
Via Eudossiana, 18 – 00184 Roma, guido.gentile@uniroma1.it
ABSTRACT
The dynamic shortest path problem lies at the heart of within-day dynamic traffic
assignment. In this paper we address the case of urban road networks with several thousands
of short links, where the theoretical paradigm of diachronic graphs that underlies discrete
models becomes unfeasible to apply, especially for real time instances. To overcome this limit
we reject the discretization of time at the formalization level and focus on the original version
of the problem, where each arc of the network is associated with a function having continuous
domain and range that yields the exit time for any given entrance time.
Within the resulting continuous framework, where every variable is represented as a
temporal profile, we will present two formulations of the dynamic network loading map with
implicit path enumeration for the case of deterministic route choice. The first one addresses
the general case of time-varying arc costs in presence of tolls. The temporal perspective is the
exit time from the current node, which yields a model based on temporal layers. The second
one addresses the particular case where arc costs are proportional to travel times and the FIFO
rule is satisfied. The temporal perspective is the arrival time at the destination, which yields a
model based on vehicle trajectories.
Then, we develop a computational approach based on the approximation of the temporal
profiles as piecewise linear functions of time, which benefits from the possibility to define at
the algorithmic level time intervals of any length suitable with the modulation of demand
flows. This results in a dramatic improvement of calculation times and memory usage
compared to existing assignment algorithms, where instead the length of time intervals
defines the accuracy of arc travel times.
The heuristics proposed to solve the two formulations of the dynamic shortest path
problem and of the corresponding network flow propagation model allow to evaluate the
dynamic network loading map for large road networks with small computing resources in the
case of deterministic route choice. Moreover, these can also be utilized within a Montecarlo
1
simulation to address the case of stochastic route choice.
Keywords: dynamic shortest path problem, dynamic fastest path problem, dynamic traffic
assignment, continuous temporal profiles, implicit path enumeration, deterministic route
choice, network flow propagation.
1 INTRODUCTION
The within-day Dynamic Traffic Assignment (DTA) has three fundamental components: a)
the arc performance model, which reproduces vehicle queuing and traffic congestion yielding
the travel time temporal profiles corresponding to given inflow temporal profiles; b) the route
choice model, which reproduces the behaviour of a driver travelling from an origin to a
destination on the road network; c) the network flow propagation model, which loads all user
trips on the chosen paths yielding the arc inflow temporal profiles corresponding to a given
travel time pattern. To be noticed that the latter differs from the Continuous Dynamic
Network Loading (Xu et al., 1999), which is aimed at finding, for given path flow temporal
profiles, time-varying arc flows and travel times that are mutually consistent through the
network flow propagation model and the arc performance model, respectively. For an
extensive bibliography on DTA the reader should refer to Carey and Ge (2003).
In this paper we will focus on the route choice model and on the network flow propagation
model in presence of time-varying arc costs and travel times, but without the possibility of
waiting at nodes, under the assumptions of perfect information and rational behaviour of the
drivers. This leads to deterministic models where drivers travel only on dynamic shortest
paths, i.e., paths with minimum cost. The cost of a path is given by the sum of the costs of its
arcs, each one evaluated at the time when the user travelling along the path enters it, while the
travel time of a path is given by the concatenation of the exit times of its arcs. As usual in
transportation applications, we will address the many-to-one version of the dynamic shortest
path problem, since the main concern of the user is to reach his destination.
Most of the literature focus on discrete models (Pallottino and Scutellà, 1998), where it is
assumed that the time varies in a finite set of values and that the exit time from each arc
evaluated at one of these instants belongs to the set. In this case, the dynamic shortest path
problem can be studied by introducing the so-called space-time network, or diachronic graph,
where each node of the original network is replicated into a vertex for every instant, and an
edge connects the vertex relative to the initial node of each arc at every instant with the vertex
of its final node at the corresponding exit time. The space-time network has no cycles, and
2
any chronological ordering of its vertices provides a topological ordering. Exploiting this
property, it is possible to solve efficiently the dynamic shortest path problem, by performing
reverse chronological visits of the space-time network. For more details about discrete
formulations of the dynamic shortest path problem in transportation networks, see De Palma,
Hansen and Labbé (1993) and Nachtigall (1995).
The shortest paths may contain cycles, since it may be convenient to wait around on the
network with the aim of traveling on certain arcs at a lesser cost. Moreover, in order to find
the dynamic shortest paths arriving to a given destination at a particular instant from each
origin it is necessary to handle multiple cost labels for each node, one for every instant. The
most efficient algorithms to solve this problem introduce a list of vertices to be examined with
a bucket (Dial, 1969) for each instant. A vertex is extracted iteratively from the latest non-
empty bucket, so that each vertex of its backward star is updated in terms of shortest path
solution and inserted in the proper bucket, if its label can be improved through that edge. All
labels are initialized to infinity except the label of the destination vertex, which is initialized
to zero and inserted in an empty list.
A shortest path is said to satisfy the concatenation property if its two sub-paths from the
origin to any intermediate node and from this node to the destination are themselves shortest
paths. In general, this does not hold in the dynamic context. However, if the FIFO rule is
satisfied for each arc, i.e., no overtaking can occur on road links, then the concatenation
property holds true with respect to travel times (Ziliaskopoulos, 1994). Moreover, if the arc
costs are proportional to the travel times, this can be extended to costs, thus inducing to study
the deterministic model where drivers travel only on dynamic fastest paths, i.e., paths with
minimum travel time (Dreyfus, 1969; Cooke and Halsey, 1966; Ziliaskopoulos and
Mahmassani, 1993).
Based on the FIFO rule, the fastest paths cannot contain cycles. Moreover, any classical
algorithm with only one label for each node can be applied in order to find on the space-time
network the fastest trajectories arriving to a given destination at a particular instant from each
origin (Kaufmann and Smith, 1993), thus solving the dynamic fastest path problem. In this
case the bucket list paradigm, applied to the original nodes instead that to the vertices of the
space-time network, can be adopted to implement efficiently the label setting approach.
Often in the applications to DTA the dynamic shortest path problem is to be solved for
every arriving time. For this case, Chabini (1998) proposed an algorithm that addresses all the
temporal instances jointly, and finds the next arc of the trip from any given node at each
particular instant that allows to reach the destination at a later time with the minimum cost.
3
This is simply achieved by comparing, among each arc exiting that node, the sum between the
arc cost at that instant and the minimum cost from the final node of the arc to the destination,
evaluated at the corresponding exit time from the arc. The above approach underlies a
temporal-layer structure of the solution rather than a trajectory structure, since the temporal
perspective is local.
The latter algorithm eliminates by its nature the need to handle multiple cost labels and,
based on the acyclic property of the time-space network, requires a simple visit of all its
vertices in reverse chronological order, while no particular order is to be maintained when
processing the vertices of a same temporal layer, which leads to an optimal running time. The
only drawback of the above approach is common to all discrete models based on the paradigm
of the diachronic graph. This is the need to introduce a large number of time intervals having
a short length in order to reproduce the arc travel times with the required accuracy, since these
are multiples of such a length (usually 1 second, in urban contexts), which results in time-
consuming procedures.
Continuous models, which do not introduce the space-time network but operate directly on
variables that are functions of time, have been analyzed by Orda and Rom (1990-1991).
However their exact solution approach seems to be unfeasible for large networks. In this
paper we explore the possibility of allowing some approximations when operating on the
temporal profiles in the algorithm, with the aim of achieving fast heuristics. Specifically, we
deal with temporal profiles that are piecewise linear functions of time defined on a pre-
specified set of instants, and keep their form during any operation accepting the necessary
distortions.
With this aim the trajectory approach is simply extended, while the temporal-layer
approach is more significantly tailored, to the case where costs and travel times are functions
of time having a continuous domain and range. Indeed, to avoid a dense time discretization in
the temporal-layer approach, we will renounce the acyclic property of the space-time network,
by letting the exit time from any given arc at the beginning of a particular interval to fall
within that same interval. This leads to the possibility that a cycles in a shortest path falls
within a same temporal layer and therefore introduces the need to make some approximation;
specifically, we force a label setting strategy and implement it through a bucket list.
In both approaches, the reference instants on which basis the piecewise linear temporal
profiles are defined can then identify time intervals of several minutes. This, on one side,
allows to capture the features of road traffic dynamic that are relevant for most planning
purposes, and on the other side, results in much shorter computational times.
4
The shorter the time intervals are, the more the proposed continuous models tend to
coincide with the corresponding discrete models. This property will be exploited in validation
of the proposed heuristics both in terms of results and computing times. Moreover, on this
basis, the proposed algorithms can be utilized also in real-time applications that require a
dense time discretization, such as traffic signal setting (Ahuja, 2002), although in this case the
advantage with respect to discrete models vanishes.
The paper is organized as follows. In section 2, we introduce the main variables underlying
the continuous model. In section 3, we present the formulations of the dynamic shortest path
problem and of the dynamic fastest path problem, from each node to a given destination. In
section 4, we formalize the deterministic path choice model and the corresponding network
flow propagation model, through implicit path enumeration. In section 5, we outline a simple
arc performance model with an explicit queue modelling in order to formalize, in section 6,
the within-day DTA as a user equilibrium, through a fixed point problem in terms of arc flow
temporal profiles. Finally, sections 7 and 8 are respectively devoted to the presentation and
validation of heuristics that compute the deterministic network loading map and solve the
equilibrium model.
2 MATHEMATICAL FRAMEWORK
The road network is modelled through a directed graph G = (N, A), where N is the set of
the nodes and A ⊆ N × N is the set of the arcs. The forward and backward star of the generic
node o∈N are denoted, respectively, FS(o) = {(x, y)∈A: x = o} and BS(o) = {(x, y)∈A: y = o}.
When travelling from an origin node o∈N to a destination node d∈ Z ⊆ N users consider the
set Kod of all the paths connecting o to d on G. The set of the destinations Z usually comprises
a relatively small subset of nodes, and we are interested in the many-to-one shortest path
problem from each node o∈N to a given destination d∈Z. Graph G is assumed to be strongly
connected, so that Kod , with o∈N ≠ d∈Z, is non-empty.
As the analysis is carried out within a dynamic context, the model variables are temporal
profiles, here represented as real valued functions of the continuous time variable τ.
Let txy(τ) be the exit time from the generic arc (x, y)∈A and cxy(τ) be the cost of traveling
through it, for users that enter the arc at time τ. We assume that the travel times and the arc
costs are bounded between two strictly positive constants.
Due to the presence of time-varying costs, it may be convenient to wait at nodes in order to
enter a given arc later. In the following we assume that vehicles are not allowed to wait at
5
nodes, so that paths with cycles may result convenient. However the shortest paths include at
the most a finite number of cycles.
Let A(k) be the concatenated sequence of arcs constituting the generic path k∈Kod from
o∈N to d∈Z. Since waiting at nodes is not allowed, the exit time Tk(τ) from k for users
departing from o at a particular instant τ is the concatenation of the exit times of its arcs A(k),
each of them referred to the instant when these users enter the arc when travelling along the
path. Moreover, assuming that path costs are additive with respect to arc costs, its cost Ck(τ) is
the sum of the costs of its arcs A(k), each of them referred to the time when they enter the arc
when travelling along the path. The exit time and the cost of k can then be retrieved,
respectively, through the following recursive expressions:
Tk(τ) = Th(tox(τ)) , (1)
Ck(τ) = cox(τ) + Ch(tox(τ)) , (2)
where (o, x) is the first arc of k and h∈Kxd is the rest of path k (Figure 1).
τ tox(τ) Tk(τ) = Th(tox(τ))

time
cox(τ) Ch(tox(τ))
(o, x)∈A(k) h∈Kxd
Ck(τ) = cox(τ) + Ch(tox(τ))
x k∈Kod
o∈N d∈Z
(x, y)∈A(k) y
time
Tk-1(τ) = tox-1(Th-1(τ)) Th-1(τ) τ
Figure 1. Recursive expressions of path exit time, entrance time and cost.
The strict First In First Out (FIFO) rule holds when the following property is satisfied for
each arc (x, y)∈A:
txy(τ′) > txy(τ) , for any τ′ > τ . (3)
Since paths are concatenation of arcs, the FIFO rule can be immediately extended to the
generic path k∈Kod from o∈N to d∈Z:
Tk(τ′) > Tk(τ) , for any τ′ > τ . (4)
In the following, we will assume the above FIFO rule to hold only for the trajectory
6
formulation, while this is not necessary for the temporal-layer formulation.
The monotonicity expressed by (3) and (4), respectively, ensures that the temporal profiles
of the arc and path exit times are invertible. Therefore, txy-1(τ) and Tk-1(τ) are, respectively, the
entrance times of the generic arc (x, y)∈A and of the generic path k∈Kod from o∈N to d∈Z,
for users exiting them at time τ. Moreover, the FIFO rule applies also to the entrance times:
txy-1(τ′) > txy-1(τ) , for any τ′ > τ , (5)
Tk-1(τ′) > Tk-1(τ) , for any τ′ > τ . (6)
The entrance time of k can be retrieved through a recursive expression analogous to (1):
Tk-1(τ) = tox-1(Th-1(τ)) , (7)
where (o, x) is the first arc of k and h∈Kxd is the rest of path k (Figure 1).
The scope of DTA is to assign the generic demand flow Dod(τ) of users travelling from
origin o∈N to destination d∈Z that depart at time τ on the road network. These users choose
each path k∈Kod with a probability Pk(τ), and load the arcs along the path consistently with
the travel times. The network flow propagation leads to an inflow fxy(τ) and an outflow exy(τ)
of vehicles that enter and exit, respectively, each arc (x, y)∈A at time τ.
In the following the temporal profiles of the demand flows are assumed to be fixed,
bounded from above, and null outside a given interval that starts at time zero. Therefore,
because we assumed that the graph is strongly connected, the arc performances are bounded
between two positive constants, and the demand is bounded, then there exists a time Θ within
which all the trips are concluded, so that the arc flow temporal profiles are null outside the
period of analysis [0, Θ].
3 CONTINUOUS DYNAMIC SHORTEST PATH PROBLEM

Before addressing the dynamic case, we here briefly introduce the shortest path problem in
the static case, where travel times do not play any particular role, so that we can refer just to
costs. The most common way to solve a shortest path problem is to solve its dual problem,
that is to find the minimum cost wod from each node o∈N to a given destination d∈Z:
wod = min{Ck: k∈Kod} , (8)
where Ck is the cost of path k∈Kod . Assuming that path costs are additive with respect to arc
costs, we have:
Ck = ∑ (x, y)∈A(k) cxy , (9)
where and cxy > 0 is the cost of the generic arc (x, y)∈A. Note that because the arc costs are
7
assumed to be positive, problem (8) has a unique solution, but there may be more than one
shortest path with no cycles yielding the minimum cost.
A shortest path k∈Kod from o∈N to d∈Z is said to satisfy the concatenation property if the
two sub-paths of k from o to any intermediate node x and from x to d are themselves shortest
paths. In the static case the above principle clearly holds true.
This allows to prove that problem (8) can be decomposed in a system of local conditions at
each node o∈N, also called Bellman relations:
wod = min{cox + wxd: x∈FS(o)} . (10)
Proof. The paths in Kod can be partitioned on the basis of their first arc, so that based on
(9) equation (8) can be written as:
wod = min{cox + Ch: x∈FS(o), h∈Kxd} .
Because minimization is associative, we have:
wod = min{min{cox + Ch: h∈Kxd}: x∈FS(o)} .
Moreover, because the term cox is common to all the terms of the inner minimization, the
above relation becomes:
wod = min{cox + min{Ch: h∈Kxd}: x∈FS(o)} ,
which, based on (8) yields (10). ♦
Contrary to the static case, in the dynamic context the shortest path problem involves
explicitly the time dimension, since the costs of the arcs constituting a path are to be evaluated
at different instants, consistently with the travel times experienced along the path, as induced
by the recursive equation (2).
Consider the problem of finding the minimum cost wod(τ) from each node o∈N to a given
destination d∈Z for users departing at time τ:
wod(τ) = min{Ck(τ): k∈Kod} . (11)
In the dynamic case the concatenation property does not hold in general. Indeed,
- if k∈Kod is a shortest path from o∈N to d∈Z for users departing at time τ, the sub-path k1
of k from o to any intermediate node x is not necessarily shortest for users departing at time τ,
although the sub-path k2 of k from x to d must be shortest for users departing at time Tk1(τ).
This may be because the latter sub-path is a slower route that allows users to enter the sub-
path k2 from x to d later, or because it is a faster but more expensive route that allows users to
enter k2 earlier, or a combination of these two cases. Similarly,
- if k∈Kod is a shortest path from o∈N to d∈Z for users arriving at time τ, the sub-path k2
of k from any intermediate node x to d is not necessarily shortest for users arriving at time τ,
8
although the sub-path k1of k from o to x is shortest for users arriving at time Tk2-1(τ).
To clarify this issue, we illustrate the simple example of Figure 2, where a time-varying
toll sox(τ) is associated with the arc (o, x) and a constant toll sxd(τ) is associated with the arc
(x, d), while all travel times are constant. These tolls are here measured in time units and
when summed up to the travel time yield the cost of the arc. With respect to the arrival time
τ′ = 10 at the destination d, the shortest path from o to d is o-x-y-d with a cost of 7 units, since
the alternative path o-x-d has a cost of 8.5 units. But, the shortest path from x to d is x-d,
which has a constant cost of 2.5 units, and not the sub-path x-y-d of the shortest path from o to
d, which has a constant cost of 3 units. However, the concatenation property holds true with
respect to travel times. In fact, the fastest path from o to d is o-x-d. This will be proved to hold
in general when the FIFO rule is satisfied.
Note that also allowing users to arrive earlier in d the concatenation property is violated.
Indeed, if a user departs at time 5, along o-x-d he will pay 6.5 units, but then will wait for 1
unit in d, which yields a total cost of 7.5 units.
o sox(τ)
4 4
2 2
τ τ
tox(τ)-τ tox(τ)-τ
2 2
x
5 tox-1(txd-1(τ′)) = 6
txy(τ)-τ
y sxd(τ)
1 0.5
7
tyd(τ)-τ txd(τ)-τ
2 2
d
8 10 txd-1(τ′) = 8 τ′ = 10
path o-x-y-d path o-x-d
Figure 2. Violation of the concatenation property for time-varying tolls.
It is worth noting that the violation of the concatenation property can occur also in the case
of constant tolls and not only in the case of time-varying tolls. To this end, we illustrate the
9
simple example of Figure 3, where a constant toll sxy(τ) = 4 is associated with the arc (x, y).
With respect to the arrival time τ′ = 10 at the destination d, the shortest path from o to d is
o-x-d with a cost of 8 units, since the alternative path o-x-y-d has a cost of 9 units. But, the
shortest path from x to d is x-y-d, which has a constant cost of 6 units, and not the sub-path
x-d of the shortest path from o to d, which has a constant cost of 7 units.
Again, also allowing users to arrive earlier in d the concatenation property is violated.
Indeed, if a user departs at time 2, along o-x-y-d he will pay 7 units, but then will wait for 5
units in d, which yields a total cost of 12 units. Moreover, the violation of the concatenation
property in the case of constant tolls occurs also for users departing at a particular time from a
given origin. To see this it is possible to use the reverse of the example in Figure 3.
o
tox(τ)-τ tox(τ)-τ
3 3
1 τ 1 τ
x
5 tox-1(txd-1(τ′)) =2
4
sxy(τ)
y txd(τ)-τ
7
txy(τ)-τ
1
8
tyd(τ)-τ
1
d
9 10 txd-1(τ′) = 3 τ′ = 10
path o-x-y-d path o-x-d
Figure 3. Violation of the concatenation property for constant tolls.
3.1 Temporal-layer formulation of the dynamic shortest path problem
Despite only one side of the concatenation property is valid, we can still prove that the
following dynamic version of the Bellman relation for each node o∈N (Figure 4) is equivalent
to problem (11):
wod(τ) = min{cox(τ) + wxd(tox(τ))}: x∈FS(o)} . (12)
wod(τ) = min{cox(τ) + Ch(tox(τ)): x∈FS(o), h∈Kxd} .
10
wod(τ) = min{min{cox(τ) + Ch(tox(τ)): h∈Kxd}: x∈FS(o)} .
Moreover, because the term cox(τ) is common to all the terms of the inner minimization, the
above relation becomes:
wod(τ) = min{cox(τ) + min{Ch(tox(τ)): h∈Kxd}: x∈FS(o)} ,
Note that to establish equation (12), where the temporal point of view is the exit time from
the node, we have exploited the version of the concatenation property referred to the departure
times. This formulation extends the so-called temporal-layer approach of the dynamic
shortest path problem proposed by Chabini (1998) for the discrete model.
d∈Z
τ
o∈N
(o, x)∈FS(o)
x∈N
cox(τ) + wxd(tox(τ))
tox(τ)
Figure 4. The Bellman relation in the temporal-layer formulation.
The Bellman relations (12) make up a system of non-linear equations in the temporal
profiles of the node minimum costs, whose unique solution can be formally denoted as:
w = w(c, t) . (13)
3.2 Trajectory formulation of the fastest dynamic path problem
In general it is not possible to establish a local formulation of the dynamic shortest path
problem analogous to (12) by exploiting the version of the concatenation property referred to
the arrival times at the destination.
However, if the FIFO rule is satisfied, then we can prove that the concatenation property
holds true with respect to travel times:
- if k∈Kod is a fastest path from o∈N to d∈Z for users arriving at time τ, the sub-path k2 of
k from any intermediate node x to d is fastest for users arriving at time τ, and the sub-path k1
of k from o to x is fastest for users arriving at time Tk2-1(τ) in x.
Proof. If by contradiction there is a path h∈Kxd from x to d that for users arriving to d at
11
time τ is faster than the sub-path k2, then users departing from o can use the sub-path k1 to
arrive in x at time Th-1(τ) > Tk2-1(τ) and then path h to arrive in d at time τ. For the FIFO rule
(6) these users enter this path in o at time Tk1-1(Th-1(τ)) > Tk1-1(Tk2-1(τ)) = Tk-1(τ) . Therefore, k
is not a fastest path to arrive in d at time τ departing from o, which contradicts the first
hypothesis. ♦
Consider the problem of finding the maximum departure time zod(τ) from each node o∈N
to arrive in a given destination d∈Z exactly at time τ:
zod(τ) = max{Tk-1(τ): k∈Kod} . (14)
Based on the FIFO rule (6), for any path k∈Kod if τ′ < τ it is Tk-1(τ′) < Tk-1(τ). On this basis,
to arrive at destination earlier than τ is never convenient in terms of departure time. Therefore,
(14) is equivalent to the problem of finding the maximum departure time from o to arrive no
later than τ in d:
zod(τ) = max{Tk-1(τ′): k∈Kod , τ′ ≤ τ} . (15)
Moreover, (14) is equivalent to the problem of finding the minimum travel time τ-zod(τ)
from o to arrive in d at time τ:
τ-zod(τ) = min{τ-Tk-1(τ): k∈Kod}. (16)
On these bases, we can prove that the following version of the Bellman relation (Figure 5)
referred to the arrival time at destination is equivalent to problem (14):
zod(τ) = max{tox-1(zxd(τ)): x∈FS(o)} . (17)
zod(τ) = max{tox-1(Th-1(τ)): x∈FS(o), h∈Kxd} .
zod(τ) = max{max{tox-1(Th-1(τ)): h∈Kxd}: x∈FS(o)} .
Because the FIFO rule (6) holds true, we have:
max{tox-1(Th-1(τ)): h∈Kxd} = tox-1(max{Th-1(τ): h∈Kxd}).
Therefore, the above relation becomes:
zod(τ) = max{tox-1(max{Th-1(τ): h∈Kxd}): x∈FS(o)} ,
The concatenation property allows to establish a formulation of the dynamic fastest path
problem where the temporal point of view is the arrival time at the destination, which extends
the so-called trajectory approach, presented in Kaufmann and Smith (1993) for the discrete
12
model. Clearly, if the arc costs are proportional to the travel times, finding the fastest path
coincides with finding the shortest path.
τ
d∈Z
tox-1(zxd(τ))
o∈N
(o, x)∈FS(o)
x∈N
zxd(τ)
Figure 5. The Bellman relation in the trajectory formulation.
The Bellman relations (17) make up a system of non-linear equations in the temporal
profiles of the node maximum departure times, whose unique solution can be formally
denoted as:
z = z(t) . (18)
4 PATH CHOICE AND NETWORK FLOW PROPAGATION

In this section we develop two formulations for the dynamic network loading map with
implicit path enumeration in the case of deterministic route choice model.
4.1 Temporal-layer formulation
Under the assumption that users are perfectly informed rational decision-makers, the
resulting behaviour is such that only shortest paths are utilized. The deterministic route choice
model for users that travel between the origin o∈N and the destination d∈Z departing at time
τ, can then be formulated through the following extension to the dynamic case of Wardrop’s
first principle:
- if the generic path k∈Kod is used, i.e., its choice probability Pk(τ) is positive, then its cost
Ck(τ) is equal to the minimum cost wod(τ) to travel between o and d departing at time τ;
- vice versa, if path k is unused, i.e., its choice probability is null, then its cost may not be
smaller than the minimum cost.
This can be formally expressed as follows:
13
Pk(τ) ⋅ [Ck(τ) - wod(τ)] = 0 . (19)
Moreover, the choice probabilities must satisfy the following structural conditions:
∑ k∈Kod Pk(τ) = 1 , (20)
Pk(τ) ≥ 0 . (21)
To be notice that, when there is more than one shortest path between any o-d pair, the
choice probability pattern solving the system (19)÷(21) is not unique.
In the following we device a formulation based on implicit path enumeration for the route
choice model (19)÷(21) and for the corresponding network flow propagation model adopting
the temporal-layer approach, where the temporal perspective is the exit time from the current
node.
When the shortest paths from o∈N to d∈Z for users departing at time τ involve more than
one arc exiting from o, then the conditional probabilities of these arcs at time τ for users
directed to d depend, in general, on the sub-path so far utilized. Yet, for a given cost pattern,
there is always some solution of the system (19)÷(21) consistent with the following
assumption:
- the arc conditional probabilities at each node are equal for all users directed to the same
destination regardless of the sub-path so far utilized.
Then, referring to these solutions, the choice probability Pk(τ) of the generic path k∈Kod
from o∈N to d∈Z for users departing at time τ is equal to the product of the conditional
probabilities of its arcs A(k), each of them referred to the time when these users enter the arc
when travelling along the path. The choice probability of k can be then retrieved through the
following recursive expression:
Pk(τ) = poxd(τ) ⋅ Ph(tox(τ)), (22)
where (o, x) is the first arc of k and h∈Kxd is the rest of path k.
On this basis we can prove that the deterministic specification of the path choice
probabilities defined by the model (19)÷(21) is equivalent to the specification of the arc
conditional probabilities defined by the following system:
poxd(τ) ⋅ [cox(τ) + wxd(tox(τ)) - wod(τ)] = 0 , (23)
∑ (o, x)∈FS(o) poxd(τ) = 1 , (24)
poxd(τ) ≥ 0 . (25)
Equation (23) states that users exiting at time τ from node o∈N and directed to the destination
d∈Z may choose among the forward star FS(o) only an arc (o, x) for which the cost cox(τ) plus
14
the minimum cost wxd(tox(τ)) to reach the destination once entered x at time tox(τ) is equal to
the minimum cost wod(τ). The arc conditional probabilities comply with this deterministic
behavioural scheme and must satisfy the structural conditions (24) and (25).
Proof. Based on (20), the following identity holds true:
poxd(τ) = poxd(τ) ⋅ ∑ h∈Kxd Ph(tox(τ)) .
Multiplying both sides by wod(τ), we obtain:
poxd(τ) ⋅ wod(τ) = ∑ h∈Kxd poxd(τ) ⋅ Ph(tox(τ)) ⋅ wod(τ) .
Let path k∈Kod result from the composition of arc (o, x) and path h∈Kxd .
Based on (19) and (22), if Pk(τ) = poxd(τ) ⋅ Ph(tox(τ)) > 0 then it is wod(τ) = Ck(τ), otherwise
Pk(τ) = poxd(τ) ⋅ Ph(tox(τ)) = 0. Therefore, based on (2), the identity becomes:
poxd(τ) ⋅ wod(τ) = ∑ h∈Kxd poxd(τ) ⋅ Ph(tox(τ)) ⋅ [cox(τ) + Ch(tox(τ))] .
The above equation can be written as:
poxd(τ) ⋅ wod(τ) = poxd(τ) ⋅ [cox(τ) ⋅ ∑ h∈Kxd Ph(tox(τ)) + ∑ h∈Kxd Ph(tox(τ)) ⋅ Ch(tox(τ))] .
Based on (19), if Ph(tox(τ)) > 0 then Ch(tox(τ)) = wxd(tox(τ)), otherwise Ph(tox(τ)) = 0. Then, it is:
∑ h∈Kxd Ph(tox(τ)) ⋅ Ch(tox(τ)) = wxd(tox(τ)) ⋅ ∑ h∈Kxd Ph(tox(τ)) ⋅.
Moreover, based on (20), it is:
∑ h∈Kxd Ph(tox(τ)) = 1 .
Therefore, the above equation coincides with (23). ♦
When there is more than one arc exiting from a given node that yields the minimum cost to
reach a destination, the arc conditional probability pattern solving the system (23)÷(25) is not
unique, and is then formally expressed through the following point-to-set map:
p ∈ pTL(w, c, t) . (26)
For a given performance pattern, the set of path choice probability patterns obtained by
composing the maps (26) through the recursive equation (22) is only a subset of the solutions
to the system (19)÷(21). However, because when solving the assignment problem we just
need to determine any point of the choice map, this circumstance does not constitute a
relevant limitation of the implicit path formulation at hand.
The flow foxd(τ) of vehicles directed to destination d∈Z that enter the generic arc (o, x)∈A
at time τ is given by the arc conditional probability poxd(τ) multiplied by the flow exiting from
node o at time τ. The latter is given, in turn, by the sum of the outflow eyod(τ) from each arc
(y, o)∈BS(o) entering o, and of the demand flow Dod(τ) from o to d reduced by the vehicle
occupancy coefficient μ > 0. Then, we have:
15
foxd(τ) = poxd(τ) ⋅ [Dod(τ) / μ + ∑ (y, o)∈BS(o) eyod(τ)] . (27)
Applying the FIFO and vehicle conservation rules (Cascetta, 2001, p. 376) the outflow at
time τ can be expressed in terms of the inflow at time tyo-1(τ):
eyod(τ) = fyod(tyo-1(τ)) / [dtyo(τ)/dτ] , (28)
where the weight dtyo(τ)/dτ stems from the fact that travel times vary over time, so that users
exit from y at a certain rate and, in general, enter in o at a different rate, which is higher than
the previous one, if the arc travel time is decreasing, and lower, otherwise.
The total flow entering arc (o, x)∈A at time τ is then:
fox(τ) = ∑ d∈Z foxd(τ) . (29)
Based on (27) and (28), equation (29) is expressed formally by the following functional:
f = ωTL(p, t ; D) . (30)
4.2 Trajectory formulation
The route choice model (19)÷(21) reproduces the behaviour of users that depart from their
origin at a given instant to arrive in their destination at a later time. In the following we
address instead the route choice of users that wish to arrive at their destination no later than a
given instant departing from their origin at an earlier time, analyzing under which conditions
the latter behaviour leads to the same path probabilities of the former.
To this end we will refer to the case where costs are proportional to travel times and users
are perfectly informed rational decision-makers. The resulting behaviour in both cases is such
that only fastest paths are utilized.
Under the hypothesis that the FIFO rule is satisfied, to anticipate the arrival at destination
is never convenient in terms of departure time, so that users will arrive exactly at the latest
possible instant. Moreover, the following property holds true:
- a path k∈Kod from o∈N to d∈Z is fastest for users that arrive in d at time τ, if and only if
it is fastest for users that depart from o at time Tk-1(τ).
Proof. Let k∈Kod from o∈N to d∈Z be fastest for users that depart from o at time Tk-1(τ).
Assume by contradiction that k is not fastest for users that arrive to d at time τ. Let thus h∈Kod
be a path such that Tk-1(τ) < Th-1(τ). Based on the FIFO rule (4), it is: Th(Tk-1(τ)) < Th(Th-1(τ)).
Then, we have: Th(Tk-1(τ)) < τ = Tk(Tk-1(τ)), which contradicts the first hypothesis.
Let k∈Kod from o∈N to d∈Z be fastest for users that arrive in d at time τ. Assume by
contradiction that k is not fastest for users that depart from o at time Tk-1(τ). Let thus h∈Kod be
a path such that Th(Tk-1(τ)) < τ. Based on the FIFO rule (6), it is: Th-1(Th(Tk-1(τ))) < Th-1(τ).
16
Then, we have: Tk-1(τ) < Th-1(τ), which contradicts the first hypothesis. The assertion follows. ♦
On these bases, the choice probability of path k∈Kod from o∈N to d∈Z for users that wish
to arrive in d no later than time τ is equal to the choice probability Pk(Tk-1(τ)) of path k for
users that depart from o at time Tk-1(τ) and arrive to d at time τ. The deterministic route choice
model for users that travel between the origin o∈N and the destination d∈Z to arrive no later
than time τ, can then be formulated through the following extension to the dynamic case of
Wardrop’s first principle:
- if the generic path k∈Kod is used, i.e., its choice probability Pk(Tk-1(τ)) is positive, then its
departure time Tk-1(τ) is equal to the maximum departure time zod(τ) to travel between o and d
arriving at time τ;
- vice versa, if path k is unused, i.e., its choice probability is null, then its departure time
may not be later than the maximum departure time.
This can be formally expressed as follows:
Pk(Tk-1(τ)) ⋅ [Tk-1(τ) - zod(τ)] = 0 . (31)
∑ k∈Kod Pk(Tk-1(τ)) = 1 , (32)
Pk(Tk-1(τ)) ≥ 0 . (33)
It is worth noting that, although the fastest paths from o∈N to d∈Z for users arriving to d at
time τ coincide with the fastest paths for users departing from o at the corresponding
maximum departure time zod(τ), the travel times of the paths that are not shortest are evaluated
at different instants in the two cases, and then may well differ from each other. However, in
the deterministic case only the fastest paths have a positive choice probability, while the other
paths have null probability, and in this sense the route choice model (31)÷(33) is equivalent to
the model (19)÷(21).
In the following we device a formulation based on implicit path enumeration for the route
choice model (31)÷(33) and for the corresponding network flow propagation model adopting
the trajectory approach, where the temporal perspective is the arrival time at the destination.
To this end, we refer in the following to those solutions of the system (31)÷(33) which are
consistent with the assumption that “the arc conditional probabilities at each node are equal
for all users directed to the same destination regardless of the sub-path so far utilized”. On this
basis, we can prove that the deterministic specification of the path choice probabilities defined
by the model (31)÷(33) is equivalent to the specification of the arc conditional probabilities
defined by the system of the structural conditions (24) and (25) and of the following equation:
17
poxd(tox-1(zxd(τ))) ⋅ [tox-1(zxd(τ)) - zod(τ)] = 0 , (34)
to be considered jointly for all instants.
Equation (34) states that at node o∈N users arriving at time τ to the destination d∈Z may
choose among the forward star FS(o) only an arc (o, x) for which, given that the exit time is
the maximum departure time zxd(τ) from x, the corresponding entrance time tox-1(zxd(τ)) is the
latest possible and is then equal to the maximum departure time zod(τ) from o.
Proof. Based on (20), the following identity holds true:
poxd(tox-1(zxd(τ))) = poxd(tox-1(zxd(τ))) ⋅ ∑ h∈Kxd Ph(zxd(τ)) .
Multiplying both sides by zod(τ), we obtain:
poxd(tox-1(zxd(τ))) ⋅ zod(τ) = ∑ h∈Kxd poxd(tox-1(zxd(τ))) ⋅ Ph(zxd(τ)) ⋅ zod(τ) .
Let path k∈Kod result from the composition of arc (o, x) and path h∈Kxd .
Based on (31) and (22), if Pk(tox-1(zxd(τ))) = poxd(tox-1(zxd(τ))) ⋅ Ph(zxd(τ)) > 0, then, consistently
with the concatenation property k is fastest departing at time tox-1(zxd(τ)) from o and h is fastest
departing at time zxd(τ) from x. Therefore, it is: Th-1(τ) = zxd(τ) and Tk-1(τ) = zod(τ). Since by
construction it is: Tk-1(τ) = tox-1(Th-1(τ)), we have: zod(τ) = tox-1(zxd(τ)) . Otherwise it is:
Pk(tox-1(zxd(τ))) = poxd(tox-1(zxd(τ))) ⋅ Ph(zxd(τ)) = 0. Then, the identity becomes:
poxd(tox-1(zxd(τ))) ⋅ zod(τ) = ∑ h∈Kxd poxd(tox-1(zxd(τ))) ⋅ Ph(zxd(τ))⋅ tox-1(zxd(τ)) .
Based on (20), it is:
∑ h∈Kxd Ph(zxd(τ)) = 1 .
Therefore, the above equation coincides with (34). ♦
Unlike (23), equation (34) does not reproduce the local arc choice referred to a given
instant at node o, but rather restraints the conditional probabilities to be consistent with the
path choice referred to the arrival time at the destination d. However we can prove that the
above formulation is equivalent to the following local specification of the arc conditional
probabilities, where the same behaviour at node o∈N expressed by (34) for users arriving at
time τ in d is attributed to users departing at time zod(τ) from o:
poxd(zod(τ)) ⋅ [tox-1(zxd(τ)) - zod(τ)] = 0 , (35)
∑ (o, x)∈FS(o) poxd(zod(τ)) = 1 , (36)
poxd(zod(τ)) ≥ 0 . (37)
Proof. If tox-1(zxd(τ)) = zod(τ) then the equivalence between (35) and (34) follows
immediately. Let us then consider the non trivial case where tox-1(zxd(τ)) < zod(τ). Based on
(34), it is: poxd(tox-1(zxd(τ))) = 0 . Assume by contradiction that poxd(zod(τ)) > 0 . This implies
18
that there exists a path k∈Kod passing through node x at time tox(zod(τ)) that is fastest for users
departing from o at time zod(τ) and arriving in d at time τ. Since also the sub-path of k from x
to d shall be fastest, then we have: tox(zod(τ)) = zxd(τ). Taking the inverse of both sides we
obtain: zod(τ) = tox-1(zxd(τ)), which contradicts the hypothesis. ♦
When there is more than one arc exiting from a given node that yields the maximum
departure time to reach a destination within a particular instant, the arc conditional probability
pattern solving the system (35)÷(37) is not unique, and is then formally expressed through the
following point-to-set map:
p ∈ pTJ(z, t) . (38)
For a given performance pattern, the set of path choice probability patterns obtained by
composing the maps (38) through the recursive equation (22) is only a subset of the solution
set of the system (31)÷(33). However, because when solving the assignment problem we just
need to determine any point of the choice map, this circumstance does not constitute a
relevant limitation of the implicit path formulation at hand
The flow foxd(zod(τ)) of vehicles arriving to destination d at time τ that enter arc (o, x) at
time zod(τ) can be expressed through equation (27) as:
foxd(zod(τ)) = poxd(zod(τ)) ⋅ [Dod(zod(τ)) / μ + ∑ (y, o)∈BS(o) eyod(zod(τ))] . (39)
If eyod(zod(τ)) > 0 then pyod(tyo-1(zod(τ))) > 0 so that based on (34) it is tyo-1(zod(τ)) = zy(τ);
based on (28) we have then:
eyod(zod(τ)) = fyod(zy(τ)) ⋅ [dzyd(τ)/dτ] . (40)
The total flow entering arc (o, x)∈A at time zod(τ) is then:
fox(zod(τ)) = ∑ d∈Z foxd(zod(τ)). (41)
Based on (39) and (40), equation (41) is expressed formally by the following functional:
f = ωTJ(p, z ; D) . (42)
5 ARC PERFORMANCE MODEL

The arc performance model yields the temporal profiles of the arc exit times for given
temporal profiles of the arc inflows. For a detailed review on this topic, the reader is referred
to Gentile, Meschini and Papola (2005a), where macroscopic flow models are investigated in
the continuous framework at hand, and to Gentile, Meschini and Papola (2005b), where
spillback modelling is addressed. We consider here the simple case of a road link with a
constant speed that has a bottleneck with a fixed exit capacity at the end.
19
When there is no queue, the vehicles travel along the generic arc (x, y)∈A of length Lxy > 0
at the speed Vxy > 0, so that their travel time is Lxy / Vxy . But when the inflow fxy(τ) exceeds
the arc exit capacity λxy > 0, an over-saturated queue occurs. If the queue arises at time
θ + Lxy / Vxy , the exit time of a vehicle entering the arc at time τ ≥ θ is equal to that time plus
the time that takes to all the vehicles that entered the arc between θ and τ to pass through the
bottleneck at the maximum rate λxy . As depicted in Figure 6, the worst case dominates the
others. Then, we have:
τ
txy(τ) = max{θ + Lxy / Vxy + θ ∫ fxy(t) ⋅ dt / λxy: θ ≤ τ} , in compact form: t = t( f ) . (43)
vehicles
cumulative outflow
temporal profile
cumulative inflow
temporal profile λxy
τ
∫θ
f xy (t ) ⋅ dt
Lxy / Vxy
time
θ τ txy(τ)
Figure 6. The arc exit time of a bottleneck with a fixed exit capacity.
For the bottleneck model (44), only the non-strict version of the FIFO rule holds true.
τ′
Indeed, if no vehicle enters the arc between any τ and τ′ > τ, that is τ ∫ fxy(t) ⋅ dt = 0 , while the
queue is vanishing, that is txy(τ′) > τ′ + Lxy / Vxy , equation (3) is violated, since we have that
txy(τ′) = txy(τ). However, in the trajectory formulation we need the strict FIFO rule to ensure
the invertibility of the exit time temporal profiles. With this aim, we propose a slight
modification of (44) that forces equation (3) to hold, by introducing a small artificial positive
lower bound ξ > 0 to the inflow as follows:
τ
txy(τ) = max{θ + Lxy / Vxy + θ ∫ max{fxy(t), ξ} ⋅ dt / λxy: θ ≤ τ} , in compact form: t = t( f ) , (44)
which affects the travel time temporal profile only locally.
The cost of the generic arc (x, y)∈A at time τ is given by the sum of the travel time txy(τ)-τ ,
scaled by the value of time η > 0, and of the monetary cost sxy(τ) > 0, or toll, paid by users
entering the arc at time τ:
20
cxy(τ) = η ⋅ [txy(τ) -τ] + sxy(τ) , in compact form: c = c(t) . (45)
Based on (44) and (45) the arc cost and travel time temporal profiles are positive and, if the
monetary costs are uniformly bounded from above, they take value between two positive
constants.
6 USER EQUILIBRIUM
All the components of DTA have been introduced. Here we formulate the user equilibrium,
where no user can reduce his perceived travel cost by unilaterally changing path, as a fixed
point problem in the temporal profiles of the arc inflows.
6.1 The deterministic case
The formulation of DTA with implicit path enumeration proposed in Bellei, Gentile and
Papola (2005), where the case of a logit route choice model is addressed, is here extended to
the deterministic case, yielding the two models synthetically depicted in Figure 7.
TEMPORAL LAYER FORMULATION TRAJECTORY FORMULATION
network loading map network loading map

TL
p (w, t, c)
D D
p w p pTJ(z, t) z
ωTL( p, t ; D) w(c, t) ωTJ( p, z ; D) z(t)
f t c f t
t( f ) c(t) t( f )
arc performance model arc performance model
Figure 7. Formulations of DTA with implicit path enumeration in the deterministic case.
In analogy with the static case, the Network Loading Map (NLM) is a functional relation
yielding, for given demand flows D, an arc flow pattern f consistent with the arc performances
t, and c, through the deterministic route choice model pTJ(z(t), t), or pTL(w(c, t), t, c), and the
network flow propagation model ωTJ( p, z ; D), or ωTL( p, t ; D), respectively for the trajectory
and the temporal layer formulations. These two models have been formulated with implicit
path enumeration by introducing the node minimum departure times z, or cost w, and the arc
21
conditional probabilities p. Note that the dashed arrows indicate any solution of the
corresponding choice map. In turn, the arc performance model yields the arc exit time pattern
t, and the arc cost pattern c, consistent with the arc inflows f.
The deterministic user equilibrium is formally given by the system of the NLM and of the
arc performance model, which can be formulated as fixed point problem in terms of the arc
inflow temporal profiles, as specified in the following.
The combination of the node minimum cost model (13) and of the arc conditional
probability model (26) with the network flow propagation model (30) yields the temporal-
layer formulation of the deterministic NLM with implicit path enumeration:
f ∈ ωTL(pTL(w(c, t), c, t), t ; D) = fDETTL(c, t ; D) . (46)
Combining (46) with the arc performance model (44)÷(45), we have:
f ∈ fDETTL(c(t( f )), t( f ) ; D) . (47)
Analogously, the combination of the minimum departure time model (18) and of the arc
probability model (38) with the flow propagation model (42) yields the trajectory formulation
of the NLM with implicit path enumeration:
f ∈ ωTJ(pTJ(z(t), t), z(t) ; D) = fDETTJ(t ; D) . (48)
Combining (48) with the arc exit time model (44), we have:
f ∈ fDETTJ(t( f ) ; D) . (49)
6.2 The Probit case
In the Probit route choice model, which is based on the random utility theory, the arc costs
perceived by users are not known with certainty and are thus regarded as independent random
variables. More details can be found in Cascetta (2001) with reference to the static case. Here,
we extend the Probit model to the dynamic case assuming that the arc cost ĉxy(τ) of the
generic arc (x, y)∈A perceived by users at time τ is equal to the sum of the arc cost cxy(τ)
yielded by the arc performance model and of a time-varying random error, whose value at
time τ is distributed as a normal variable. Its variance is assumed proportional, through a
constant coefficient ξ > 0, to a time-varying cost term χxy(τ) > 0 independent of congestion.
The arc flow pattern resulting from the evaluation of the Probit NLM for given arc
performances is obtained through the well-known Montecarlo method, as follows.
a) Get a sample of Η perceived arc cost patterns:
ĉxyh(τ) = cxy(τ) + ψxyh⋅[ξ⋅χxy(τ)]0.5, in compact form: ĉ h = ĉ(c ; χ) , (50)
where each ψxyh is extracted from a standard normal variable N[0,1] and h = 1, … , Η.
22
b) For each perceived arc cost pattern of the sample, determine through the deterministic
NLM (46) a consistent arc inflow pattern. We have in compact, form for h = 1, … , Η :
f h ∈ fDETTL(ĉ h, t ; D) . (51)
c) Calculate the average of the resulting deterministic arc inflow patterns, thus obtaining an
undistorted estimation of the Probit arc inflow pattern; formally:
f = 1/Η ⋅ ∑ h = 1, … , Η f h . (52)
Note that, based on (50), the same outcome ψxyh of the standard normal variable is used to
perturb the whole temporal profile ĉxyh(τ). This is consistent with the behaviour of users, who
perceive the arc cost temporal profile as a whole. On the contrary, the travel times that
underlie the network flow propagation, are considered as constant throughout the simulation.
The Probit NLM evaluated through (50)÷(52), which for Η → ∞ is indeed a point-to-point
map that can be formally expressed as:
f = fPROBTL(c, t ; D) . (53)
Combining (53) with the arc performance model (44)÷(45), yields a stochastic formulation of
the user equilibrium in the dynamic framework at hand:
f = fPROBTL(c(t( f )), t( f ) ; D) . (54)
An analogous formulation can be developed adopting the trajectory approach:
f = fPROBTJ(t( f ) ; D) . (55)
7 SOLUTION ALGORITHMS
In order to implement the proposed models, the period of analysis [0, Θ] is divided into n
time intervals identified by the sequence of instants τ = {τ0, … , τi, … , τn}, with τ0 = 0, τi < τj
for any 0 ≤ i < j ≤ n, and τn = Θ. For computational convenience, we introduce also an
additional instant τn+1 = ∞.
In the following we approximate the generic temporal profile g(τ) of the performance and
flow variables introduced in the previous sections, respectively, through a piecewise linear
and a piecewise constant function, defined by the values gi = g(τi) taken at each instant τi∈τ.
Under this assumption, for τ∈[τi, τi+1), with 0 ≤ i ≤ n-1, in the two cases we have,
respectively:
g(τ) = gi + (τ - τi) ⋅ (gi+1 - gi) / (τi+1 - τi) , (56.1)
g(τ) = gi . (56.2)
This way, the generic temporal profile g(τ) can be then represented numerically through the
23
(1 × n+1) row vector g = (g0, … , gi, … , gn).
7.1 Temporal-layer network loading map
In this section, we first propose a heuristic to solve the many-to-one temporal-layer

formulation of the dynamic shortest path problem presented in sections 3.1, under the
assumption that (56) holds true. On this basis, a procedure implementing the route choice and
the network flow propagation models presented in section 4.1 is then developed, consistently
with an all-or nothing assignment to a shortest path. This algorithm yields, indeed, a specific
value of the deterministic NLM (46) with implicit path enumeration, such that all vehicles vxd i
travelling to a same destination d∈Z that exit any node x∈N during the generic time interval
[τi, τi+1), with 0 ≤ i ≤ n-1, are propagated forward on one arc only, whose head σxd i is called
the successive node.
At this stage we consider as an input the exit time txyi and the cost cxyi of every arc (x, y)∈A
at any entrance time τi∈τ, and aim at determining the minimum cost wxd i from every node
x∈N to a given destination d∈Z departing at each time τi∈τ. Based on the Bellman relation
(12), these node minimum cost satisfy the following:
wxd i = min{cxyi + wyd(txyi): y∈FS(x)} , (57)
where, by letting j be such that txyi∈[τj, τj+1), based on (56.1) we can write:
wyd(txyi) = wyd j + (wyd j+1 - wyd j) ⋅ (txyi - τj) / (τj+1 - τj) . (58)
Since the network is unloaded outside the period of analysis, when the temporal profile of
the node minimum cost is to be evaluated at any time τ > τn, we consider the value that it
takes at τn : wxd(τ) = wxd n.
Under the condition of short time intervals such that the exit time txyi of every arc (x, y)∈A
at any entrance time τi ∈ τ\{τn} is not earlier than the next instant τi+1:
txyi ≥ τi+1 , (59)
the solution to above system of Bellman relations can be simply addressed by performing the
local search (57) for all the temporal layers, but the last one, in reverse chronological order,
and for all the nodes in no particular order, after a static shortest path problem is solved
adopting any classical approach to determine the node minimum costs at time τn (Chabini,
1998). Indeed, in this case the time index j in (58) is greater than i, so that when wxd(txyi) is
evaluated, it is a function of node minimum costs that have already been computed. The node
among the forward star of x that yields the maximum value for wxd i is recorded in σxd i to hold
a solution also in terms of shortest paths.
24
However, condition (59) may result very onerous in terms of computing times, since it
leads to introduce many time intervals in order to cover a given period of analysis. This is
particularly true for urban road networks, where the links can be very short and in some cases
even the single maneuvers at intersections are modeled as separate arcs of the graph.
In the following we will consider long time intervals for which condition (59) does not
hold true in general. In this case equation (57)÷(58) expresses the minimum cost wxd i of node
x∈N at time τi∈τ as a function of the minimum costs wyd j of each node y∈FS(x), that can be
evaluated not only at later times τj > τi, but also at the same time τi, depending on the exit
time txyi. Consequently, as it is depicted in Figure 8, if txyi < τi+1, since wyd(txyi) is a monotone
decreasing function of wyd i, when wyd i is improved, then also wxd i may improve.
cost
wyd(τ)
wyd(txyi)
wyd i
time
τ i
txyi τ i+1
τ i+2
Figure 8. Consequence of long time intervals in the temporal-layer algorithm.
In this case the resulting system of Bellman relations for the generic temporal layer, given
the solution for the successive temporal layers, cannot be solved by adopting any of the
classical approaches valid for the static shortest path problem, since its solution in terms of
successive nodes may involve cycles. For instance, this circumstance makes a label correcting
procedure converge to the solution in an infinite number of iterations, yielding the so-called
absorbing cycles. Moreover, the presence of cycles affects the solution of the network flow
propagation model as well.
Since cycles are not desirable from a computational point of view, we force an acyclic
solution for each i-th temporal layer. Specifically, we adopt a label setting approach, where
iteratively a node y∈N is extracted from a list of nodes to be examined, and from that moment
its minimum cost is not modified anymore, even if it could be improved. Then, for each node
x∈BS(y) not yet extracted from the list, if cxyi + wyd(txyi) is lower than wxd i, its minimum cost is
25
updated, y is recorded as its successive node σxd i, and x is inserted in the list of nodes to be
examined; indeed, its improved cost may be exploited by the nodes of its backward star (see
Figure 9). Each node minimum cost is initialized to infinity, except for node d whose cost to
the destination is zero, the list of nodes to be extracted is initialized as empty, and any
classical approach is applied to determine the solution at time τn.
cxri + wrd(txri) = wxd i ≤ cxyi + wyd(txyi)

x∈BS(y)
τi
y∈N
txyi
r = σxd i∈FS(x) txri
d∈Z
Figure 9. Bellman relation and successive node in the temporal-layer algorithm.
By construction the arcs (x, σxd i) corresponding to the successive nodes that yielded the
last improvement for each x∈N form a tree, and the extraction order of the nodes from the list
constitutes a topological order. This is crucial to perform efficiently the network flow
propagation.
The extracted nodes are recorded in an ordered set Q i, where Q i(q) is the q-th node in
topological order, which is also used in the network flow propagation to visit the nodes in
reverse topological order.
More specifically, we adopt a Dijkstra-like approach, where the node extracted from the
list is that with the minimum cost to reach the destination. Contrary to the static case, this
does not at all guarantee to obtain the exact solution to the system of Bellman relations for the
generic temporal layer, since we have showed that the potential occurrence of cycles is an
intrinsic characteristic of the problem. On the other hand, to extract the nodes from the list
with any order related solely to the connectivity may lead to even higher approximations.
Moreover, cycles do not occur if the FIFO rule holds and the arc costs are proportional to the
arc travel times, so that the proposed algorithm in this case yields the exact solution.
However, to maintain a precise ordering of the nodes by their current minimum cost within
26
the entire list, or even only for its first node (heap approach), is onerous, both in terms of
actual computing time and of theoretical complexity. Then we opt for a pseudo ordering based
on a bucket list. To this end, the non-negative real semi-axis of the node minimum costs is
partitioned by introducing the sequence of values ρ = (ρ0, … , ρh, … , ρm), with ρ0 = 0,
ρm = ∞, ρh < ρk for any 0 ≤ h < k ≤ m , which define a limited number m of intervals [ρh-1 , ρh),
called buckets. A set of nodes Bh ⊆ N is associated with the generic bucket, such that the
intersection of any two distinct sets is empty: Bh ∩ Bk = ∅, h ≠ k. When the minimum cost of
a node is improved, the node is removed from its current bucket Bk and is inserted in the
proper bucket Bh , depending on the current minimum cost, in such a way that
wxd i ∈ [ρh-1 , ρh). For computational convenience, we consider buckets of equal length Δρ, so
that we have: ρh = h ⋅ Δρ, with 0 ≤ h ≤ m-1. This way, indeed, the research of the proper
bucket Bh requires performing only a simple integer division: h = 1 + wxd i \ Δρ. Within each
bucket no ordering of the nodes is maintained.
At each iteration a node is extracted from the first non empty bucket. If the updated cost
label wxd i is always not smaller than the cost label wyd i of its successive node y = σxd i, then by
construction the buckets are visited only once in their natural order. Note that the additional
computational burden that the procedure has to feature in order to visit all the buckets is not
relevant for large network with thousands of nodes. For instance, if the costs are measured in
seconds, with say “only” one thousand buckets with a length of ten seconds we can cover a
cost range of almost three hours. Depending on the application scale and dimension, by
introducing an appropriate number of buckets m and by setting opportunely their length Δρ,
we can always find a suitable compromise between precision and computing times. Consider
also that the discretization of costs based on the buckets is definitely not the more important
approximation introduced in the proposed heuristic.
The network flow propagation model is solved accordingly to the approximate solution
determined for the dynamic shortest path problem in terms of successive nodes. This is
consistent with an all-or-nothing solution to the system (23)÷(25) that reproduces the
deterministic local choice at node x∈N in the generic instant τi∈τ, where for each y∈FS(x) it
is: pxyd(τi) = 1, if y = σxd i, and pxyd(τi) = 0, otherwise. Indeed, by construction σxd i is a node
y∈FS(x) such that cxyi + wyd(txyi) = wxd i, thus (23) is satisfied.
For given arc performances consistent with (56.1), the successive node y of x∈N that yields
at time τ∈[τi, τi+1), with 0 ≤ i ≤ n-1, the minimum cxy(τ) + wyd(ty(τ)) among its forward star
can change several times during the interval. However, consistently with (56.2), we assume:
27
pxyd(τ) = pxyd(τi) for τ∈[τi, τi+1), which implies the approximation to consider the successive
node constant during the interval and equal to σxd i. Under this assumption, all the vehicles
vxd i directed to d that exit node x during the interval [τi, τi+1), will enter arc (x, y), with
y = σxd i, and will exit it during the interval [txyi, txyi+1).
Therefore, these vehicles constitute the inflow of arc (x, y) directed to d, which based on
(56.2) is considered constant during the interval [τi, τi+1) and equal to fxyd i:
fxyd i = vxd i / (τi+1 - τi) . (60)
Based on (29), the latter contributes to the total inflow on the arc:
fxyi ← fxyi + fxyd i. (61)
Based on (28), the constant inflow and the linear exit time will produce a constant exit flow
exyd i during the interval [txyi, txyi+1):
exyd i = fxyd i ⋅ (τi+1 - τi) / (txyi+1 - txyi) , (62)
which, in turn, contributes to the number of vehicles vyd j exiting node y during each interval
[τj, τj+1), with i ≤ j ≤ n, that covers the interval [txyi, txyi+1), proportionally to the length of the
intersection:
vyd j ← vyd j + exyd i ⋅ mis{[τj, τj+1)∩[txyi, txyi+1)} . (63)
Since the number of vehicles vxd i are propagated forward on the successive node y = σxd i
and contribute to vyd j at non earlier intervals, the linear system of equations induced by (60),
(62) and (63) can be simply solved by processing the temporal layers in chronological order
and the nodes in reverse topological order, after the number of vehicles vod i that exit from
each origin o∈N during every interval [τi, τi+1), with 0 ≤ i ≤ n-1, is initialized consistently
with the demand flow Dod i:
vod i ← (Dod i / μ) ⋅ (τi+1 - τi) . (64)
It’s worth noting that, as depicted in Figure 10, for the first one and the last one of the
intervals [τj, τj+1) that overlap with [txyi, txyi+1) an approximation is introduced when the
contribution of vxd i is simply added to vyd j without keeping memory of its actual distribution
in time. Based on (60), this is equivalent to spread uniformly this flow on the interval [τj, τj+1).
Such a “spreading” error propagates downstream towards the destination, since it affects not
only the arc flows but also the node flows.
28
flow
vyd j d j+2
vyd j+1 vy
txyi txyi+1
exyd i
y
fxyd i vxd i time

x
τi τi+1 τi+2 τi+3
Figure 10. Network flow propagation in the temporal-layer algorithm.
The complete procedure implementing the temporal-layer algorithm for the deterministic
network loading map is described below.
function f = fDETTL(c, t ; D) * compute the deterministic network loading map

w=∞,f=0,v=0 * initialize node costs to infinity and flows to zero
B=∅ * initialize the bucket list as empty
for each d∈Z * for each destination d
* solve the dynamic shortest path problem

for i = n to 0 step -1 * process each i-th temporal layer in reverse chronological order
B1 = B1 ∪ {d} * initialize the first bucket with the destination
wdd i = 0 * the cost to reach the destination form d is zero
Qi = ∅ * initialize the list of extracted nodes as empty
for k = 1 to m * process each k-th bucket in the natural order
until Bk = ∅ do * until the bucket is empty
y∈Bk * let y be the any node of the bucket
Bk = Bk \ {y} * extract y from the bucket
i i
Q = Q ∪ {y} * insert y in the list of extracted nodes
for each x∈BS(y) * visit each node x in the backward star of y
if x∉Q i then * that has not been extracted yet
j=i * starting from i , scroll forward the time index j
until τj+1 > txyi do j = j + 1 loop * to find j such that txyi∈[τj, τj+1)
* evaluate the minimum cost from x to d using arc (x, y) departing at τi
if j = n then * for the last temporal layer
n dn
ϕ = cxy + wy * apply a static Bellman relation
else
ϕ = cxyi + wyd j + (txyi - τj) ⋅ (wyd j+1 - wyd j) / (τj+1 - τj) * dynamic BR
end if
if ϕ < wxd i then * if this is better than the current cost from x
if wxd i < ∞ then * if x already belongs to the bucket list
h = 1 + wxd i \ Δρ * find the current bucket of x
29
Bh = Bh \ {x} * extract x from this bucket
end if
h = 1 + ϕ \ Δρ * find the proper bucket for x
Bh = Bh ∪ {x} * insert x in the proper bucket
wxd i = ϕ * update the current cost from x to d
di
σx = y * update the successive node of x
di
if ϕ < wy then k = h - 1 end if * in case, update the current bucket
end if
end if
next x
loop
next k
next i
* load on the nodes the demand flows

for each o∈N * for each origin o
for i = 0 to n-1 * for each i-th temporal layer
vod i = (Dod i / μ) ⋅ (τi+1 - τi) * load on o the flow departing to d during the interval
next i
next o
* solve the network flow propagation model

for i = 0 to n-1 * process each i-th temporal layer in chronological order
for q = |N| to 2 step -1 * process each node in reverse topological order q
x = Q i(q) * let x be the q-th node in this order
y = σxd i * let y be the successive node of x
* load on arc (x, y) the flow exiting from x during the i-th interval
fxyi = fxyi + vxd i / (τi+1 - τi)
j=i * starting from i , scroll forward the time index j
until τj+1 > txyi do j = j + 1 loop * to find j such that txyi∈[τj, τj+1)
* propagate this flow to y on the interval [txyi, txyi+1)
* splitting it among each overlapping interval [τj, τj+1)
if τj+1 ≥ txyi+1
vyd j = vyd j + vxd i
else
e = vxd i / (txyi+1 - txyi)
vyd j = vyd j + e ⋅ (τj+1 - txyi)
j=j+1
until τj+1 ≥ txyi+1 do
vyd j = vyd j + e ⋅ (τj+1 - τj)
j=j+1
loop
vyd j = vyd j + e ⋅ (txyi+1 - τj)
end if
next k
next i
next d
end function
30
Since each node may belong to only one bucket, the bucket list can be implemented with
one multi-list of nodes, which is to be doubly linked, since a node can be removed from any
position of the bucket sub-list when its minimum cost is updated. Therefore, to handle the
bucket list B we need two vectors BN and BP having dimension (1 x |N|), and two vectors BF
and BL having dimension (1 × m), where BNx and BPx indicate, respectively, the next and the
previous node in the list B with respect to the generic node x∈N, while BFh and BLh indicate,
respectively, the first and the last node of the generic bucket Bh , with 1 ≤ h ≤ m. Moreover,
by convention, we state that BFh = BLh = 0 if and only if the bucket h is empty, while if
BLh = x then BNx = 0, and if BFh = x then BPx = 0. Six types of operations are required to
handle the bucket list.
1) The initialization of the list as empty, that is B = ∅, is implemented as:
BP = BN = BF = BL = 0.
2) The check if bucket k is empty, that is Bk = ∅, is implemented as: BFk = 0 .
3) The selection of any node y from bucket k, that is y∈Bk , is implemented as: y = BFk .
4) The check if node x has already been extracted from the bucket list, that is x∉Q i , is
implemented as: BPx > 0 or [BPx = 0 and (wxd i = ∞ or BFh = x)], with h = 1 + wxd i \ Δρ.
Indeed, since any node is extracted from the bucket list when it is the first in its bucket, if
x∈Q i then it is BPx = 0. There are only two other cases where BPx = 0 : x has not been visited
yet, so that wxd i = ∞; x is the first node of its bucket, so that BFh = x.
5) The insertion of node x in bucket h, that is Bh = Bh ∪ {x}, is implemented by linking the
node to the end of the sub-list:
if BFh = 0 then BFh = x else BNBLh = x end if ,
BPx = BLh , BLh = x , BNx = 0 .
6) The extraction of node x from bucket h, that is Bh = Bh \ {x}, is implemented as:
if x = BFh then BFh = BNx else BNBPx = BNx end if ,
if x = BLh then BLh = BPx else BPBNx = BPx end if .
The ordered list of extracted nodes is implemented through a vector Q i having dimension
(1 x |N|), where Qqi indicates the q-th node in topological order. Three types of operations are
required to handle the ordered list of extracted nodes.
1) The initialization of the list as empty, that is Q i = ∅, is implemented as: q = 0.
2) The insertion of node y in the list, that is Q i = Q i ∪ {y}, is implemented as: q = q +1 , Qqi = y.
3) The selection of the q-th node in topological order, that is x = Q i(q), is implemented as: x = Qqi.
31
If the FIFO rule holds, when finding j ≥ i such that txyi∈[τj, τj+1), we can initialize j with the
time index resulting from the last search for the same arc. This would avoid, in case of long
arcs, to scroll many time indices and becomes essential in the next algorithm.
Finally note that, in practice, the model variables can be implemented with no destination
reference by reusing the same vectors in the outer cycle on d, thus achieving huge memory
savings.
7.2 Trajectory network loading map
In this section we first propose a heuristic to solve the many-to-one trajectory formulation
of the dynamic fastest path problem presented in sections 3.2, under the assumption that (56)
holds true. On this basis, a procedure implementing the route choice and the network flow
propagation models presented in section 4.2 is then developed, consistently with an all-or
nothing assignment to a fastest path. This algorithm yields, indeed, a specific value of the
deterministic NLM (48) with implicit path enumeration, such that all vehicles uxd i exiting any
node x∈N that arrive to a same destination d∈Z during the generic time interval [τi, τi+1), with
0 ≤ i ≤ n-1, are propagated forward on one arc only, whose head υxd i is called again the
successive node.
time
txy(τ)
j+1
txy
zyd i
txy j
time
τj txy-1(zyd i) τj+1
Figure 11. Determining the entrance time txy-1(zyd i) at time zyd i based on the piecewise linear
temporal profile txy(τ) of the exit time.
At this stage we consider as an input the exit time txyi of every arc (x, y)∈A at any entrance
time τi∈τ, and aim at determining the maximum departure time zxd i from every node x∈N to
reach a given destination d∈Z at the generic instant τi∈τ. Based on the Bellman relation (17),
these node maximum departure times satisfy the following:
32
zxd i = max{txy-1(zyd i) : y∈FS(x)} , (65)
where, by letting j be such that zyd i∈[txy j, txy j+1), based on (56.1) we can write:
txy-1(zyd i) = τj + (τj+1 - τj) ⋅ (zyd i - txy j) / (txy j+1 - txy j) , (66)
as shown in Figure 11.
In this context the issue of long time intervals is not relevant. Indeed, in (65)÷(66) all the
node maximum departure times are referred to the same instant of arrival to the destination
(see Figure 12), so that the resulting system of Bellman relations, which can be rewritten as:
[τi-zxd i] = min{[zyd i - txy-1(zyd i)] + [τi-zyd i] : y∈FS(x)} , (67)
is equivalent to a static shortest path problem, where the arc cost is [zyd i - txy-1(zyd i)] and the
node cost is [τi-zyd i]. So it can be solved applying any classical label setting or label correcting
approach (see for instance Bertsekas, 1993). Here, we will adopt the bucket list paradigm,
presented in the previous section.
txr-1(zrd i) = zxd i ≥ txy-1(zyd i)

x∈BS(y)
y∈N
zyd i
r = σxd i∈FS(x) zr d i
τi
d∈Z
Figure 12. Bellman relation and successive node in the trajectory algorithm.
Then, differently from the temporal-layer algorithm, it is not essential for the trajectory
algorithm to process the arrival times τ in any particular order. Notwithstanding it is
convenient from a computational point of view to process them in chronological order,
because this way, based on the FIFO rule, it is possible to begin the search for the time index j
such that zyd i∈[txy j, txy j+1) from the index Ixy found in the previous search for arc (x, y)∈A.
The network flow propagation model is solved accordingly with the solution determined
for the dynamic fastest path problem in terms of successive nodes. This is consistent with an
all-or-nothing solution to the system (35)÷(37) that reproduces the deterministic local choice
at node x∈N in the generic instant zxd i, with τi∈τ, where for each y∈FS(x) it is: pxyd(zxd i) = 1,
33
if y = υxd i, and pxyd(zxd i) = 0, otherwise. Indeed, by construction υxd i is a node y∈FS(x) such
that txy-1(zyd i) = zxd i, thus (35) is satisfied.
For given travel times consistent with (56.1), the successive node y of x∈N that yields for
the arrival time τ∈[τi, τi+1), with 0 ≤ i ≤ n-1, the maximum txy-1(zyd(τ)) among its forward star
can change several times during this interval. However, consistently with (56.2), we assume:
pxyd(τ) = pxyd(zxd i) for τ∈[zxd i, zxd i+1
), which implies the approximation to consider the
successive node constant during this interval and equal to υxd i. This is also equivalent to
consider that the fastest tree to destination d for users arriving there at time τ∈[τi, τi+1) is
constant during the interval and equal to that at time τi. On this basis, a change of fastest tree
can occur only for an arriving time τi+1, with 0 ≤ i ≤ n-1, when, since travel times are
continuous, the two different trees identified by the successive nodes at time τi and at time τi+1
are both fastest and yield equal maximum departure times for each node x∈N. Under this
assumption, all the vehicles uxd i directed to d that exit node x during the interval [zxi, zxi+1),
will enter arc (x, y), with y = υxd i, and will exit it during the interval [zyi, zyi+1).
zyd i zyd i+1

flow
vyd i
y
fxyd j fxyd j+1 fxyd j+2
zxd i zxd i+1

fxyd j+1 vxd i time
x j+1
τj τ τ j+2
τ j+3
Figure 13. Network flow propagation in the trajectory algorithm.
These vehicles contribute to the inflow fxyd j directed to d entering arc (x, y) during each
interval [τj, τj+1), with 0 ≤ j ≤ i, that covers [zxi, zxi+1), proportionally to the length of the
intersection (Figure 13):
fxyd j ← fxyd j + uxd i ⋅ mis{[τj, τj+1)∩[zxi, zxi+1)} / (zxi+1 - zxi) / (τj+1 - τj) . (68)
Based on (41), the latter contributes, in turn, to the total inflow on the arc:
fxy j ← fxy j + fxyd j. (69)
34
Moreover, these vehicles contribute to the number of vehicles uyd i directed to d that exit node
y during the interval [zyi, zyi+1):
uyd i ← uyd i + uxd i . (70)
Thus in the trajectory algorithm it is not necessary to introduce the arc exit flow. Figure 13
also shows that, differently from the temporal-layer algorithm, in the trajectory algorithm the
effect of the spreading error is local and does not propagate downstream.
Since the number of vehicles uxd i exiting each node x∈N that arrive to d during a particular
interval [τi, τi+1), with 0 ≤ i ≤ n-1, are propagated forward on the successive node y = υxd i, the
linear system of equations induced by (70) can be simply solved by processing the nodes in
reverse topological order, that is in order of maximum departure time.
Again, differently from the temporal-layer algorithm, it is not essential here to process the
arrival time intervals in any particular order. Notwithstanding it is convenient from a
computational point of view to process them in chronological order, because this way, based
on the FIFO rule, the earliest time interval [τj, τj+1), with 0 ≤ j ≤ i, that overlaps with
[zxd i, zxd i+1), with 1 ≤ i ≤ n-1, is the last time interval that overlaps with [zxd i-1, zxd i), so that the
current time index j can be recorded in a variable Ix for each node x∈N.
The number of vehicles exiting from each origin is to be initialized consistently with the
demand flows. To this end, the demand flow Dod i of users departing from each o∈N during
the generic interval [τi, τi+1), with 0 ≤ i ≤ n-1, is split among the number of vehicles uod j
exiting from o during each interval [zod j, zod j+1

), with 0 ≤ j ≤ i, that covers [τi, τi+1),
proportionally to the length of the intersection:
uod j ← uod j + (Dod i / μ) ⋅ mis{[zod j, zod j+1)∩[τi, τi+1)} . (71)
The above splitting procedure would not be necessary if the demand flows were refereed to
the arrival time at the destination. In such a case the initialization of node flows is simply
achieved as in (64), and it is then possible to perform the network flow propagation right after
the dynamic fastest path problem is solved, separately for each arrival time. This leads to
memory savings, since all the variables except for arc flows and travel times, can be
implemented with no time reference, and makes the resulting procedure to determine the
dynamic network loading map conceptually equivalent to a sequence of static network
loading maps. In alternative, the problem partition can be achieved by referring all the model
variables to the departure time from the origin.
The complete procedure implementing the trajectory algorithm for the deterministic
network loading map is described below.
35
function fDETTJ(t ; D) * compute the deterministic network loading map
z = -∞ , f = 0 , v = 0 * initialize node exit times to minus infinity and flows to zero
B=∅ * initialize the bucket list as empty
for each d∈Z * for each destination d
* solve the dynamic fastest path problem

for i = 0 to n * process each i-th arrival time in chronological order
B1 = B1 ∪ {d} * initialize the first bucket with the destination
di i
zd = τ * the travel time to reach the destination from d is zero
Qi = ∅ * initialize the list of extracted nodes as empty
for k = 1 to m * process each k-th bucket in the natural order
until Bk = ∅ do * until the bucket is empty
y∈BFk * let y be the any node of the bucket
Bk = Bk \ {y} * extract y from the bucket
Q i = Q i ∪ {y} * insert y in the list of extracted nodes
for each x∈BS(y) * visit each node x in the backward star of y
if zxd i < zyd i then * that has not been extracted yet
* evaluate the max. dep. time from x using arc (x, y) to arrive in d at τi
if i = 0 then * for the first arrival time
ϕ = zyd 0 - (txy0 - τ0) * apply a static Bellman Relation
Ixy = 0 * initialize the time index of arc (x, y)
else if zyd i < txy0 then * where the entrance time is not defined
d0 i 0
ϕ = zx - (τ - τ ) * consider an unloaded network
else
j = Ixy * starting from the current time index of arc (x, y)
until txy j+1 > zyd i do j = j + 1 loop * find j such that zyd i∈[txy j, txy j+1)
Ixy = j * update the time index for arc (x, y)
ϕ = τ + (τ - τj) ⋅ (zyd i - txy j) / (txy j+1 - txy j) * dynamic BR
i j j+1
end if
if ϕ > zxd i then * if this is better than the current departure time from x
if zxd i > -∞ then * if x already belongs to the bucket list
h = 1 + (τi - zxd i) \ Δρ * find the current bucket of x
Bh = Bh \ {x} * extract x from this bucket
end if
h = 1 + ϕ \ Δρ * find the proper bucket for x
Bh = Bh ∪ {x} * insert x in the proper bucket
zxd i = ϕ * update the current departure time from x
di
υx = y * update the successive node of x
end if
end if
next x
loop
next k
next i
* load on the nodes the demand flows

for each o∈N * for each origin o
i = n-1 * starting from the last tone, scroll backward the arrival time intervals
until τi < zod n do i = i - 1 loop * to skip those that do not overlap with [0, Θ]
36
j=n * initialize the time index j
for i = i to 0 step -1 * process each other i-th interval in chronological order
* load on origin o the demand flow to d departing within the interval [τi, τi+1)
* splitting it among each overlapping interval [zod j, zod j+1)
if zod j ≤ τi then
uod j = uod j + (Dod i / μ) ⋅ (τi+1 - τi)
else
uod j = uod j + (Dod i / μ) ⋅ (τi+1 - zod j)
j=j-1
until zod j ≤ τi do
uod j = uod j + (Dod i / μ) ⋅ (zod j+1 - zod j)
j=j-1
loop
uod j = uod j + (Dod i / μ) ⋅ (zod j+1 - τi)
end if
next i
next o
* solve the network flow propagation model

for i = 0 to n-1 * process each i-th time interval in reverse chronological order
for q = |N| to 2 step -1 * process each node in reverse topological order q
x = Q i(q) * let x be the q-th node in this order
y = υxd i * let y be the successive node of x
if zxd i+1 ≤ τ0 then * where [zxd i, zxd i+1) does not overlap with [0, Θ]
Ix = 0 * initialize the time index for node x
else
* load on arc (x, y) the flow exiting from x within the interval [zxd i, zxd i+1)
* splitting it among each overlapping interval [τj, τj+1)
j = Ix * start from the current time index of node x
j+1 i+1
if τ ≥ zx
fxy j = fxy j + uxd i / (τj+1 - τj)
else
e = uxd i / (zxi+1 - zxi)
fxy j = fxy j + e ⋅ (τj+1 - zxi) / (τj+1 - τj)
j=j+1
until τj+1 ≥ zxi+1 do
fxy j = fxy j + e
j=j+1
loop
fxy j = fxy j + e ⋅ (zxi+1 -τj) / (τj+1 - τj)
Ix = j * update the time index of node x
end if
* propagate this flow to y
uyd i = uyd i + uxd i
end if
next k
next i
next d
end function
37
7.3 Arc performances and user equilibrium
The following procedures have been proposed and discussed in Bellei, Gentile and Papola
(2005), where the reader is referred for any detail. We present here only the more general
temporal-layer formulation.
The solution of the arc performance model presented in section 5 results extremely
simplified by the assumption (56), and is implemented as follows:
function [t, c] = t(f) * compute the arc performance function

for each (x, y)∈A * for each arc (x, y)
0 0
txy = τ + Lxy / Vxy * set the initial exit time to uncongested
cxy0 = η ⋅ (txy0-τ0) + sxy0 * compute the corresponding cost
for i = 1 to n * process each i-th instant in chronological order
txyi = max{txyi-1 + (τi-τi-1) ⋅fxyi-1 / λxy , τi + Lxy / Vxy} * compute the exit time
cxyi = η ⋅ (txyi-τi) + sxyi * compute the corresponding cost
next i
next (x, y)
end function
The fixed point formulations (47) and (54) are solved iteratively through the Method of
Successive Averages (MSA) as follows:
function DUE * compute the dynamic user equilibrium

k=0,f=0,q=ε⋅1 * initialize flows to zero and the auxiliary flows to ε
until ||f - q||∞ < ε or k > Κ do * verify the stop criterion
k = k +1 * increment by one the iteration counter
[t, c] = t(f) * compute the arc performance function
q = fDETTL(c, t ; D) | q = fPROBTL(c, t ; D) * compute the network loading map
f = f +1/k ⋅ (q - f) * average the flows
loop
end function
where ε and Κ are, respectively, the maximum flow difference and the maximum number of
iterations in the stop criterion, while the Probit NLM is implemented as follows:
function f = fPROBTL(c, t ; D) * compute the probit network loading map

f=0 * initialize flows to zero
for h = 1 to Η * for each h-th simulation run
ĉ = ĉ(c ; χ) * perturb the arc costs
q = fDETTL(ĉ, t ; D) * compute the deterministic network loading map
f = f +1/h ⋅ (q - f) * average the flows
next h
end function
38
8 VALIDATION OF THE HEURISTICS
In the following we summarize the approximations introduced in the proposed heuristics to
compute the network loading map consistently with piecewise linear arc performances.
The temporal-layer algorithm involves four types of errors.
1) Although the node minimum costs have actually a piecewise linear temporal profile, this is
not based on the predefined instants τ. Therefore, when wyd(txyi) is computed as in (58), an
approximation is introduced in the computation of wxd i as in (57). This error then propagates
among the nodes in a non systematic way. However, it adds up to other errors of the same
nature, which makes their variance increase with the distance from the destination.
2) For long time intervals, the system of Bellman relations is not solved exactly.
3) The determination of the successive node is affected by this error. But more important, the
latter is considered constant during each time interval.
4) The most heavy approximation is due to the spreading of the arc outflow in the first and in
the last overlapping interval. There is a partial compensation between the error produced by
adjacent intervals. However, this produces a systematic distortion that propagates downstream
toward the destination and tends to accelerate vehicles when the arc inflows are increasing in
time and to decelerate them when the arc inflows are decreasing.
In the trajectory algorithm the first and second types of errors is not present at all.
Moreover, although some vehicles are accelerated while some others are delayed when the arc
flows are uniformly distributed within each time interval, the effect of the fourth type of error
is local and does not propagate downstream. This is a main advantage of the trajectory
algorithm, whose only relevant approximation is the assumption that the fastest path changes
can occur just at the predefined instants τ, which produces the third type of error.
All the above approximations do not concern the model itself but are intrinsically related to
the time discretization. Indeed, increasing indefinitely the number n of the predefined time
intervals covering the period of analysis and decreasing their length tends to eliminate all
errors, because, four the types respectively: 1) the interpolation featured by the piecewise
linear function tends to fit with the actual temporal profile; 2) at a given point the short time
interval condition will be satisfied; 3) the distance between the actual and the enforced path
change instants tend to zero; 4) the acceleration/delay effect is proportional to the length of
the time intervals. As a theoretical conclusion, increasing the density of time discretization
mesh, the numerical solution produced by the proposed heuristics tends to the actual solution
of the original continuous formulation.
39
The effects of the approximations will be now discussed on the basis of numerical tests and
confrontations among the results produced by the different algorithms, with the aim of
investigating the relation between the length of the time intervals and the entity of the errors.
Specifically, we want to determine a suitable compromise between efficiency and efficacy.
To address the above questions, the road network of Cosenza, Italy, consisting of 524
directed arcs, 241 nodes and 39 destinations, has been considered to carry out the numerical
experiments. The travel demand is constituted by 347 o-d components, whose flow temporal
profiles are described with 10 minute intervals. The period of analysis of five hours from
07:00 to 12:00 AM covers the morning peak-hour.
Figure 14. The road network of Cosenza, Italy.
flow [us/h] Total demand temporal profile

25000
20000
15000
10000
5000
0
7.10
7.40
8.10
8.40
9.10
9.40
10.10
10.40
11.10
11.40
time
Figure 15. Total demand temporal profile during the period of analysis.
40
In order to compare in terms of computing times and solution accuracy the proposed
heuristics and to investigate their sensitivity with respect to the congestion level a set of 18
deterministic within-day dynamic traffic assignments have been performed, resulting from the
combination of:
a) two approaches: the trajectory algorithm, and the temporal-layer algorithm, denoted
respectively as TJ and TL;
b) three demand levels: multiplying by 0.5, 1, and 1.5 the original demand flows;
c) three time discretizations: 3000 intervals of 6 sec, 300 intervals of 60 sec, and 30 intervals
of 600 sec, indicated respectively with DT6, DT60 and DT600.
The case of costs proportional to travel times has been considered, so that the dynamic
shortest and fastest path problems coincide. In any other case, only TL can be applied, since
TJ address a different problem. Since TJ is affected by fewer approximations than TL, we
assume the solution obtained by TJ for the densest time discretization DT6 as a reference.
avg err
gap[us/h]
[veh/h] Average arc gap
Average errortemporal
profiles profiles – alg
- Algorithm TJ
CTJ avg avg
flowflow[us/h]
[veh/h]
100 600
DT60
80 500
400
60 DT600
300
40
200
20 average
100
flow
0 0
25200 28800 32400 time [sec]
gap [veh/h]
avg error [us/h] Average arcerror
Average gap temporal
profiles - profiles
Algorithm– alg TL
CTL-R avgavg
flowflow
[veh/h]
[us/h]
100 600 DT6
80 500
400 DT60
60
300
40 DT600
200
20 100 average
flow
0 0
25200 28800 32400 time [sec]
Figure 16. Temporal profiles of the average arc flow and of the average arc gap.
To analyze the effect of the time discretization on the accuracy for the two algorithms, we
depicted in the plots of Figure 16 the temporal profiles of the average gap between the
reference arc flows and the estimates provided by each heuristic considered, defined as:
Δi = ∑ (x, y)∈A | fxy(τi) - fxyi| / |A| , (72)
41
where fxy(τi) is the reference solution at time τi and fxyi is the approximate solution.
One can observe that for both algorithms the gap is larger when the average arc flow
(depicted by a thick line in the above plots) changes rapidly, as at the beginning of the
simulation. Moreover, the gap is larger for longer time intervals. We think that this is the
effect of the third type of error, since when the arc flows and, as a consequence, the arc travel
times change remarkably from one time interval to the next, substantial modifications to the
shortest path trees may take place, and these are forced to occur in the predefined instants of
the periodization, thus generating a distortion in the solution which increases with the length
of time intervals. Note that a few modifications of the successive nodes may determine many
modifications of shortest paths.
The gap presents a similar shape inside each time interval. This is evident for DT600, but
can be observed also for DT60. The periodic pattern of the gap is due to the fact that the
reference flow temporal profiles are almost continuous with respect to the arc flow temporal
profiles relative to less dense periodizations that are piecewise constant. In particular, the
polarized pattern relative TL shows a certain inertia of the heuristics in responding to demand
flow variations (Figure 17).
arc flow
arc flow
time time
i i+1 i+2 i+3 i i+1 i+2 i+3
τ τ τ τ τ τ τ τ
Figure 17. Centred and polarized approximation of a continuous temporal profile with a
piecewise constant function.
The average error, defined as follows:

Δ = ∑ i = 0, … , n-1 Δi / n ,
can be assumed as a synthetic measure of the solution accuracy. From the plots in Figure 18
we can observe that the average error:
a) decreases proportionally with the length of time intervals;
42
b) increases with the level of congestion;
c) is lower than 2% of the average arc flow for DT6 and DT60, which is satisfactory;
d) is lower than 10 % of the average arc flow for DT600, and for TJ is still acceptable;
e) for D60, the error of TL and that of TJ are similar, while for DT6 and DT600 the former is
noticeably higher then the latter.
Average error [veh/h] – alg TJ Average error [veh/h] – alg TL

50 50
40 40
30 30
20 20
10 10
0 0
6 60 600 DT 6 60 600 DT
low dem med dem high dem low dem med dem high dem
Figure 18. Total average arc gap.
Run time [sec] – alg TJ Run time [sec] – alg TL

10000 10000
1000 1000
100 100
10 10
1 1
6 60 600 DT 6 60 600 DT
low dem med dem high dem low dem med dem high dem
Figure 19. Time to perform 100 equilibrium iterations.
To analyze the efficiency of the proposed heuristics, we compared the computing times
needed to perform the same number of equilibrium iterations on a PC with a 1.8 GHz CPU.
Recalling that for each single equilibrium iteration we need to solve |C|⋅I dynamic shortest
path and network flow propagations, from the plots in Figure 19 we can observe that run
times are:
a) essentially not affected by the level of congestion, which confirms the expectations based
on the theoretical evidence;
43
b) proportional to the number of time intervals introduced;
c) very similar for TJ and for TL.
The above analysis let us draw the following conclusion:
a) both algorithms are robust with respect to the level of approximation;
b) only TL can be utilized in presents of tolls or when the FIFO rule does not hold, which
makes it then way more general than TJ;
c) the best compromise between efficiency and efficacy is obtained with a time discretization
approximately equal to 1/10 of the demand discretization, while a more dense temporal mesh
increases calculation times without a significant improvement of the solution accuracy.
9 CONCLUSIONS
The within-day dynamic traffic assignment has been formulated as a user equilibrium and
solved as a fixed point problem in terms of arc inflow temporal profiles. Specifically, we have
addressed through implicit path enumeration the behaviour of users that travel only on
dynamic shortest paths, thus extending to the deterministic case the model proposed in Bellei,
Gentile and Papola (2005). Moreover, the resulting network loading map can be utilized
within a Montecarlo simulation to model route choice in the stochastic case.
To this end we have solved a continuous formulation of the dynamic shortest path problem
and a different formulation of the dynamic fastest path problem, both including the
corresponding network flow propagation, by approximating the temporal profiles with
piecewise linear functions of time. The two models are based, respectively, on an extension of
the temporal-layer approach proposed by Chabini (1998) and of the trajectory approach
presented in Kaufmann and Smith (1993) that were developed for discrete models.
These heuristics outperform the existing assignment algorithms based on the space-time
network paradigm because they allow to introduce time intervals of any suitable length.
Experimentally, the best compromise between accuracy and CPU running time is achieved by
defining time intervals that are about 10 times smaller than the modulation of demand flows.
For example, if we are assigning a sequence of one-hour o-d matrix temporal slices, we can
define time intervals of 6 minutes without deteriorating significantly the solution accuracy.
All in all, these heuristics allow to capture the features of road traffic dynamic that are
relevant for most planning purposes, while keeping computational times to a minimum.
The temporal-layer algorithm introduces more approximations than the trajectory
algorithm and is therefore slightly less accurate. However, differently from the latter, it can
44
handle generalized arc costs, thus allowing for an effective modelling of toll pricing strategies
in a dynamic framework.
REFERENCES
1. Ahuja R.K., Orlin J.B., Pallottino S., Scutellà M.G. (2002) Minimum time and minimum cost
path problems in street networks with traffic lights, Transportation Science 36, 326-336.
2. Bellei G., Gentile G., Papola N. (2005). A within-day dynamic traffic assignment model for urban
road networks, Transportation Research B 39, 1-29.
3. Bertsekas D.P. (1993) A simple and fast label correcting algorithm for shortest paths, Networks
23, 703-709.
4. Carey M., Ge Y.E. (2003) Bibliography of dynamic traffic assignment related papers, School of
Business and Management, Queen’s University Belfast, internal report, available online at
http://www.qub.ac.uk/mgt/transport/webpages/BibloAlphaOrderwithAbstracts.pdf.
5. Cascetta E. (2001) Transportation systems engineering: theory and methods, Kluwer Academic
Publisher, Dordrecht, The Netherlands.
6. Chabini I. (1998) Discrete dynamic shortest path problems in transportation applications:
complexity and algorithms with optimal run time, Transportation Research Record 1645, 170-175.
7. Cooke L.L. and Halsey E. (1966) The shortest route through a network with time-dependent
intermodal transit times, Journal of Mathematical Analysis and Applications 14, 492-498.
8. De Palma A., Hansen P. And Labbé M. (1993) Commuters’ paths with penalties for early or late
arrival times, Transportation Science 24, 276-286.
9. Dial R.B. (1969) Algorithm 360: shortest path forest with topology ordering, Communications of
the A.C.M. 12, 632-633.
10. Dreyfus S.E. (1969) An appraisal of some shortest-path algorithms, Operations Research 17,
395-412.
11. Gentile G., Meschini L., Papola N. (2005a) Macroscopic arc performance models with capacity
constraints for within-day dynamic traffic assignment, Transportation Research B 39, 319-338.
12. Gentile G., Meschini L., Papola N. (2005b) Spillback congestion in dynamic traffic assignment: a
macroscopic flow model with time-varying bottlenecks, submitted for publication in Transportation
Research B.
13. Kaufman, D.E., Smith, R.L. (1993) Fastest Path in time dependent networks for intelligent
vehicle-highway system applications, IVHS Journal 1, 1-11.
14. Orda A. and Rom R. (1990) Shortest-path and minimum-delay algorithms in network with time-
dependent edge length, Journal of the ACM 37, 607-625.
15. Orda A. and Rom R. (1991) Minimum weight paths in time-dependent network, Networks 21,
295-320.
16. Nachtigall K. (1995) Time-depending shortest path problems with applications to railway
networks, European Journal of Operational Research 83, 154-166.
17. Pallottino S., Scutellà M.G. (1998) Shortest path algorithms in transportation models: classical
and innovative aspects, in Equilibrium and advanced transportation modelling, ed.s P. Marcotte, S.
Nguyen, Kluwer Academic Publisher, Dordrecht, The Netherlands, 245-281.
18. Xu Y.W., Wu J.H., Florian M., Marcotte P., Zhu L.H. (1999) Advances in the continuous
dynamic network loading problem, Transportation Science 33, 341-353.
45
19. Ziliaskopoulos A.K. (1994) Optimum path algorithms on multidimensional networks: analysis,
design, implementation and computational experience, Ph.D. dissertation, University of Texas at
Austin.
20. Ziliaskopoulos A.K. and Mahmassani H.S. (1993) Time-dependent shortest path algorithm for
real-time intelligent vehicle highway system applications, Transportation Research Record 1408, 94-
100.
NOTATION
Topology
N set of the nodes
A set of the arcs
G(N, A) graph of the road network
FS(x) nodes of the forward star of node x
BS(x) nodes of the backward star of node x
Z set of the destination nodes
Kod set of the paths on G from node o to destination d
A(k) sequence of arcs constituting path k
Performance pattern
cxy(τ) cost of arc (x, y) for users entering it at time τ
txy(τ) exit time from arc (x, y) for users entering it at time τ
txy-1(τ) entrance time in arc (x, y) for users exiting it at time τ
sxy(τ) monetary cost of arc (x, y) for users entering it at time τ
Ck(τ) cost of path k for users entering it at time τ
Tk(τ) exit time from path k for users entering it at time τ
Tk-1(τ) entrance time in path k for users exiting it at time τ
wod(τ) minimum cost to reach destination d departing from node o at time τ
zod(τ) maximum exit time from node o to reach destination d within time τ
Link characteristics
Lxy length of arc (x, y)
Vxy speed of arc (x, y)
λxy exit capacity of arc (x, y)
46
Flow pattern
Dod(τ) demand flow of users departing at time τ from node o to reach destination d
Pk(τ) choice probability of path k for users departing at time τ
pxyd(τ) conditional probability of choosing arc (x, y) for users directed to destination d that
exit from node x at time τ
fxyd(τ) inflow of vehicles entering arc (x, y) at time τ directed to destination d
exyd(τ) outflow of vehicles exiting arc (x, y) at time τ directed to destination d
fxy(τ) total inflow of vehicles entering arc (x, y) at time τ
μ vehicle occupancy
η value of time
ξ small positive lower bound to the inflow to enforce the strict FIFO rule
Probit model
ĉxy(τ) perceived cost of arc (x, y) for users entering it at time τ
χxy(τ) congestion-independent cost of arc (x, y) for users entering it at time τ
ξ variance coefficient
ψ pseudo random number extracted from a standard normal variable
Η number of Montecarlo iterations
Functionals
t( f ) , c(t) arc performance model
Temporal-layer formulation
w(c, t) , pTL(w, t, c) route choice model
ωTL(p, t ; D) network flow propagation model
fDETTL(c, t ; D) deterministic network loading map
TL
fPROB (c, t ; D) probit network loading map
Trajectory formulation
z(t) , pTJ(z, t) route choice model
ωTJ(p, z ; D) network flow propagation model
fDETTJ(t ; D) deterministic network loading map
fPROBTJ(c, t ; D) probit network loading map
Algorithm
47
[0, Θ] period of analysis
n number of time intervals
τi i-th instant defining the time intervals, i = 0, 1, … , n
ε maximum flow difference for the equilibrium
Κ maximum number of MSA iterations
Temporal-layer formulation
σxd i successive node for users directed to destination d that exit from node x at time τi
vxd i number of vehicles directed to destination d that exit node x during interval [τi, τi+1)
Trajectory formulation
υxd i successive node for users that exit from node x and arrive to destination d at time τi
uxd i number of vehicles that exit node x and arrive to destination d during the interval [τi, τi+1)
Ix current time index for node x
Ixy current time index for arc (x, y)
Bucket list and topological order

m number of buckets
ρh h-th value defining the buckets, h = 0, 1, … , m
Δρ bucket length
B bucket list
Bh h-th bucket sub-list
BFh first node of the h-th bucket
BLh last node of the h-th bucket
BNx next node of node x
BPx previous node of node x
Qi ordered list of the extracted nodes for the i-th temporal layer
i
Qq q-th node in topological order for the i-th temporal layer
48

Fast Heuristics For Continuous Dynamic Shortest Paths and All-Or-Nothing Assignment

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Fast Heuristics For Continuous Dynamic Shortest Paths and All-Or-Nothing Assignment

Uploaded by

Copyright:

Available Formats

FAST HEURISTICS FOR CONTINUOUS DYNAMIC SHORTEST

PATHS AND ALL-OR-NOTHING ASSIGNMENT

Guido Gentile, Lorenzo Meschini, Natale Papola

τ tox(τ) Tk(τ) = Th(tox(τ))

3 CONTINUOUS DYNAMIC SHORTEST PATH PROBLEM

3.1 Temporal-layer formulation of the dynamic shortest path problem

Figure 4. The Bellman relation in the temporal-layer formulation.

3.2 Trajectory formulation of the fastest dynamic path problem

Figure 5. The Bellman relation in the trajectory formulation.

4 PATH CHOICE AND NETWORK FLOW PROPAGATION

4.1 Temporal-layer formulation

4.2 Trajectory formulation

5 ARC PERFORMANCE MODEL

6.1 The deterministic case

TEMPORAL LAYER FORMULATION TRAJECTORY FORMULATION

network loading map network loading map

ωTL( p, t ; D) w(c, t) ωTJ( p, z ; D) z(t)

6.2 The Probit case

7.1 Temporal-layer network loading map

In this section, we first propose a heuristic to solve the many-to-one temporal-layer

Figure 8. Consequence of long time intervals in the temporal-layer algorithm.

cxri + wrd(txri) = wxd i ≤ cxyi + wyd(txyi)

fxyd i vxd i time

function f = fDETTL(c, t ; D) * compute the deterministic network loading map

* solve the dynamic shortest path problem

* load on the nodes the demand flows

* solve the network flow propagation model

7.2 Trajectory network loading map

txr-1(zrd i) = zxd i ≥ txy-1(zyd i)

zyd i zyd i+1

fxyd j fxyd j+1 fxyd j+2

zxd i zxd i+1

Figure 13. Network flow propagation in the trajectory algorithm.

exiting from o during each interval [zod j, zod j+1

* solve the dynamic fastest path problem

* load on the nodes the demand flows

* solve the network flow propagation model

function [t, c] = t(f) * compute the arc performance function

function DUE * compute the dynamic user equilibrium

function f = fPROBTL(c, t ; D) * compute the probit network loading map

Figure 14. The road network of Cosenza, Italy.

flow [us/h] Total demand temporal profile

The average error, defined as follows:

Average error [veh/h] – alg TJ Average error [veh/h] – alg TL

Figure 18. Total average arc gap.

Run time [sec] – alg TJ Run time [sec] – alg TL

Figure 19. Time to perform 100 equilibrium iterations.

Bucket list and topological order

You might also like