On Solving Quickest Time Problems in Time

Journal of Mathematical Modelling and Algorithms 3: 39–71, 2004. © 2004 Kluwer Academic Publishers. Printed in the Netherlands.

39

On Solving Quickest Time Problems in Time-Dependent, Dynamic Networks ELISE MILLER-HOOKS and SARAH STOCK PATTERSON Department of Civil & Environmental Engineering 1173 Glenn Martin Hall, The University of Maryland, College Park, MD 20742, U.S.A. e-mail: [email protected],[email protected] (Received in final form and accepted: 12 February 2004) Abstract. In this paper, a pseudopolynomial time algorithm is presented for solving the integral time-dependent quickest flow problem (TDQFP) and its multiple source and sink counterparts: the time-dependent evacuation and quickest transshipment problems. A more widely known, though less general version, is the quickest flow problem (QFP). The QFP has historically been defined on a dynamic network, where time is divided into discrete units, flow moves through the network over time, travel times determine how long each unit of flow spends traversing an arc, and capacities restrict the rate of flow on an arc. The goal of the QFP is to determine the paths along which to send a given supply from a single source to a single sink such that the last unit of flow arrives at the sink in the minimum time. The main contribution of this paper is the time-dependent quickest flow (TDQFP) algorithm which solves the TDQFP, i.e. it solves the integral QFP, as defined above, on a time-dependent dynamic network, where the arc travel times, arc and node capacities, and supply at the source vary with time. Furthermore, this algorithm solves the time-dependent minimum time dynamic flow problem, whose objective is to determine the paths that lead to the minimum total time spent completing all shipments from source to sink. An optimal solution to the latter problem is guaranteed to be optimal for the TDQFP. By adding a small number of nodes and arcs to the existing network, we show how the algorithm can be used to solve both the time-dependent evacuation and the time-dependent quickest transshipment problems. Mathematics Subject Classifications (2000): 90B10, 90C35. Key words: dynamic networks, quickest flow, dynamic shotest path, time-dependent, minimum cost network flow, evacuation, transshipment.

The importance and wide applicability of network flow problems has long been recognized. Dynamic network flow problems, in particular, have been used to model numerous real world phenomena arising in applications within almost all industries. Such applications include, for example, production-distribution systems, fleet management, evacuation and communications (see [5, 27]). In a dynamic network, flow moves through the network over time, travel times determine how long each unit of flow spends traversing an arc, and capacities restrict the rate of flow on an arc. However, dynamic network flow problems have been traditionally considered in a purely static environment, i.e. the attributes of the network, including arc tra Corresponding author.

40

ELISE MILLER-HOOKS AND SARAH STOCK PATTERSON

versal times (or costs), arc and node capacities, and the availability of supply, are time-invariant. For many of the aforementioned applications, such a static representation may be inadequate. Thus, to more realistically model such problems, the methodology must recognize the inherent time-varying nature not only of flow, but also of the network attributes. We make the distinction between time-dependent (or time-varying) and dynamic, where time-dependency is associated with the network attributes (such as traversal times, capacities, and supply at the source node) and dynamic is associated with the movement of flow through the network. In this paper, a pseudopolynomial time algorithm is presented for solving the integral time-dependent quickest flow problem (TDQFP) and its multiple source and sink counterparts: the time-dependent evacuation and time-dependent quickest transshipment problems. A more widely known, though less general version, is the quickest flow problem (QFP). The QFP has historically been defined on a dynamic network, where the objective is to determine the paths along which to send a given supply from a single source to a single sink such that the last unit of flow arrives at the sink in the minimum time. For the remainder of this paper, we refer to this time by which all flow will arrive at the destination as the quickest flow time. The time-dependent quickest flow (TDQFP) algorithm presented in this paper solves the TDQFP, i.e. it solves the integral QFP, as defined above, on a timedependent dynamic network, where the arc travel times, arc and node capacities, and supply at the source vary with time. A technique is presented for converting a network with multiple sources and multiple sinks into an equivalent single source and sink network with the addition of a small number of nodes. With this conversion, the proposed algorithmic approach (the TDQFP algorithm) also solves the time-dependent evacuation problem (multiple sources, single sink) and the timedependent quickest transshipment problem (multiple sources and sinks). Moreover, the TDQFP algorithm can be used to solve the time-dependent minimum time dynamic flow problem whose objective is to determine the paths that lead to the minimum total time spent completing all shipments from a single source to a single sink. One can easily extend the triple optimization result of Jarvis and Ratliff [19] defined for static networks to dynamic and time-dependent networks. This result guarantees that an optimal solution to the latter problem is optimal for the TDQFP. Problems in dynamic networks can be solved using traditional network techniques on a time-expanded graph. The time-expanded network is constructed by making a copy of the original network for each discrete interval of time. Thus, each node in the time-expanded network is actually a node–time pair corresponding to the original node number and time interval. Each arc in the original network corresponds to several arcs in the time-expanded network. These arcs originate at a given node–time pair for every possible departure time and terminate at a node– time pair that corresponds to the arrival time at the destination node. Two such constructions for a simple network are depicted in Figure 1, first, with static arc traversal times and second, with time-varying arc traversal times. Note that in the former case, a regular pattern of arc construction emerges, whereas, in the latter

ON SOLVING QUICKEST TIME PROBLEMS

41

Figure 1. Construction of time-expanded networks for both static and time-varying travel time cases.

case, no pattern can be identified. Such expanded networks are typically very large for realistic problems and it may be beneficial to avoid such explicit expansion. Ford and Fulkerson [13] introduced dynamic networks with the maximum dynamic flow problem whose aim is to send as much flow as possible from the source to the sink within a specified time bound T . They showed that the maximum dynamic flow problem can be solved in polynomial time with a single minimum cost flow computation. The quickest flow problem (QFP) can be reduced to solving the maximum dynamic flow problem via binary search. Burkard, Dlaska and Klinz [8] give more efficient and strongly polynomial algorithms for the quickest flow problem. Klinz and Woeginger [20] show that a similar problem, the minimum cost quickest flow problem, whose objective is to determine the set of path flows for sending all of the supply from the source to the sink such that the last unit of flow arrives in the minimum time and the total cost of all shipments is minimized, is NP-hard. The evacuation problem is an extension of the QFP to multiple origins. It is commonly used to model building evacuation, where it is assumed that only one exit (i.e. sink) exists. Chalmet, Francis and Saunders [11] and Hamacher and Tufekci [16] present pseudopolynomial time algorithms to solve this problem requiring the use of time-expanded networks. A more general extension of the QFP is the quickest transshipment problem. Here the paths along which to send the supply out of multiple sources and into multiple sinks such that the last shipment arrives in the minimum time are sought. Hoppe and Tardos [18] present the first polynomial time algorithm for the integral quickest transshipment problem and Fleischer and Tardos [12] extend this work. Note that in all of the works described thus far, network attributes are assumed to be time-invariant. We will now review related work on time-dependent networks. Halpern [15] presents a solution technique to address the maximal dynamic network flow problem where time is discretized into uniform intervals, arc capacities

42


are time-varying, and waiting is restricted at intermediate nodes along the paths. Begun by Anderson, Nash and Philpott [3], there is a body of research on dynamic network flow problems that models time continuously and considers problems with time-varying arc capacities, storage capacities or costs [2, 4, 14, 23–25, 28, 29]. This approach is not valid when travel times are also time-varying. Hoppe [17] provides a reference to include dynamic networks with time-varying arc traversal times. Using a discrete time network, he briefly describes the use of parallel “mortal edges” (edges with single start and end times) for incorporating time-varying network attributes into quickest flow and transshipment problems. He states that the performance of this approach decreases with increasing variation over time of the time-varying network characteristics. No attempt is made to test this approach. Cai, Sha and Wong [9] have developed a technique which solves the time-varying minimum cost flow problem, that is, the problem of sending a given amount of flow from a single source to a single sink such that the total cost of all shipments is minimized and the flow satisfies the capacity constraints and arrives before a given time bound. The arc costs, travel times and capacities are all time-varying. While no mention of this is made by the authors, one could use their technique to solve a case of the TDQFP with time invariant supply, by simply using the travel times as the cost function. This approach, while correct, is less efficient since it was developed to distinguish between cost and travel time rather than focus solely on time as an approach developed purely for the TDQFP would. The authors know of no efficient solution technique in the existing literature for solving the discrete time-dependent quickest flow problem or its special cases (time-dependent evacuation and quickest transshipment problems). This research provides the conceptual framework and specific algorithmic steps for solving the integral time-dependent quickest flow problem (TDQFP), whose objective is to determine the set of integral path flows for sending all of the supply from a given source to a given sink such that the last unit of flow arrives at the sink in the minimum time. The algorithm presented here allows for the intermediate storage of flow at the nodes which corresponds to holding inventory at a node before sending it onward. It is assumed that the travel times on the network can be nonFIFO (i.e. for a given arc (i, j ), it is possible to send a shipment from node i that leaves earlier than another shipment but arrives at node j later than it). Thus, by waiting at a node while en route, an earlier arrival time at the destination may be achieved. A technique for transforming both the time-dependent evacuation problem (multiple sources) and time-dependent quickest transshipment problem (multiple sources and sinks) into an instance of the TDQFP is shown. Such transformation enables solution of these problems by employing the TDQFP algorithm. The transformation of an instance with multiple sources to an instance with a single source is given and is relatively straightforward requiring only one additional supersource node. However, the transformation of the multiple sink instance is not straightforward. Both of these transformations are developed in this paper.


43

The main contribution of this paper is a pseudopolynomial time algorithm (the TDQFP algorithm) for solving the time-dependent quickest flow problem that does not require an explicit space-time expansion. We show how the algorithm can be used to solve both the time-dependent evacuation and the time-dependent quickest transshipment problems by adding a small number of nodes and arcs to the existing network. Moreover, we present an efficient algorithm for determining the time-dependent earliest arrival time paths (the TDEAT algorithm) with the associated arrival times and capacities that permits negative travel times. An example is provided to illustrate the steps of the procedure and results and analysis of computational experiments conducted to assess the performance of the proposed procedure are provided. This paper is structured as follows. Section 1 mathematically defines the TDQFP and presents the notation. Section 2 introduces the TDQFP algorithm for solving the time-dependent quickest flow problem and its counterparts: the evacuation and quickest transshipment problems. The TDEAT (Time-Dependent Earliest Arrival Time) algorithm, upon which the TDQFP algorithm relies, is also described. An illustrative example is given in Section 3. Section 4 gives computational results on several example networks. Conclusions and extensions are discussed in Section 5.

1. Definitions and Preliminaries A time-dependent dynamic network, ℵ = (G, u, τ ), is a directed graph, G = (N, A, {0, . . . , T }), where N is the set of nodes, A is the set of directed arcs and {0, . . . , T } is the time frame of interest discretized into small time intervals. The TDQFP has a single source node and a single sink node, denoted by k and l, respectively. The supply at node k at departure time t is denoted by bk (t) and can take on positive values for any t ∈ {0, . . . , T }. The demand at node l at departure time t, denoted by bl (t), will be zero for all values of t ∈ {0, . . . , T } except for t = T . At thisdeparture time, it is assumed that the demand will equal the total supply, B = Tt=1 bk (t), so that bl (T ) = −B. This does not mean that the flow cannot arrive at the sink at an earlier time. As fulfilling the demand requirement in the minimum time is our objective, this would obviously be meaningless. Instead, when flow arrives before time T , it simply waits without penalty until time T in order to satisfy the demand. Finally, the supply at any other node will be zero at all other times, i.e. bi (t) = 0, for all i ∈ N\{k, l}, t ∈ {0, . . . , T }. The time-dependent evacuation and time-dependent quickest transshipment problems have multiple sources, the set of which is denoted by K and the timedependent quickest transshipment problem also has multiple sinks, the set of which is denoted by L. We show in Subsections 2.1 and 2.2 how to transform the nodes in K and L into a single supersource, k, and a single supersink, l. Each arc has a nonnegative time-varying capacity and an associated positive time-varying travel time. For all (i, j ) ∈ A and all t ∈ {0, . . . , T }, the capacity of arc (i, j ) at departure time t is given by uij (t), where it is assumed that

44


uij (T ) > 0. The capacity of an arc limits the amount of flow released on an arc at a given departure time. This capacity is, in effect, controlling the rate of flow entering an arc, and not the total flow on that arc at any given time. Depending on the application, other models might restrict the actual flow on an arc at every time period. For instance, when modelling airline operations, one could control the rate of aircraft entering an airspace [21] or the number of aircraft within that airspace at any given time [7]. Either approach could be incorporated in the general structure of the TDQFP algorithm, however, we are focusing on the former. As flow leaves node i at some departure time t, the time it takes to reach node j , i.e. the travel time along arc (i, j ), is given by positive valued τij (t). The arc travel time is defined upon entering an arc, and is assumed to be constant for the duration of travel along that arc. Thus, it is possible for a unit of flow to leave node i ahead of some other flow, but arrive later. It is assumed, for clarity only, that the travel times are multiples of the discretized time interval. At each node, i ∈ N, and for every time interval, t ∈ {0, . . . , T }, there exists a holdover arc (i, i) with unlimited capacity, uii (t) = ∞, and travel time, τii (t) = 1. A stationary period follows the nonstationary period {0, . . . , T } and the arc capacities and travel times are set to the value at the last time interval in the nonstationary period, i.e. for all t > T , uij (t) = uij (T ) and τij (t) = τij (T ). Moreover, no supply occurs after the nonstationary period, bi (t) = 0, ∀i ∈ N, t > T , and the arc travel times, arc capacities and the supply at the source node are known a priori. It is assumed in this discussion that the last time interval in the nonstationary period T is at least as large as the time-dependent quickest flow time, i.e. in the optimal solution, the last unit of flow will arrive at the sink before the end of the nonstationary period. Thus, T also presents a bound on the time-dependent quickest flow time. If such a bound is not given exogenously, as is often the case in real-world applications, the technique presented in Appendix A can be used to identify one. As we have stated in the introduction, an optimal solution to the time-dependent minimum time dynamic flow problem is guaranteed to be optimal for the TDQFP. Thus, we begin by formulating the time-dependent minimum time dynamic flow problem as a linear program, where xij (t) is the flow on arc (i, j ) that leaves node i at time t and arrives at node j at time t + τij (t), and x = {xij (t) | (i, j ) ∈ A, t ∈ {0, . . . , T }}. The set of predecessor and successor nodes to a node i are given by δ − (i) = {j | (j, i) ∈ A} and δ + (i) = {j | (i, j ) ∈ A}, respectively. (P )

min

τij (t)xij (t),

(i,j )∈A\{(l,l)},t ∈{0,...,T }

j ∈δ + (i)

xij (t) −

j ∈δ − (i)

{t |t +τji (t )=t }

xj i (t ) = bi (t),

0 xij (t) uij (t), ∀(i, j ) ∈ A, t ∈ {0, . . . , T }.

∀i ∈ N, t ∈ {0, . . . , T },


45

The objective seeks the minimum total time to send all the flow from the source to the sink. Note that the holdover arc at the sink node is not included in the objective function. While the travel time on this holdover arc will be one at all times, (τll (t) = 1, ∀t), there is no penalty for arriving at the sink early and waiting to satisfy the demand at period T , so this arc must be excluded from the objective function. The first set of constraints are the flow conservation constraints in a time-dependent and dynamic environment. To determine the flow arriving at a given node at a given time, not only is it necessary to sum over all possible predecessor nodes, but it is also necessary to sum over all possible departure times from each predecessor node such that the departure time plus the travel time equals the desired arrival time. The last constraints are nonnegativity and capacity constraints. Note that the formulation for the TDQFP would have a different objective function. As the objective of the TDQFP is to minimize the time that the last unit of flow arrives at the sink, a nonlinear objective function is given as: min max (t + τil (t)) Iil (t) , i∈δ − (l),t ∈{0,...,T }

where Iil (t) is a binary indicator variable that takes on a value of 1 if xil (t) > 0 and 0 otherwise. This objective requires that the capacity constraints be restated as xil (t) uil (t)Iil (t)

for all i ∈ δ − (l), t ∈ {0, . . . , T }.

The flow conservation constraints would remain identical to those given above. Lastly, the variables xij (t), ∀(i, j ) ∈ A, t ∈ {0, . . . , T } would be integer valued. We present an algorithm for solving the TDQFP in the following section. 2. Solving the Time-Dependent Quickest Flow Problem In this section, we present an algorithm that finds the solution to the time-dependent quickest flow problem (TDQFP) and its counterparts: the evacuation and quickest transshipment problems. This algorithm is based on the successive shortest path algorithm for solving minimum cost network flow problems in static networks (see [1] for additional detail on the successive shortest path algorithm) in that it relies on the concept of residual networks described in [13] and it incrementally loads flow on the network, each time selecting the appropriately defined (time-dependent) shortest path from source to sink. For a given flow x, the residual network is denoted G(x). The capacity associated with each arc in the residual network is the remaining capacity, referred to as the residual capacity, for a given flow. The residual network employs backward arcs to permit the return of capacity to an arc, corresponding to reversing decisions from previous iterations. Our algorithm employs a time-dependent extension of this static residual network. Further, it relies on a procedure that determines the time-dependent earliest arrival time paths with the associated arrival times and capacities which is discussed in Subsection 2.3;

46


details of which are presented in Appendix B. The overall algorithm is outlined below with specific emphasis on how each of the elements work together to solve the problem. The details of the entire algorithm are provided in Subsection 2.4. Procedure Overview 1. (Multiple Source and/or Sink Conversion) For the time-dependent evacuation and quickest transshipment problems only, the first step is to convert the multiple sources and multiple sinks (quickest transshipment only) into a single source and a single sink using the techniques given in Subsections 2.1 and 2.2. After this step is completed, the need to distinguish between quickest flow, evacuation and quickest transshipment no longer exists. 2. (Earliest Arrival Time Path) Initially, let the residual network be the original network. Beginning at the earliest available supply time, determine the earliest arrival time path and corresponding capacity through the time-dependent residual network and send as much flow on this path as the supply or capacities allow. 3. (Updating the Time-Dependent Residual Network) For each arc in which positive flow is shipped in the previous step, first decrease the remaining capacity appropriately for the time that the flow occurred. Next, if the arc is not a backward arc and if one does not already exist, add a backward arc to the graph. Update the capacities and travel times of all affected arcs in the network at the appropriate departure time intervals. 4. (Stopping Criterion) If all the supply has reached the sink node, stop. Otherwise, return to step two and find the new earliest arrival time path.

2.1. CONVERTING MULTIPLE SOURCES TO A SINGLE SUPERSOURCE For the time-dependent evacuation and quickest transshipment problems, we need to convert the network representation from one with multiple sources to an equivalent network with a single supersource. Given that the number of source nodes is greater than one, |K| > 1, we add a supersource, denoted as k, to the graph. For every original source node i ∈ K, we add an arc (k, i) to the network with travel time of zero, τki (t) = 0 for all t ∈ {0, . . . , T }. Let the capacity at time t equal the value of the supply at node i at time t, i.e. uki (t) = bi (t). Also add a self-loop at the supersource, k, with infinite capacity and travel time equal to one for all t ∈ {0, . . . , T }, i.e. ukk (t) = ∞ and τkk (t) = 1, ∀t ∈ {0, . . . , T }. Set the supply value at the supersource as follows. bi (t) and bk (t) = 0, for all t ∈ {1, . . . , T }. bk (0) = i∈K t ∈{0,...,T }

An example of this transformation is shown in Figure 2.

47


Figure 2. Supersource construction example.

This transformation maintains the same supply structure as the original network. Although all B units of supply are available at time 0 and now need to be sent from the supersource, the capacities on the arcs emanating from the supersource restrict when this flow is actually introduced to the original network. For instance, in the example above, all eight units are available at time 0, however, only 4 units of this flow can leave the supersource and enter node 1 at time 0 due to the capacity on arc (k, 1) at time 0. The remaining units will wait at node k until a time in which there is capacity available to enter an original source. As the travel times on the arcs leaving the supersource and entering the original sources are zero, flow will be available at the original sources at the times specified by the supply quantities, bi (t) for all i ∈ K, as occurred in the original network. With this transformation, the TDQFP algorithm can now be directly applied. The formulation given in Section 1 is also directly applicable to this expanded network. However, given the supersource construction, the objective function can be restated as follows.

min

τij (t)xij (t)

(i,j )∈A\{(l,l)},t ∈{0,...,T }

= min

(i,j )∈A\{(l,l)},i=k, t ∈{0,...,T }

τij (t)xij (t) +

j |(k,j )∈A, t ∈{0,...,T }

τkj (t)xkj (t)

48


= min

τij (t)xij (t) +

(i,j )∈A\{(l,l)},i=k, t ∈{0,...,T }

= min

(i,j )∈A\{(l,l)},i=k, t ∈{0,...,T }

τij (t)xij (t) +

τkk (t)xkk (t)

t ∈{0,...,T }

tbi (t).

i∈K,t ∈{0,...,T }

Thus, this transformation has the effect of adding the constant term, i∈K,t ∈{0,...,T } tbi (t), to the optimal objective function value for the multiple source problem. 2.2. CONVERTING MULTIPLE SINKS TO A SINGLE SUPERSINK For the time-dependent quickest transshipment problem, we must convert the network with multiple sinks to an equivalent network with a single supersink. Given that the number of sink nodes is greater than one, |L| > 1, we add a copy of each node, denoted j for each j ∈ L, and a supersink, denoted l, to the graph. Define the set L to be the set of new nodes excluding the supersink, i.e. L = {j | j ∈ L}. For every node j ∈ L, add the arc (j, j ) to the network with infinite capacity, ujj (t) = ∞, and travel time equal to zero, τjj (t) = 0, for all t ∈ {0, . . . , T }. For every node j and for all t ∈ {0, . . . , T }, add a self-loop with infinite capacity, uj j (t) = ∞, and travel time equal to one, τj j (t) = 1, and add arc (j , l) to the network. Let the capacity of arc (j , l) be equal to the absolute value of the demand at node j ∈ L at time T , i.e. uj l (T ) = bj (T ) and let the travel time be zero, τj l (t) = 0, for all t ∈ {0, . . . , T }. An example of this transformation is shown in Figure 3. This transformation maintains the same demand structure as the original network. As all the flow must be sent from the supersource to the supersink, B units of flow will arrive at the sink at time T . This transformation will ensure that an excess of exactly bj (T ) units occurs at each original sink node j . All flow that arrives at a sink node j can travel without penalty to j because the capacity on the arcs from the original sink nodes j to the new sink nodes j is infinite. At j , the flow waits without penalty until the final time period, T . At this point only a flow of bj (T ) is allowed to reach the supersink due to the capacity on arc (j , l). As all flow that enters each j must eventually leave and only bj (T ) can leave, that means that only bj (T ) will enter. Thus, only bj (T ) will leave each original sink node j on a path to the supersink. It may seem that the j nodes are not necessary and could be combined with the original nodes j . However, this is not the case. As flow could travel to any of the original sink nodes on a path to another sink node, we need to have a self loop at each original sink node that penalizes the total time spent waiting. In contrast, the self loops at the nodes in L have a travel time of one, but no objective function penalty for waiting. What this does is only count the time spent traveling from the original source to the original sink. Any time spent in the network after the flow has arrived at the original sink, where the sink does not act as a transshipment node, is made without penalty.


49

Figure 3. Supersink construction example.

For completion, we need to redefine the sets N and A to include the new nodes and new arcs that have been added to the network in this conversion. Once again, with this supersink transformation, the TDQFP algorithm can now be directly applied. The formulation given in Section 1 is also directly applicable to this expanded network. However, the objective function, given in Section 1, will change slightly since waiting without penalty now occurs on all nodes j ∈ L rather than on a single sink. Mathematically, we restate the objective function as τij (t)xij (t). min (i,j )∈A\{(j ,j )|j ∈L }, t ∈{0,...,T }

Note that all the newly added arcs, except the arc (j , j ), ∀j ∈ L , have zero travel times and will not affect the objective function value. 2.3. THE TIME - DEPENDENT EARLIEST ARRIVAL TIME ALGORITHM The TDQFP algorithm depends upon a procedure to determine the earliest arrival time to a given destination node, for a given departure time from a select origin, in a nonFIFO, time-dependent network. It is required that the procedure allows for flow to be held at intermediate nodes along the paths (i.e. unlimited waiting is permitted), and that it guarantees an optimal solution given possible negative arc traversal times. As will be seen in the algorithm description in Subsection 2.4, the TDQFP algorithm introduces backward arcs whose associated arc times are negatively valued. Given this, it will be necessary to compute the earliest arrival time path in a network with negative arc lengths. Thus, a label correcting approach is

50


required. (See [1] for additional detail on basic label setting and label correcting algorithms.) Such a procedure, called the TDEAT (Time-Dependent Earliest Arrival Time) algorithm, is discussed in this section. The pseudocode for the algorithm and proof of optimality are given in Appendix B. The TDEAT algorithm is a time-dependent version of the label correcting algorithm first employed by Bellman [6], using a FIFO scan eligible (SE) list. The algorithm determines the earliest arrival time, αj , at every node j ∈ N for departure at a given time from a single source node, k, in a time-dependent network. The details for efficiently maintaining and rebuilding the optimal path, and for efficiently tracking its capacity are provided in the description given in Appendix B. Briefly, at each iteration of the algorithm, a node, called the current node, is removed from the SE list. For each of its successor nodes, the earliest arrival time is computed, using a path that departs from the origin at the earliest time that supply is available and that proceeds through the current node. Pointers are maintained to keep track of the optimal paths and the optimal departure times from each node along these paths. Because unlimited waiting is permitted, if a path to node j exists with arrival time αj , then a path to node j exists at any later time t > αj . Thus, the path and time pointers are updated at these later departure times to reflect this. If it is possible to arrive at the successor node at a time that is earlier than previously recorded via another path, this earliest arrival time will be recorded and the pointers will be updated to reflect this improvement. Because the earliest arrival time at the node has improved, a path that uses this path as a subpath may lead to lower earliest arrival times at other nodes. Thus, this node will enter the SE list (assuming it is not already in the list). Once all the successor nodes of the current node have been considered, another node is selected from the SE list, commencing the next iteration of the algorithm. The algorithm stops once an iteration has completed and the SE list is empty. Upon termination, the earliest arrival time αi , capacity κi and associated path Pi (including arcs along the path, as well as the associated departure times for each arc) at all nodes i ∈ N from origin k for the earliest departure time are provided. PROPOSITION 1. The TDEAT Algorithm has O(|N|2 T 2 ) worst-case computational complexity. A proof of this proposition is given following the pseudocode and proof of optimality in Appendix B. 2.4. THE TIME - DEPENDENT QUICKEST FLOW (TDQFP) ALGORITHM The TDQFP algorithm solves the time-dependent quickest flow problem (TDQFP) as well as the time-dependent evacuation and time-dependent quickest transshipment problems subsequent to the transformations presented in Subsections 2.1 and 2.2. As with the successive shortest path algorithm for solving minimum cost network flow problems in static networks, optimality of the solution is maintained


51

at every step of the TDQFP algorithm and the objective is to achieve feasibility. While feasibility is maintained with respect to the non-negativity and arc capacity constraints, the flow conservation constraints are not held at the terminal nodes. At each iteration of the TDQFP algorithm, an incremental amount of flow is shipped between the source and sink along the arcs of the time-dependent residual network, reducing this imbalance at the terminal nodes. If, at each iteration of the TDQFP algorithm, the decision to ship along a path were set permanently, the algorithm would not guarantee optimality. Backward arcs are introduced in order to permit the return of capacity to an arc, corresponding to reversing decisions from previous iterations as a means for improving the objective function. The algorithm terminates once the flow conservation constraints are met and feasibility is achieved, i.e. once all the supply is shipped from the source to the sink. The algorithm that was outlined in the beginning of this section is now presented using the time-dependent dynamic network ℵ = (G, u, τ ) with source node k and sink node l. Additional notation that is used in the algorithm description include: e(t) = excess supply at the source at time t. t = minimum value of t such that there is positive supply at the source. rij (t) = the residual capacity on arc (i, j ) at time t. TDQFP Step 0. Initialize the following variables: x = 0, G(x) = G and e(t) = bk (t), ∀t ∈ {0, . . . , T }. Step 1. Determine t, where t = mint ∈{0,...,T } (t : e(t) > 0). Call the function TDEAT(k, t, T , G(x)), whose output contains αl , κl , and Pl . Determine ε, where ε = min[e( t ), κl ]. If ε = 0, stop, the problem is infeasible. Augment ε units of flow along path Pl , i.e., increase xij (t) by ε, ∀((i, j ), t) ∈ Pl . Decrease e( t ) by ε. If t ∈{0,...,T } e(t) = 0, Stop. Determine the residual capacities for all (i, j ) ∈ A given the flow x.   uij (t) − xij (t) + xj i (t + τij (t)), rij (t) = ∀{t ∈ {0, . . . , T } | t αi , t + τij (t) T },  0, ∀{t ∈ {0, . . . , T } | t < αi }. Note it is only necessary to update r (t) if either the original arc (i, j ) or on the backwards arc ij

(j, i) lie on path Pi.

52


Backward arc update: Add the backward arc (j, i) to the residual graph, G(x), if it does not already exist, for each (i, j ) ∈ A, such that for some t ∈ {0, . . . , T }, xij (t) > 0 and j = l. For all backward arcs, (j, i), update the following travel times and residual capacities. −τij (t), t = t + τij (t), ∀{t ∈ {0, . . . , T } | xij (t) > 0}, τj i (t ) = T, ∀{t ∈ {0, . . . , T } | xij (t) = 0}.   xij (t) − xj i (t ), t = t + τij (t), rj i (t ) = ∀{t ∈ {0, . . . , T } | xij (t) > 0},   0, ∀{t ∈ {0, . . . , T } | xij (t) = 0}. Repeat Step 1. Step 0 is simply an initialization step. In particular, the residual network is initialized to the original graph. The excess e(t), that tracks the remaining flow to be sent through the network beginning at each time, is initialized to the supply values at each time t. In Step 1, the paths are determined and flow is sent. The TDEAT algorithm is used to determine the paths. The amount to send along the path is limited by the minimum capacity on any arc along the path and by the amount of supply that remains to be sent. If this value is zero, then there is no way to send any more supply and the algorithm terminates with the conclusion that the problem is infeasible. Once the flow has been sent, the excess, e( t ) is decreased and the residual network is updated as follows. The capacities on the arcs along the chosen path are reduced accordingly. Backward arcs are added to the residual graph in order to permit the return of capacity to an arc. Suppose we have positive flow on arc (i, j ) at time t and we wish to create a backward arc (j, i). The travel times and residual capacities on these backward arcs in the residual network are computed by τj i (t + τij (t)) = −τij (t) and rj i (t + τij (t)) = xij (t). This allows some portion of a previously scheduled shipment to be returned to the original node at the original departure time. Finally, Step 1 is then repeated until the stopping condition is met, i.e. until all the supply has been sent. The TDQFP algorithm terminates with the set of arc flows, x. If the solution contains xj i (t + τij (t)) positive units of flow along a backward arc (j, i) for some t ∈ {0, . . . , T }, then xij (t) is reduced by xj i (t + τij (t)) units, i.e. the flow along a backward arc (j, i) at time t + τij (t) cancels the same amount of flow along the forward arc (i, j ) at time t. PROPOSITION 2. The TDQFP algorithm terminates with optimal flow values. Note that if real arcs (i, j ) and (j, i) exist in A and if the backward arc of (i, j ) is introduced,

then this backward arc must be denoted in such a way that it can be distinguished from the original arc (j, i) in A.


53

The proof of this follows immediately from the optimality of the TDEAT algorithm and the successive shortest path technique. PROPOSITION 3. The TDQFP algorithm is pseudopolynomial with running time O(F · B), where F is the running time of the embedded least time path algorithm. Assuming the TDEAT algorithm is used for the least time path algorithm, the worst-case computational complexity of the TDQFP algorithm is O(B · |N|2 · T 2 ). Note that if one chooses to solve the TDQFP using a time-expanded network, then the problem becomes a minimum time flow problem and can be solved using the successive shortest path algorithm. This procedure would involve the following steps. Construct the space-time expansion, where arc costs are the arc travel times for the associated departure times and each arc has an associated capacity given by the capacity in the original network for the appropriate departure time. Associate the supply bi (t) with node–time pair (i, t). Introduce a terminal node with incoming arcs from all destination node–time pairs with zero travel times and infinite capacities. Find the least cost path from an origin–time pair to the terminal node and ship as much flow along this path as the path’s capacity and supply permit. Update the arc capacities for all arcs along the path. Introduce backward arcs (if they do not already exist) for each arc used in the path and set the costs and capacities. Repeat the process of finding least cost paths and sending flow until all the supply has been shipped. Implementing the successive shortest path procedure as described above on a time-expanded network requires a label correcting algorithm. The use of backward arcs introduces cycles and arcs with negative travel times (although no negative cycles will exist). The best known complexity of a label correcting algorithm is O(Number of nodes · Number of arcs). The time-expanded network consists of |N|T nodes and |A|T arcs. Similar to the TDQFP algorithm, in the worst-case only one unit of flow will be shipped at each iteration, accounting for O(B). Thus, this process has worst-case computational complexity of O(B|N||A|T 2 ). Alternatively, one can work with reduced costs and, thus, avoid the issue of working with negative arc travel times in the residual network. This is because the reduced cost of any arc employed at any departure time that might be contained in any path from the origin will be nonnegative. One can implement the successive shortest path algorithm on this time-expanded network with a label setting based shortest path algorithm. The best strongly polynomial-time bound for solving the shortest path problem with nonnegative arc lengths is O(Number of arcs + Number of nodes log(Number of nodes)) by Fibonacci heap implementation of Dijkstra’s algorithm [1]. Consequently, the time-dependent quickest flow problem in a time-expanded network working with reduced costs can be solved with worst-case computational complexity of O(BT (|A| + |N| log |N|T )). One could also implement a version of the TDQFP algorithm that works with reduced costs and employs a time-dependent residual network, obviating the need for the space-time expansion. This implementation is described next.

54


Let’s begin with the linear programming formulation of the time-dependent minimum time dynamic flow problem, (P ) min τij (t)xij (t), (i,j )∈A\{(l,l)},t ∈{0,...,T }

xij (t) −

j ∈δ + (i)

j ∈δ − (i)

{t |t +τji (t )=t }

0 xij (t) uij (t),

xj i (t ) = bi (t),

∀(i, j ) ∈ A, t ∈ {0, . . . , T },

and determine the dual formulation, bi (t)πi (t) − (D) max i∈N,t ∈{0,...,T }

∀i ∈ N, t ∈ {0, . . . , T },

zij (t)uij (t),

(i,j )∈A,t ∈{0,...,T }

πi (t) − πj (t + τij (t)) − zij (t) τij (t), ∀(i, j ) ∈ A\{(l, l)}, t ∈ {0, . . . , T }, πl (t) − πl (t + τll (t)) − zll (t) 0, ∀t ∈ {0, . . . , T }, zij (t) 0, ∀(i, j ) ∈ A, t ∈ {0, . . . , T }. The node potentials (dual variables of the flow balance constraints) are represented by πi = {πi (t) | t ∈ {0, . . . , T }} and can be interpreted as the negative of the amount of time required to send a unit of flow from the origin so that it arrives at node i by time t. With respect to these node potentials, we define reduced costs according to the following relationship which is maintained throughout the algorithm. cijπ (t) = τij (t) − πi (t) + πj (t + τij (t)), ∀(i, j ) ∈ G(x)\{(l, l)}, and {t ∈ {0, . . . , T } | t + τij (t) T }. π cll (t) = 0 − πl (t) + πl (t + τll (t)), ∀{t ∈ {0, . . . , T } | t + τll (t) T }. Note that cllπ (t) is defined separately since the cost on this arc is zero in the primal objective function, i.e. there is no cost for arriving at the sink early and waiting to satisfy the demand at period T . Using the reduced costs, we can re-express the dual as: bi (t)πi (t) − max{0, −cijπ (t)}uij (t) . (D) max i∈N,t ∈{0,...,T }

(i,j )∈A,t ∈{0,...,T }

Defining a time-dependent residual network in terms of the node potentials, reduced costs and residual capacities helps to frame this technique within the existing network flow literature for static networks. At Step 0, initialize the node potentials for all i ∈ N and t ∈ {0, . . . , T }, as πi (t) = 0, then, after the first flow has been sent (in the first iteration of TDQFP), set the node potentials as follows, πi (t) = −t,

∀i = l, t ∈ [αi , T ],

and

πl (t) = −αl ,

∀t ∈ [αl , T ].

55


Note that the reduced cost values will be zero for all arcs, except those ending with the sink node, i.e. cijπ (t) = 0, ∀i ∈ N, j ∈ N\{l}, t ∈ {0, . . . , T }. This will remain true for all remaining iterations, so there is no need to ever update these values. For the remaining iterations, instead of finding the earliest arrival time path to the sink, use the residual costs to determine the path along which flow will be sent. Since the reduced costs are only positive for the arcs incident on the sink, determine the minimum reduced cost for all feasible times. For each predecessor node of the sink j ∈ δ − (l)\{l}, determine the earliest feasible time, αj , using the TDEAT algorithm. In particular, for each j ∈ δ − (l)\{l}, compute the minimum reduced cost from node j to l with remaining capacity, Cj =

min

{t ∈{0,...,T }|t αj ,t +τjl (t )T }

(cjπl (t) : rj l (t) > 0),

and the associated departure time at which the minimum reduced cost is found, ϒj = arg

min

{t ∈{0,...,T }|t αj ,t +τjl (t )T }

(cjπl (t) : rj l (t) > 0).

For all j ∈ δ − (l), select the node with the minimum reduced cost, µ = arg min (Cj ). − j ∈δ (l)

Send ε units of flow, where ε = min[e( t), κµ , rµl (ϒµ )] along Pµ . Hold ε units of flow at node µ from t = αµ until ϒµ . Finally, send ε units of flow along (µ, l) e( t) by ε. Note, as before, if ε = 0, stop, the problem at time t = ϒµ . Decrease is infeasible and if t ∈{0,...,T } e(t) = 0, we are done. Otherwise, update πl (t) as follows πl (t) = πl (t) − Cµ ,

∀t ∈ [αl , T ].

Recompute the reduced costs for the arcs incident on the sink node at all feasible times, i.e. cjπl (t) = τj l (t) − πj (t) + πl (t + τj l (t)), ∀j ∈ δ − (l)\{l}, and {t ∈ {0, . . . , T } | t αj , t + τj l (t) T , rj l (t) > 0}. Subsequently, update the residual network G(x) by the residual capacity and backward arc updates described in the TDQFP algorithm in Subsection 2.4. Continue iterating in this fashion until the stopping criterion is met. 3. Illustrative Example In this section, an example is worked out in detail. The purpose of this section is to clarify the notation and steps of the algorithm, as opposed to presenting an application of this method to a real-world problem. The time-dependent network

56


Figure 4. Example network.

is depicted in Figure 4. The example has five nodes, seven arcs connecting those nodes and five holdover arcs. Node 1 is the source node, k = 1, and node 5 is the sink node, l = 5. An initial supply of four units originates at the source node at time 0, b1 (0) = 4, a later supply of two units follows at time 2, b1 (2) = 2. These six units of flow must satisfy the demand at the sink node by time T = 15. If an upper bound had not been provided, one could use the technique in Appendix A to find an upper bound, as we have done here. For this example, B stat stat T = t + αl + κ stat l 6 = 15. = 5+8+ 3 The time, t stat , at which the travel conditions become stationary is 5. The shortest path distance given stationary travel times, αlstat, which, in this example, corresponds to the path 1 → 4 → 5, is 8. The total supply, B, is 6 and the capacity of the shortest stationary path, κlstat, is 3. The time-dependent travel times and capacities are given in Table I. Recall that for all t ∈ {0, . . . , T }, τii (t) = 1 and uii (t) = ∞ for all i ∈ N. Step 0: Initialize the variables x = 0, e(0) = 4 and e(2) = 2. Step 1: t = 0. Call the function TDEAT(1, 0, 15, G(0)) whose results are given in Table II. From these values, we determine α, κ and P. α5 = 5, κ5 = 2, P5 = {((1, 2), 0), ((2, 3), 1), ((3, 5), 3)}. Determine ε, where ε = min[e(0), κ5 ] = min[4, 2] = 2. Augment ε units of flow along P5 : x12 (0) = 2, x23 (1) = 2, x35 (3) = 2. Decrease e(0) by ε: e(0) = 4 − 2 = 2. All original rij (t) remain the same except for r12 (0) = 0, r23 (1) = 3, r35 (3) = 0. Add arcs (2, 1), (3, 2), and (5, 3) with the following properties. τ21 (1) = −1, r21 (1) = 2, τ21 (t) = 15, r21 (t) = 0, ∀t ∈ {0, 2, . . . , 15}. τ32 (3) = −2, r32 (3) = 2, τ32 (t) = 15, r32 (t) = 0, ∀t ∈ {0, 1, 2, 4, . . . , 15}. τ53 (5) = −2, r53 (5) = 2, τ53 (t) = 15, r53 (t) = 0, ∀t ∈ {0, . . . , 4, 6, . . . , 15}.

57


Table I. Time-dependent travel times and capacities for the example (i, j )

(1, 2)

τij (t)

1, 4,

t =0 t 1

uij (t) 2

(1, 4)

(2, 3)

2, t = 0 3, t 1

2, 3,

t 1 t 2

5, t = 0 3, t 1

5, 3,

t 1 t 2

(4, 3) 2, t 1 1, t = 2 3, t 3 4, t 3 2, t 4

(2, 5) 5, t 2 3, t = 3 5, t 4 5

(3, 5)

(4, 5)

2, 5,

t 3 t 4

2, 5,

2, 5,

t 4 t 5,

5

t 1 t 2

Table II. Results after first pass of TDEAT 0

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

P1 P2

0 ∞

1 1

1 2

1 2

1 2

1 2

1 2

1 2

1 2

1 2

1 2

1 2

1 2

1 2

1 2

1 2

P3 P4

∞ ∞

∞ ∞

∞ 1

2 4

3 4

3 4

3 4

3 4

3 4

3 4

3 4

3 4

3 4

3 4

3 4

3 4

P5 D1 D2

∞ 0 ∞

∞ 0 0

∞ 1 1

∞ 2 2

∞ 3 3

3 4 4

2 5 5

5 6 6

5 7 7

5 8 8

5 9 9

5 10 10

5 11 11

5 12 12

5 13 13

5 14 14

D3 D4

∞ ∞

∞ ∞

∞ 0

1 2

3 3

4 4

5 5

6 6

7 7

8 8

9 9

10 10

11 11

12 12

13 13

14 14

D5 U1 U2

∞ ∞ ∞

∞ ∞ 2

∞ ∞ 2

∞ ∞ 2

∞ ∞ 2

3 ∞ 2

1 ∞ 2

6 ∞ 2

7 ∞ 2

8 ∞ 2

9 ∞ 2

10 ∞ 2

11 ∞ 2

12 ∞ 2

13 ∞ 2

14 ∞ 2

U3 U4

∞ ∞

∞ ∞

∞ 5

2 5

2 5

2 5

2 5

2 5

2 5

2 5

2 5

2 5

2 5

2 5

2 5

2 5

U5

∞

∞

∞

∞

∞

2

2

2

2

2

2

2

2

2

2

2

Step 1: Compute t = 0 and call the function TDEAT(1, 0, 15, G(x)) whose results are given in Table III. From these values, we determine α, κ and P. α5 = 6, κ5 = 2, P5 = {((1, 4), 0), ((4, 3), 2), ((3, 2), 3), ((2, 5), 1}. Determine ε, where ε = min[e(0), κ5 ] = min[2, 2] = 2. Augment ε units of flow along path P5 : x14 (0) = 2, x43 (2) = 2, x32 (3) = 2, x25 (1) = 2. Decrease e(0) by ε: e(0) = 2 − 2 = 0. All original rij (t) remain the same except for r14 (0) = 3, r43 (2) = 2, r23 (1) = 5, r25 (1) = 3. Add arcs (4, 1), (3, 4), and (5, 2) with the following properties. Note that since arc (3, 2) already exists, all we need to do is adjust its properties.

58


Table III. Results after the second pass of TDEAT P1

0 0

1 1

2 1

3 1

4 1

5 1

6 1

7 1

8 1

9 1

10 1

11 1

12 1

13 1

14 1

15 1

P2 P3

∞ ∞

3 ∞

2 ∞

2 4

2 3

1 3

2 3

2 3

2 2

2 3

2 3

2 3

2 3

2 3

2 3

2 3

P4 P5

∞ ∞

∞ ∞

1 ∞

4 ∞

4 ∞

4 ∞

4 2

4 4

4 5

4 5

4 2

4 5

4 5

4 5

4 5

4 5

D1 D2 D3

0 ∞ ∞

0 3 ∞

1 1 ∞

2 2 2

3 3 3

4 1 4

5 5 5

6 6 6

7 7 5

8 8 8

9 9 9

10 10 10

11 11 11

12 12 12

13 13 13

14 14 14

D4 D5

∞ ∞

∞ ∞

0 ∞

2 ∞

3 ∞

4 ∞

5 1

6 2

7 7

8 8

9 5

10 10

11 11

12 12

13 13

14 14

U1 U2 U3

∞ ∞ ∞

∞ 2 ∞

∞ 2 ∞

∞ 2 4

∞ 2 4

∞ 2 4

∞ 2 4

∞ 2 4

∞ 2 2

∞ 2 2

∞ 2 2

∞ 2 2

∞ 2 2

∞ 2 2

∞ 2 2

∞ 2 2

U4 U5

∞ ∞

∞ ∞

5 ∞

5 ∞

5 ∞

5 ∞

5 2

5 5

5 5

5 5

5 2

5 2

5 2

5 2

5 2

5 2

τ41 (2) = −2, r41 (2) = 2, τ41 (t) = 15, r41 (t) = 0, ∀t ∈ {0, 1, 3, . . . , 15}. τ34 (3) = −1, r34 (3) = 2, τ34 (t) = 15, r34 (t) = 0, ∀t ∈ {0, 1, 2, 4, . . . , 15}. τ52 (6) = −5, r52 (6) = 2, τ52 (t) = 15, r52 (t) = 0, ∀t ∈ {0, 1, . . . , 5, 7, . . . , 15}. r32 (t) = 0, ∀t ∈ {0, . . . , 15}. Step 1: Compute t = 2 and call the function TDEAT(1, 2, 15, G(x)) whose results are given in Table IV. From these values, we determine α, κ and P. α5 = 10, κ5 = 3, P5 = {((1, 4), 2), ((4, 5), 5)}. Determine ε, where ε = min[e(2), κ5 ] = min[2, 3] = 2. Augment ε units of flow along path P5 : x14 (2) = 2, x45 (5) = 2. Decrease e(2) by ε: e(2) = 2 − 2 = 0. t ∈[0,15] e(t) = 0, Stop. The final solution is to send 2 units along the path {((1, 2), 0), ((2, 5), 1)} which arrives at the sink at time 6, 2 units along the path {((1, 4), 0), ((4, 3), 2), ((3, 5), 3)} which arrives at the sink at time 5, and 2 units along the path {((1, 4), 2), ((4, 5), 5)} which arrives at the sink at time 10. The minimum total time spent completing these shipments is 12 + 10 + 16 = 38 and the time-dependent quickest flow time is 10. 4. Computational Results The average run time and other characteristics of the TDQFP algorithm are examined through numerical experiments conducted on randomly generated networks.

59


Table IV. Results after the third pass of TDEAT P1

2 0

3 1

4 1

5 1

6 1

7 1

8 1

9 1

10 1

11 1

12 1

13 1

14 1

15 1

P2 P3

∞ ∞

∞ ∞

∞ ∞

∞ ∞

1 ∞

2 ∞

2 4

2 2

2 3

2 3

2 3

2 3

2 3

2 3

P4 P5

∞ ∞

∞ ∞

∞ ∞

1 ∞

4 ∞

4 ∞

4 ∞

4 ∞

4 4

4 2

4 5

4 5

4 5

4 5

D1 D2 D3

2 ∞ ∞

2 ∞ ∞

3 ∞ ∞

4 ∞ ∞

5 2 ∞

6 6 ∞

7 7 5

8 8 6

9 9 9

10 10 10

11 11 11

12 12 12

13 13 13

14 14 14

D4 D5

∞ ∞

∞ ∞

∞ ∞

2 ∞

5 ∞

6 ∞

7 ∞

8 ∞

9 5

10 6

11 11

12 12

13 13

14 14

U1 U2 U3

∞ ∞ ∞

∞ ∞ ∞

∞ ∞ ∞

∞ ∞ ∞

∞ 2 ∞

∞ 2 ∞

∞ 2 2

∞ 2 2

∞ 2 2

∞ 2 2

∞ 2 2

∞ 2 2

∞ 2 2

∞ 2 2

U4 U5

∞ ∞

∞ ∞

∞ ∞

3 ∞

3 ∞

3 ∞

3 ∞

3 ∞

3 3

3 2

3 2

3 2

3 2

3 2

In this section, the experimental design and methodology for generating the networks with their time-varying arc traversal times and capacities, as well as the time-varying supply, are presented. Additional runs were completed on problem instances generated by NETGEN and provided at the MP-TESTDATA website (see Appendix C for additional detail). The results and analysis of these tests are provided.

4.1. EXPERIMENTAL DESIGN The first set of experiments were conducted on seven randomly generated networks using a random network generator adapted from [30]. A procedure is used to ensure connectivity as described in [22]. Four factors must be specified in order to generate the network topology, the arc capacities and traversal times, and the supply. These factors include the number of nodes, N, the average degree at each node, D, the number of time intervals in the nonstationary period, I , and the total amount of supply to be shipped, B. The networks that are considered have either 25, 100 or 500 nodes. For one network of each size (i.e. 25, 100, and 500 nodes), the average in- and out-degree at each node is approximately 4. The in- or out-degree of the nodes in these networks can each vary between 2 and 9. For the 100 node networks, we further tested networks with constant in- and out-degree each of 25, 50, 75 or 90. The total duration of the nonstationary period is taken as 60, 120 and 240 time intervals.

60


Three size problems are specified with respect to the supply: small, medium and large. The small problem assigns 5 units of supply to one-quarter of the nonstationary period, the medium problem assigns supply to one-half of the nonstationary period and the large problem assigns supply to three-quarters of this period. The largest supply considered in this set of experiments is 900 units. The arc traversal times for each time interval are randomly generated between 1 and 15 units of time and are integer-valued. The arc capacities for each time interval are randomly generated between 1 and 20 units and again are integer-valued. These arc attributes were chosen so that the number of paths ultimately required to ship the supply from its source to the sink would lie somewhere between the best case (e.g., a small problem with 60 time intervals could at best ship 5 units of supply out at each of 15 time intervals, requiring at least 15 paths) and the worst case (each unit on its own path, requiring 75 paths). Finally, the origin and destination were randomly selected. Results were obtained for a single randomly selected origin and 10 randomly selected destinations. The average of these results was then recorded. For each source-sink pair, we used the equation T = t stat + αlstat + κBstat , as l discussed in Appendix A, to compute a bound on the time-dependent quickest flow time. This bound is required in order to compute the earliest arrival time paths. In addition to these runs on randomly generated networks, the TDQFP algorithm was tested on the Cap1.net and Cap4.net networks, instances of minimum cost flow problems with static attributes generated by NETGEN and provided at the MP-TESTDATA web site. The parameters used to create these networks are given in Appendix C, along with the current web site location for accessing the source code for NETGEN and the Cap1.net and Cap4.net files we used herein. As there are no publicly available related problem instances with time-varying attributes, we selected these general networks and modified them appropriately. The Cap1 network consists of 1,000 nodes and 10,000 arcs, arc costs (which we assumed to be travel times) between 1 and 10,000, and capacities for 80% of the arcs ranging from 20,000 to 120,000. The Cap4 network consists of 5,000 nodes and 30,000 arcs, arc costs (times) between 1 and 10,000 and capacities for 90% of the arcs ranging between 30,000 and 150,000. In the Cap1 and Cap4 networks, the remaining 20% and 10% of the arcs, respectively, have unlimited capacity. A nonstationary period of 240 time intervals was assumed. In order to maintain the characteristics of the original problem, while also including time-varying networks attributes, the arc capacities were cut in half and the travel times were doubled for one-quarter of the nonstationary period (from time intervals 90 through 150). At all other departure times, the original scaled capacities and travel times (as generated by NETGEN) were used. Because the arc travel times are often set to very high values, a very high time-dependent quickest flow time bound T will be computed in order to solve quickest flow problem versions of these problem instances. Thus, it was necessary to scale the problem instances in order to obtain a solution. Several instances of each problem were run, where the problems are scaled by dividing the supply values, arc costs (times) and capacities by either


61

10 (for Cap1) or 100 (for Cap4). For these instances, more than one value of total supply are tested, including a case where the supply value is significantly greater than posed in the original problem. Similar to the first set of tests, it is assumed that all supply units are available for shipping before three-quarters of the nonstationary period (the first 180 time intervals) has elapsed. The quickest flow problem employs only a single source and single sink. For each problem instance, we randomly selected three such pairs from the nodes specified by NETGEN as sources and sinks. Additional experiments were run to assess the performance of the TDQFP algorithm on problem instances with multiple sources and sinks (2 × 2, 5 × 5, 5 × 15, 15×5 and 15×15). These experiments were run for varying level of supply (small, medium and large) on networks with 25, 50, 100, and 500 nodes. The results of these experiments were similar to that found from the initial set of experiments for single source-single sink problem instances described in detail in the following section. For all experiments described in this section, the TDQFP and TDEAT algorithms were implemented in C++ and run on an AlphaServer 1200/533 dual processor computer with 1 gigabyte ram and 1.5 gigabytes swap, running Digital 4.0E operating system, using Digital’s C++ compiler. The results of these tests are given in the next subsection.

4.2. EXPERIMENTAL RESULTS The results of the first set of experiments are given in Tables V and VI. In Table V, results are reported for the three networks with average in- and out-degree each of four. In Table VI, the results are given for the tests conducted on the 100 node networks with a nonstationary time period of 120 time intervals with varying node degree. In the tables, the column headed “T bound” gives the average (over ten randomly selected destination nodes) estimated T (i.e. bound on the time-dependent quickest flow time as estimated using the equation given in Appendix A). For each selected destination, the TDQFP algorithm is then run with the chosen T . The optimal solution is obtained, providing the arrival time of the last unit of supply at the destination. This is referred to as the optimal T . The average optimal T for the ten runs is provided in the column headed “Optimal T .” The resulting number of paths used to ship all of the supply is given in the column headed “Number of paths.” The average run time using the upper bound on T is given under the column heading “TDQFP run time.” The portion of that run time that was spent determining the earliest arrival time paths is given under the column heading “TDEAT run time.” All run times reported in this paper are in user c.p.u. seconds, unless specified otherwise. The run times do not include I/O time, as is common practice in reporting such average run times. Upon determining the optimal T , the code was rerun to determine the run time that would have resulted from selecting the optimal T with which to start, i.e. the best that any bound could provide. This

62


Table V. Computational test results on three networks with average in- and out-degree each of 4 Optimal Number TDQFP TDEAT Optimal N I Supply T bound T of paths run time run time run time small 103.2 49.6 24.8 0.04 0.02 0.02 60 medium 144.5 55.4 50.2 0.1 0.07 0.04 large 143.2 56.7 80.0 0.2 0.1 0.05 25

small medium large

176.7 255.3 272.7

99.1 100.3 98.0

48.4 101.9 140.2

0.1 0.4 0.6

0.08 0.2 0.4

0.05 0.1 0.2

small medium large small medium large

452.3 722.9 745.2 95.9 173.7 243.4

187.6 189.5 190.9 50.4 61.7 63.6

100.9 213.9 333.5 22.8 56.8 88.2

0.7 2.7 4.4 0.1 0.7 1.6

0.4 1.6 2.7 0.09 0.4 1.0

0.2 0.5 0.8 0.07 0.2 0.3

small medium large

180.5 214.9 239.6

103.0 103.0 102.2

52.2 109.6 154.3

0.6 1.5 2.4

0.3 0.9 1.4

0.3 0.6 0.8

small medium large small medium large

403.8 419.5 609.0 133.8 142.5 264.6

192.0 196.0 196.4 64.3 72.9 73.5

111.1 242.7 360.3 36.8 73.5 113.5

2.9 6.9 18.2 2.0 4.3 14.3

1.8 4.2 11.1 1.2 2.6 8.7

1.0 2.4 3.5 0.8 1.7 2.6

120

small medium large

236.4 279.2 243.7

112.8 112.0 112.3

65.7 134.4 204.2

6.4 16.7 21.4

3.8 10.1 13.0

2.3 4.6 7.0

240

small medium large

381.9 491.8 768.1

195.0 199.6 202.4

122.0 277.9 437.6

19.1 61.8 162.4

11.1 36.9 99.1

6.7 17.1 27.1

120

240

60

100

120

240

60

500

was done purely to assess the impact of the chosen T on the run time. The resulting run times are shown under the column heading “Optimal run time.” From Table V, we see that the optimal T is often much lower than the T chosen by our bound (on the order of 0.26 to 0.57 of the chosen T ). Note that the optimal T increases with the number of time intervals in the nonstationary period, but hardly increases with increasing supply. This is due to the fact that the supply is equally likely to be assigned to any of the first three-quarters of the nonstationary period, regardless of the amount of supply to be shipped. In addition, the number of paths falls comfortably within its lower and upper bounds. On average, the run time of the algorithm using the T chosen by the upper bound is 3.4 (between 1.4 and 6) times worse than the run time resulting from using the optimal T . Additionally, on


63

average, approximately 60% of the run time is spent determining the earliest arrival time paths. In order to characterize the performance of the TDQFP algorithm using the upper bound T (TDQFPRT ), as well as the optimal T (OptimalRT ), the natural log of the average run time in user c.p.u. milliseconds is regressed against the natural log of the number of nodes (N), value of the upper bound T (Tb ), or the optimal T (Topt ), and total units of supply to be shipped (B), resulting in the following equations, each with an R 2 -value of 99.4% and 99.6%, respectively. TDQFPRT = (0.000037)N 1.22 Tb1.11 B 1.06 0.829 1.07 and OptimalRT = (0.00013)N 1.19 Topt B . From the regression analyses, one can see that the average run time increases slightly worse than linearly with the number of nodes, approximately linearly with T and linearly with the total amount of supply to be shipped. Additional analysis results in the following regression equation with an R 2 of 99.6% concerning the portion of the run time used to determine the earliest arrival time paths, given the tests run using the upper bound on T (as opposed to the optimal T ). Here, rather than take the log of run time of the TDEAT algorithm directly, the log of the TDEAT algorithm run time divided by the number of paths used is taken to account for the fact that the TDEAT algorithm is run multiple times. The resulting equation is given as follows. TDEATRT = (0.00014)N 1.11 Tb1.10 . Thus, the run time increases nearly linearly with respect to the number of nodes and size of T . The tests were not designed to test the TDEAT algorithm itself, so some overhead is included in these run times that would not have been had the tests been specifically designed for use in this algorithm. Additional analyses were conducted to assess the impact of the degree of the network. Results of the tests run on the 100 node networks with varying degree at the nodes for a nonstationary period of 120 time intervals are given in Table VI. Similar results were found for a nonstationary period of 60 and 240 time intervals, thus, detailed results are not reported here. In order to characterize the performance of the TDQFP algorithm using the upper bound T (TDQFPRT ), as well as the optimal T (OptimalRT ), as the degree of the network increases, the natural log of the average run time in user c.p.u. milliseconds is regressed against the natural log of the number of arcs (M) (as a surrogate for degree), value of the upper bound T (Tb ), or the optimal T (Topt ), and total units of supply to be shipped (B), resulting in the following equations, with an R 2 -value of 98.9 % and 98.5%, respectively. TDQFPRT = (0.000048)M 1.07 Tb0.852 B 1.09 0.684 1.01 and OptimalRT = (0.000066)M 1.16 Topt B . From the regression analyses, one can see that the average run time increases nearly linearly with the number of arcs, value of T and the total amount of supply.

64


Table VI. Computational test results for N = 100, I = 120 Optimal Number Degree Supply T bound T of paths small 180.5 103.0 52.2 4 medium 214.9 103.0 109.6 large 239.6 102.2 154.3 25

50

75

90

TDQFP run time 0.6 1.5 2.4

TDEAT run time 0.3 0.9 1.4

Optimal run time 0.3 0.6 0.8

small medium large small medium large small medium large

167.0 248.5 349.1 160.9 208.3 265.1 187.1 206.1 280.3

94.5 94.1 94.4 93.1 93.1 92.6 92.7 92.8 92.6

44.6 88.6 136.3 41.0 83.2 127.1 44.3 97.7 137.6

3.2 10.2 23.4 6.5 17.1 34.3 13.6 33.3 62.0

1.4 4.8 11.4 2.4 6.9 14.6 4.8 12.2 24.9

1.5 2.9 4.5 3.7 7.2 11.1 7.1 15.3 21.9

small medium large

158.9 160.2 204.5

92.8 92.6 91.6

49.0 96.1 149.2

16.8 33.1 62.0

5.6 10.8 22.8

10.3 19.8 29.5

Moreover, both sets of runs show that the average performance of the TDQFP and TDEAT algorithms is significantly better than predicted by worst-case complexity analyses. The results of the second set of experiments conducted on the Cap1 and Cap4 networks are shown in Table VII. In general, the run times increased less than linearly with increasing supply. For nearly all cases where the TDQFP algorithm is run with an estimated bound on T , when the supply is increased by a factor of 10, the run times were increased by a factor less than 10 (between 2 and 9). For the runs employing the optimal T , the run times increased by a factor between 2 and 4 for nearly all cases. The exception is when the supply is increased from 500,000 to 5,000,000 for the Cap1 network. In this case, the run times increased by a factor between 36 and 45 for the estimated T bound and between 13 and 20 for the optimal T . This increase is due to the relative value of arc capacity to the total supply. While the supply is increased, the path capacities remain constant. Thus, as is shown in the table, a much larger number of paths is required for completing the shipments. If we were to use the regression equations developed earlier in this subsection to estimate the run times for these cases, we would find that the equations will significantly overestimate the times. For example, the estimated run time using the equation TDQFPRT = (0.000048)M 1.07 Tb0.852B 1.09 for Cap1 with 500,000 supply units with attributes scaled by 10 is 454,517 seconds for source-sink pair (1 and 986), while the actual run time was only 349 seconds. Similar relative differences are found for all of these cases and for the optimal runs times using the optimal

65


Table VII. Computational test results rounded to nearest whole number for NETGEN generated networks B

Number of paths

TDQFP run time

Optimal run time

777 816 1,092

190 192 187

108 142 210

86 114 177

1,021 1,067 1,309 2,671 2,783 2,714

825 885 1,125 1,168 1,314 1,461

396 463 356 2,996 2,723 3,934

349 505 506 15,678 18,159 22,424

202 333 362 3,059 4,384 7,301

347 490 431 471 670 611

273 410 351 289 421 367

183 187 187 425 391 591

322 443 484 1,329 1,647 2,745

156 271 307 392 607 1,156

Source & sink pair

T bound

1 & 986 8 & 997 15 & 1000

856 896 1,168

1 & 986 8 & 997 15 & 1000 1 & 986 8 & 997 15 & 1000 1 & 4941 11 & 4978 24 & 4988 1 & 4941 11 & 4978 24 & 4988

Optimal T

Cap1.net 50, 000 (10) 500,000 (10) 5,000,000 (10) Cap4.net 6,000 (100) 60,000 (100)

T value. This disparity is due to the way that the problem instances were designed. The randomly generated problem instances generated for the first set of experiments were, by design, more difficult problems. The results of these experiments using the Cap1 and Cap4 networks indicate that the TDQFP algorithm can be used to solve large-size problems. The algorithm finds the optimal solution for the Cap1 network (with 1000 nodes and 10,000 arcs, where the network attributes are scaled by 10) with a total supply of 5,000,000 units available over a period of 180 time intervals in an average over the three randomly selected source-sink pairs of 18,754 c.p.u. seconds or 5.2 c.p.u. hours. Thus, the algorithm could be used to solve rather large problems in a time-frame that is suitable for planning, or relatively short-term, decision contexts. As the reported run times employ a rather crude method for estimating a bound on T , even shorter run times can be achieved through better techniques for estimating this bound.

5. Conclusions and Extensions In this paper, the pseudopolynomial time TDQFP algorithm is presented for solving the integral time-dependent quickest flow, evacuation and quickest transship-

66


ment problems defined on dynamic and time-dependent networks. Such problems with time-varying and dynamic attributes arise in a large variety of applications across nearly all industries. Results of numerous computational tests on randomly generated networks indicate that the average performance of this algorithm is much better than expected by worst-case computational complexity analysis. In fact, the algorithm can be used to solve relatively large problem instances, including a 1,000 node network with five million units of supply, in reasonable time. In coding the algorithm, one must trade-off increased run-time for improved use of memory (required for large problem instances). Thus, we expect that one can implement the algorithm so that it will run in significantly shorter time for the smaller networks (e.g., with 25, 100 and 500 nodes) employed in the first set of experiments. Acknowledgments The authors are grateful to Hao Tang and Baiyu Yang for their assistance with the computational experiments. The authors would also like to thank the referees for their valuable comments. Appendix A. Determining a Bound on the Time-Dependent Quickest Flow Time, T A simple and quick technique may be required to determine an upper bound on the time-dependent quickest flow time, T , in a time-dependent network. One way to estimate this bound on T is as follows. B stat stat , T = t + αl + κlstat where t stat returns the time at which travel conditions become stationary, αlstat returns the shortest path time between the origin and destination using the arc travel times at t stat , and κlstat returns the corresponding capacity of this shortest path. Thus, we solve for the shortest time path once the travel times become stationary and ship the maximum amount on this path, departing at the minimum number of required subsequent time intervals, as made possible by the dynamic characteristics of the flow.

Appendix B. The TDEAT Algorithm A label αj is associated with each node j and corresponds with the earliest known arrival time at node j , leaving node k at earliest departure time t. At each iteration, a node i selected from the SE list (Step 1) is scanned (Step 2). That is, for every successor node j of i, a temporary label is computed through the corresponding path from k to i and arc (i, j ). If the value of the temporary label is smaller than


67

the current value of αj , αj is updated and j is placed in the SE list. Let Pj (t) be the predecessor node of node j along the path from node k that arrives at node j at time t, Dj (t) be the departure time from node Pj (t) corresponding to an arrival time t at node j along the path from node k, Uj (t) be the capacity of the minimum capacity arc on the path from node k that arrives at node j at time t. The algorithm terminates with the earliest arrival time at each node, given by αj , and the corresponding pointers (Pj (t), Dj (t)) that can be used to reconstruct these earliest arrival time paths (Step 3). The paths, Pi for i ∈ N, are provided in the form of an ordered set of arc-time pairs, each element of which is given in the form of {(k, j ), t} for arc (k, j ) and departure time from k at time t. For each node j , the quickest path is maintained for every departure time t from αj to T . This is required because it may be best to wait at node j before proceeding to the next node when computing the earliest arrival time downstream. Thus, the maximum amount of flow that can be sent on a path (i.e. κj = minimum capacity of any arc used in the path Pj is given by the capacity Uj (t) of the path) is maintained for each arrival time t ∈ [αj , T ]. Note that there may be some nodes in the network whose earliest arrival time is greater than T . These nodes will obviously not be used in any useful path, so we can set αj = T , as an upper bound for all j ∈ N. In the algorithm description that follows, the line denoted by (2) specifies the feasible departure times from a node i such that arrival at node j is no later than T and that capacity along the arc exists for the suggested departure time. While line (3) is not necessary, it can be used to reduce the number of potential departure times for consideration. This line calls on a binary variable Iij defined in line (1) in order to ensure that the correct departure times are eliminated when the arc traversal times are negative-valued. TDEAT(k, t, T , G(x)) Step 0. Initialization SE = {k}.

 t 0, t αi , t + τij (t) T } (2) (3) for all t ∈ Tij ∩ {t | t + τij (t)Iij αj } if (Pj (t + τij (t)) = ∞) then SE = SE ∪ {j }; αj = t + τij (t); t ∗ = αj + 1; Pj (αj ) = i; Dj (αj ) = t; Uj (αj ) = min(Ui (t), rij (t)); while (Pj (t ∗ ) = ∞) and (t ∗ T ) Pj (t ∗ ) = j ; Dj (t ∗ ) = t ∗ − 1; Uj (t ∗ ) = Uj (t ∗ − 1); + + t ∗; end while; end if ; end for; end for; Return to Step 1. Step 3. Reconstructing the earliest arrival time paths. for all i ∈ N κi = Ui (αi ); Pi = {}; j = i; d = αi ; while (j = k) d = Dj (d); Pi = {((Pj (d), j ), d )} ∪ Pi ; j = Pj (d); d = d ; end while; end for. PROPOSITION 4. The TDEAT algorithm terminates with the earliest arrival time paths from a given origin at a select departure time to all other nodes in N, where waiting is permitted. Proof. Upon termination, for all j , αj αi + τij (t) + W , for all i ∈ N, where t αi is the departure time from node i, W = t − αi is the waiting time at node i defining the departure time t. In other words, ∀j , αj τij (t) + t, ∀i. Suppose ∃j |αj > τij (t) + t for some i, t αi . Case 1: τij (t) 0. In this case, αi t < αj and therefore αi < T . This implies that αi has been updated and node i was placed in the SE list. Given the assumption that αj > τij (t) + t for some i, j and t αi , then node i was not scanned and must still be in the SE list. This contradicts the assumption of termination. Case 2: τij (t) < 0. In this case, (i, j ) is a backward arc. Since all flow must arrive at the sink by time T and backward arcs are not constructed out of the sink,

69


then a backward arc can only exist (i.e. have positive capacity) at times strictly before T . Given that αi t < T , we know that αi must have been updated and that node i was placed in the SE list. However, since αj has not been updated, node i must still be in the SE list and termination is again contradicted. 2 PROPOSITION 1 (Restated). The TDEAT algorithm has O(|N|2 T 2 ) worst-case computational complexity. Proof. Each node can enter the SE list at most T times. Thus, Step 2 can be repeated at most |N|T times. In each iteration of Step 2, node i is scanned by considering all successor nodes j ∈ δ + (i). At most |N| such successor nodes may be considered. If arc (i, j ) is a forward arc, then at most αj − αi time intervals will be considered. If arc (i, j ) is a backward arc, then at most T − αi time intervals will be considered. Thus, the worst-case computational complexity of the TDEAT 2 algorithm is O(|N|2 T 2 ).

Appendix C. Parameter Settings for Network used in Computational Tests The complete network was retrieved from the Imperial College Management Schools’s MP-TESTDATA web site by J. E. Beasley: ftp://ftp.zib.de/pub/Packages/ mp-testdata/mincost/netg/index.html. As indicated in the website, the network can be regenerated using the NETGEN source code and the following parameter settings. Input parameters

Cap1.net

Cap4.net

Random seed Number of nodes Source nodes Sink nodes Number of arcs Minimum arc cost Maximum arc cost Total supply Transshipment – Sources – Sinks Skeleton arcs – with max cost – capacitated Minimum arc capacity Maximum arc capacity

13502460 1000 15 15 10000 1 10000 500000 0 0 30% 80% 20000 120000

13502460 5000 40 60 30000 1 10000 600000 0 0 40% 90% 30000 150000

70


References

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20.

21. 22.

23. 24. 25. 26.

Ahuja, R. K., Magnanti, T. L. and Orlin, J. B.: Network Flows: Theory, Algorithms, and Applications, Prentice-Hall, Inc., New Jersey, 1993. Anderson, E. J. and Nash, P.: Linear Programming in Infinite-Dimensional Spaces, Wiley, New York, 1987. Anderson, E. J., Nash, P. and Philpott, A. B.: A class of continuous network flow problems, Math. Oper. Res. 7 (1982), 501–514. Anderson, E. J. and Philpott, A. B.: A continuous-time network simplex algorithm, Networks 19 (1989), 395–425. Aronson, J. E.: A survey of dynamic network flows, Ann. Oper. Res. 20 (1989), 1–66. Bellman, R.: On a routing problem, Quart. Appl. Math. 16 (1958), 87–90. Bertsimas, D. and Stock Patterson, S.: The air traffic flow management problem with enroute capacities, Oper. Res. 46 (1998), 406–422. Burkard, R., Dlaska, K. and Klinz, B.: The quickest flow problem, Meth. Models Oper. Res. 37 (1993), 31–58. Cai, X., Sha, D. and Wong, C. K.: Time-varying minimum cost flow problems, European J. Oper. Res. 131 (2001), 352–374. Chabini, L.: Discrete dynamic shortest path problems in transportation applications: Complexity and algorithms with optimal run time, Transport. Res. Record 1645 (1998), 170–175. Chalmet, L., Francis, R. and Saunders, P.: Network models for building evacuation, Management Sci. 28 (1982), 86–105. Fleischer, L. and Tardos, E.: Efficient continuous-time dynamic network flow algorithms, Oper. Res. Lett. 23 (1998), 71–80. Ford, L. and Fulkerson, D.: Flows in Networks, Princeton University Press, New Jersey, 1962. Hajek, B. and Ogier, R. G.: Optimal dynamic routing in communication networks with continuous traffic, Networks 14 (1984), 457–487. Halpern, J.: A generalized dynamic flows problem, Networks 9 (1979), 133–167. Hamacher, H. and Tufekci, S.: On the use of lexicographic min cost flows in evacuation modeling, Naval Res. Logistics 34 (1987), 487–503. Hoppe, B.: Efficient dynamic network flow algorithms, Technical Report TR95-1524, Department of Computer Science, Cornell University, Ithaca, NY, 1995. Hoppe, B. and Tardos, E.: The quickest transshipment problem, Math. Oper. Res. 25 (2000), 36–62. Jarvis, J. and Ratliff, H.: Some equivalent objectives for dynamic network flow problems, Management Sci. 28 (1982), 106–109. Klinz, B. and Woeginger, G.: Minimum cost dynamic flows: The series-parallel case, in Proceedings of the 4th Conference on Integer Programming and Combinatorial Optimization, 1995, pp. 329–343. Lindsay, K., Boyd, E. and Burlingame, R.: Traffic flow management modeling with the time assignment model, Air Traffic Contr. Quart. 1 (1993), 3. Miller-Hooks, E.: Optimal routing in time-varying, stochastic networks: Algorithms and implementation, Ph.D. Thesis, Department of Civil Engineering, The University of Texas at Austin, Austin, TX, 1997. Ogier, R. G.: Minimum-delay routing in continuous-time dynamic networks with piecewiseconstant capacities, Networks 18 (1988), 303–318. Orda, A. and Rom, R.: On continuous network flows, Oper. Res. Lett. 17 (1995), 27–36. Philpott, A. B.: Continuous-time flows in networks, Math. Oper. Res. 15 (1990), 640–661. Philpott, A. B. and Craddock, M.: An adaptive discretization algorithm for a class of continuous network programs, Networks 26 (1995), 1–11.


27.

28. 29. 30.

71

Powell, W. B., Jaillet, P. and Odoni, A.: Stochastic and dynamic networks and routing, in M. Ball, T. Magnanti, C. Monma and G. Nemhauser (eds), Handbooks in OR and MS: Network Routing, Elsevier Science, 1995. Pullan, M. C.: An algorithm for a class of continuous linear problems, SIAM J. Control Optim. 31 (1993), 1558–1577. Pullan, M. C.: A study of general dynamic network programs with arc time-delays, SIAM J. Optim. 7 (1997), 889–912. Ziliaskopoulos, A.: Optimum path algorithms on multidimensional networks: Analysis and design, implementation and computational experience, Ph.D. Thesis, Department of Civil Engineering, The University of Texas at Austin, Austin, TX, 1994.

On Solving Quickest Time Problems in Time

On Solving Quickest Time Problems in Time

Suggest Documents

Solving Continuous-Time Optimal- Control Problems ...

Time-Dependent Quickest Path Problem with ...

Time aggregation problems in Financial Time Series

Solving Time-Dependent Optimal Control Problems in Comsol ...

REACTION-DIFFUSION PROBLEMS ON TIME

Solving Impulsive Control Problems by Discrete-Time ... - sbmac

Solving Continuous-Time Optimal- Control Problems with ... - CiteSeerX

Intermediate Algebra 13: Solving Rate-Time-Distance Problems

Solving Allocation Problems of Hard Real-Time ... - Semantic Scholar

TIME ON TASK The time on task effect in reading and problem solving ...

Intelligent, Real-time Problem Solving

Quickest Real-Time Detection of a Brownian Coordinate Driftwww.researchgate.net › publication › fulltext › Quickest-

ON SOLVING FEWNOMIALS OVER INTERVALS IN FEWNOMIAL TIME

Time Value of Money Problems

Solution Of “TIME VALUE” Problems

Time-Dependent Equilibrium Problems - CiteSeerX

Time Bounds for Streaming Problems

Solution of One-Time-Step Problems in

A hierarchical time-splitting approach for solving finite-time optimal ...

A hierarchical time-splitting approach for solving finite-time optimal ...

SOLVING ELECTROMAGNETIC EIGENVALUE PROBLEMS IN ...

Logic-based Real Time Problem Solving Systems

Computational algorithm for solving fredholm time

Solving the Time-Dependent Transport Equation