An Efficient Algorithm for Finding Sets of Optimal Routes
AAn Efficient Algorithm for Finding Sets of Optimal Routes
Ido Zoref and Ariel Orda
Viterbi Faculty of Electrical Engineering , The Technion – Israel Institute of Technology
Abstract
In several important routing contexts it is required to identifya set of routes, each of which optimizes a different criterion.For instance, in the context of vehicle routing, one routewould minimize the total distance traveled, while other routeswould also consider the total travel time or the total incurredcost, or combinations thereof. In general, providing such a setof diverse routes is obtained by finding optimal routes withrespect to different sets of weights on the network edges. Thiscan be simply achieved by consecutively executing a standardshortest path algorithm. However, in the case of a largenumber of weight sets, this may require an excessively largenumber of executions of such an algorithm, thus incurring aprohibitively large running time.We indicate that, quite often, the different edge weightsreflect different combinations of some "raw" performancemetrics (e.g., delay, cost). In such cases, there is an inherentdependency among the different weights of the same edge.This may well result in some similarity among the shortestroutes, each of which being optimal with respect to a specificset of weights. In this study, we aim to exploit such similarityin order to improve the performance of the solution scheme.Specifically, we contemplate edge weights that areobtained through different linear combinations of some(“raw”) edge performance metrics. We establish and validatea novel algorithm that efficiently computes a shortestpath for each set of edge weights. We demonstrate that,under reasonable assumptions, the algorithm significantlyoutperforms the standard approach. Similarly to the standardapproach, the algorithm iteratively searches for routes, oneper set of edge weights; however, instead of executing eachiteration independently, it reduces the average running timeby skillfully sharing information among the iterations.
Routing is a core networking task, in particular in roadnetworks and computer networks [10] [22] [21] [25]. Afundamental routing problem is that of finding a routethat optimizes a single additive metric (e.g., time, cost).Essentially, its solution consists of computing a shortest pathon a weighted graph.In some routing contexts, the routing objective functioncannot be satisfactorily captured through a single additiveedge cost. For example, planing a vehicle trajectory to adesired destination often requires a fast enough route (interms of driving time) as well as a route that incurs sufficientlylow fuel cost. Similarly, communication network routingproblems often consider both throughput and delay objectives.The problem of routing with multiple objectives is awell-known challenge. Usually, different routes optimizedifferent objective functions, hence finding a single route thatsimultaneously (i.e., independently) minimizes more thana single objective function (e.g. both travel time and cost)is usually impossible. We proceed to discuss the differentalternatives for handling the multi-objective routing problemand present our selected approach.A common approach for dealing with multi-objectiverouting problems is to search for a single path that optimizesone selected objective, subject to the condition that the otherobjectives do not exceed given threshold values. This is anNP-hard problem, known as the Resource Constrained Short-est Path (CSP) problem [19]. In the literature, approximatealgorithms and heuristic approaches have been proposed todeal with the CSP problem.Approximation algorithms for the CSP problem are usuallybased on scaling and rounding of the input data. Warbur-ton [28] was the first to develop a fully polynomial timeapproximation algorithm for the CSP problem on acyclicnetworks. In [26], Hassin later improved upon this to derive1 a r X i v : . [ c s . N I] A ug wo fully polynomial time approximation schemes (FPTAS)that are applicable for general networks. Other relatedapproximation schemes providing certain improvementsto Hassin’s algorithm can be found in [5]. In particular, asignificant improvement of Hassin’s result was achieved byLorenz and Raz [16], who established a strongly polynomialtime approximation scheme that is also applicable to generalnetworks. In [2], the authors considered the problem offinding a path whose delay is at most (1 + ε ) times thespecified delay bound and whose cost is not greater than thatof the minimum cost path of the CSP problem.As for heuristic approaches for the CSP problem, severalproposed algorithms are based on solutions to the integerrelaxation or the dual of the integer relaxation of the CSPproblem [13]. Juttner et al. [3] introduced the LARACalgorithm, which solves the Lagrangian relaxation of the CSPproblem. An applicable heuristic variation of the LARACalgorithm is LARAC-BIN [32]. It employs binary searchtechnique to skillfully find a path p where the deviation of p ’s cost from the optimal path cost is smaller then the tuningparameter τ .An alternative approach for dealing with multi-objectiverouting is to provide a (“suitable”) set of routes . This can beobtained by finding several optimal routes with respect todifferent sets of edge weights. For instance, in the context ofvehicle routing, one route may minimize the total distancetraveled, while other routes would also consider the totaltravel time or the total incurred cost, or combinations thereof.Such an approach is often used in recommendation sys-tems, such as autonomous navigation systems [15], [30]. Inthese systems, it is difficult to match the personal preferencesof individual users by providing only a single route. Thesepreferences may be based, for example, on better localknowledge, a bias for or against a certain route objective, orother factors. One can deal with this issue by presenting theuser with a number of alternative routes with the hope thatone of them would be satisfactory.A possible method for identifying such a ("suitable") set ofroutes is to search for several routes that optimize differentlinear combinations of some "raw" objectives [11], e.g., dis-tance traveled, incurred cost, etc. Such a linear combinationallows to translate several objectives into a single weight foreach edge, which in turn implies an “optimal” (i.e., minimumweight) route from a source to target node. Therefore, byconsidering several linear combinations, finding the setof optimal routes (each defined with respect to one linearcombination) can be simply achieved by consecutivelyexecuting a standard shortest path algorithm. However, inthe case of a large number of linear combinations, this mayrequire an excessively large number of executions of such an algorithm, thus incurring a prohibitively large running time.Accordingly, in this study we seek to efficiently find aset of routes, each of which minimizes a different linearcombination of the objectives. Funke and Storandt [9] suggestsuch a solution. Specifically, they show that contractionhierarchies – a very powerful speed-up technique originallydeveloped for the standard shortest path problem [12], canbe constructed efficiently for the case of several linearcombinations of the edge "raw" objectives. However, thismethod requires some pre-processing efforts. Pre-processingcan be applied to speed up graph-based search algorithmsin car navigation systems or web-based route planners. Still,in some routing contexts it may not be possible to performpre-processing since the network may dynamically changeover short periods of time.A possible alternative solution for the considered problemcan be obtained by finding a set of Pareto optimal routes. Recall that, in our problem, each required route minimizes adifferent linear combination of the "raw" objectives. It is easyto verify that each such route is actually a
Pareto-Optimal route. Hence, by finding the set of Pareto optimal routes weobtain a solution for the problem. We shall present severalalgorithms for finding the set of Pareto optimal routes.Standard solutions for finding the set of Pareto optimalroutes are inspired by the Dijkstra algorithm (which is thestandard approach for finding a shortest route in the basicsingle-objective case). The most common approaches are theMulticriteria Label-Setting (MLS) algorithm [18] [14] andthe Multi-Label-Correcting (MLC) algorithm [6] [7]. TheMLS algorithm keeps, for each node, a set of non-dominatedpaths. The priority queue maintains paths instead of vertices,typically ordered lexicographically. At each iteration, itextracts the minimum path, say L , which is a path ending atsome node, say u ∈ V . Then, MLS scans the outgoing edgesfrom u , say a = ( u , v ) . It does so by evaluating whether thenew path, L new = L (cid:107) a , is non-dominated by the queue’spaths, and in that case it inserts the new path, L new , to thequeue. The MLC algorithm is quite similar, except that itsorts the priority queue in a more intuitive manner, thusresulting in better performance in term of running time.Both MLS and MLC are considered to be fast enough aslong as the set of Pareto paths is relatively small [33] [20].Unfortunately, Pareto sets may consist of a prohibitivelylarge (non-polynomial) number of paths, even for therestricted case of two objectives [18]. A possible approach for To define Pareto optimality, consider two W –dimensional objective vec-tors x = ( x ,..., x W ) and y = ( y ,..., y W ) . If x i ≤ y i for each j ∈ { ,.., W } and x i < y i for some j ∈ { ,.., W } , then x dominates y . Given a finite set X of W -dimensional vectors, we say that x ∈ X is Pareto–optimal in X if there isno y ∈ X that dominates x . ε -optimalsolutions, which provide a polynomial number of Paretopaths [23]. Such an approximated solution can be computedefficiently through a fully polynomial approximation scheme(FPAS) [17] [27] [31]. However, as explained above, we seekto find a sub-set of Pareto routes where each route minimizesa different linear combination of the "raw" objectives. Hence,obtaining a sub-optimal Pareto set may not provide a validsolution. In other words, it is not guaranteed that the set ofrequired routes is included in an approximated Pareto set.Accordingly, in this study we establish and validate the Iterative Dijkstra with Adapted Queue (IDAQ) algorithm.IDAQ provides an optimal solution for the problem withoutimposing any pre-processing computations. We show that, un-der reasonable assumptions, IDAQ significantly outperformsthe standard approach of consecutively executing a standardshortest path algorithm. Similarly to the standard approach,IDAQ iteratively searches for routes; however, instead ofexecuting each iteration independently, it shares informationamong the iterations. Unlike the standard approach, thisallows IDAQ avoid scanning any optimal path (with respectto some linear combination) more than once, thus providingimproved performance in terms of running time.The rest of the paper is organized as follows. In Section 2,we formulate the problem. Next, in Section 3, we present andanalyze a standard approach algorithm. Our approach, namelythe IDAQ algorithm, along with a theoretical analysis, are pre-sented in Sections 4 and 5, respectively. Section 6 presentsa simulation study, which demonstrates that the IDAQ algo-rithm considerably improves performance (in terms of run-ning time) in comparison to the standard approach. This isdemonstrated on both randomly generated settings as well ason settings that correspond to real-life data. Finally, conclud-ing remarks are presented in Section 7.
In this section, we formulate the
Multi-Objective WeightedShortest Path problem (MOWSP) , discussed in this article.To that end, we shall use the following definitions.
Definition 1 (edge) . Consider a set of nodes V . An edge isdefined as an ordered pair of nodes in V .As mentioned, we aim to solve a problem of findingseveral optimal routes with respect to different sets of edgesweights. More specifically, each set of edges weights isproduced through a (different) linear combination of the"raw" objectives. Formally, MOG (definition 2) is definedas a graph with several objective values attached to eachedge; and a coe f f icient vector (definition 3) specifies theconsidered linear combinations of the objectives (where each coefficient represents the relative importance of eachobjective).
Definition 2 (MOG) . A Multi-Objective Graph,
MOG ( V , E ) ,is a set of connected nodes V = { v , ..., v n } and a set of di-rected edges E = { e , ..., e m } so that associated with eachedge e ∈ E are W different non-negative additive values, eachrepresenting some objective. We shall denote the i th objectiveof an edge e ∈ E (where i ≤ W ) by w e [ i ] . Definition 3 (coefficient vector) . A coe f f icient vector λ ∈ R W is a vector of W positive numbers. We denote the i thelement of λ (where i ≤ W ) by λ [ i ] . Definition 4 ( Path s ) . Consider a
MOG ( V , E ) (definition 2)and a “start node” s ∈ V . Path s is the set of paths from s toany node v ∈ V . In other words, each element of Path s is anordered list of nodes that starts with s and each subsequentnode is connected to the previous one by an edge e ∈ E Definition 5 ( Path s , v ) . Consider an
MOG ( V , E ) (definition2), a start node s ∈ V and some node v ∈ V . Path s , v is the setof paths from s to v . In other words, each element p ∈ Path s , v is the prefix of Path s having v as the last node. Definition 6 (edge cost) . Consider a coefficient vector λ (def-inition 3). The cost of an edge e ∈ E with respect to λ isdefined as follows: Cost ( e , λ ) = W ∑ j = λ [ j ] · w e [ j ] (1) Definition 7 (path cost) . Consider a coefficient vector λ (def-inition 3), a start node s ∈ V and a path p ∈ Path s . The cost of p with respect to λ is defined as follows: Cost ( p , λ ) = ∑ e ∈ p Cost ( e , λ ) = ∑ e ∈ p W ∑ j = λ [ j ] · w e [ j ] (2) Definition 8. [Optimal
Path s , v with respect to λ ] Consider an MOG ( V , E ) , a start node s ∈ V , a node v ∈ V and a coefficientvector λ . p opt ∈ Path s , v is optimal with respect to λ if, foreach p ∈ Path s , v , the following holds: Cost ( p opt , λ ) ≤ Cost ( p , λ ) (3)We are ready to state the MOWSP problem: MOWSP Problem (Multi-Objective Weighted Shortest Pathproblem) . Consider an
MOG G ( V , E ) , a start node s ∈ V anda set of coefficient vectors Λ , where: Λ = { λ i ∈ R w | i ∈ , .., K } (4)For each coefficient vector λ i ∈ Λ , find set of paths P i = { p v , p v , ..., p v n } where each path p v i ∈ Path s , v i is optimal with respect to λ i . Notice that under the
Path s , Path s , v definitions, we also consider pathsthat contain loops. Standard Algorithm: Dijkstra Iterations
In this section, we present a standard-approach algorithm forsolving the MOWSP problem, which is based on multipleexecutions of the Dijkstra algorithm (hencefort, the StandardAlgorithm ). The rest of this section is structured as follows: inSection 3.1, we describe the Standard Algorithm; in Section3.2, we prove its correctness; finally, in Section 3.3, weanalyze its time complexity.
The algorithm iterates through each λ i ∈ Λ (defined by equa-tion 4). In each iteration, the algorithm constructs a new graph G temp ( V , E ) , which is identical to G ( V , E ) except for the fol-lowing: we reduce the cost of each edge e ∈ E to a singledimension using the Cost(e, λ i ) function (defined by equation1). The algorithm calculates and returns the shortest path foreach node in G temp ( V , E ) from the start node s using the Di-jkstra shortest-path algorithm.The pseudo-code of the Standard Algorithm is presentedherein. Algorithm 1
Standard Algorithm procedure S TANDARD A LGORITHM (G,s, λ ) optimal _ paths ← null for i=1 to K do E temp ← G . E for each e ∈ E temp do e . Cost ← Cost ( e , λ i ) G temp ← ( G . V , E temp ) P i ← Dijkstra(G temp , s) optimal _ paths _ set ← optimal _ paths _ set ∪ { P i } Return optimal _ paths _ set Lemma 1.
The Standard Algorithm solves the MOWSP prob-lem.
Proof.
As explained in Section 3, The Standard Algo-rithm is based on K executions of the Dijkstra algorithm.Consider one of these executions (lines 4-9 of some iteration).In lines 4-6, the graph G temp is generated, and on thisgraph, we execute the Dijkstra algorithm. The nodes of G temp are precisely those of G , namely V . The edges of G temp , namely E temp , are equal to E with the followingaddition: each edge e ∈ E temp cost value, denoted by e . Cost ,is determined by the
Cost function (line 6). The Dijkstra algorithm (executed in line 8) returns for eachnode v ∈ V a path, namely p v ∈ Path s , v . p v is the shortest pathending at v , with respect to the cost values e . Cost for eachedge e ∈ E temp .Let us denote the output of the Dijkstra algorithm as P i where: P i = { p v , p v , ..., p v n } Recall that G temp has the same nodes and edges as G hence,for any node v , each path p ∈ Path s , v is necessarily a path onboth G temp and G .From the correctness of the Dijkstra algorithm we can con-clude that the path p v is such that: p v = arg min p ∈ Path s , v f ( p ) where: f ( p ) = ∑ e ∈ p e . Cost = ∑ e ∈ p Cost ( e , λ t ) = Cost ( p , λ t ) In other words, for each p ∈ Path s , v the following equationholds: Cost ( p v , λ t ) ≤ Cost ( p , λ t ) Notice that, by definition, p v is optimal with respect to λ i , i.e, P i is the set of optimal Path s , v for each v ∈ V with respect to λ i .The optimal _ paths _ set which is return at the end of the algo-rithm is precisely: optimal _ paths _ set = { P , P , ..., P K } hence, it is by definition the solution for the MOWSP asrequired. Lemma 2.
The complexity of the Standard Algorithm isgiven by: O ( K · W · | E | + K · | V | · log | V | ) Proof.
Recall that K is the number of input coefficientvectors (see MOWSP definition), and W is defined as thenumber of objective values in each edge (see definition 2).As described in Section 3, The Standard Algorithm in-cludes K iterations, in each of which the following operationsare performed:1. Constructing a search graph G temp by calculating foreach edge e ∈ E its cost value using the Cost function(equation 2). This is done in O ( | E | · W ) .2. Calculating the shortest path for each node in G temp using the Dijkstra algorithm. This can be done in O ( | E | + | V | · log | V | ) using a Fibonacci heap for the pri-ority queue implementation [8].4ence, the complexity of the Standard Algorithm is given by: O ( K · W · | E | + K · | V | · log | V | ) We turn to present IDAQ, an efficient algorithm that solvesthe MOWSP problem. We shall prove that, under reasonableassumptions, IDAQ has lower time complexity than the Stan-dard Algorithm described in Section 3.The rest of this section is organized as follows. We begin witha general description of the IDAQ algorithm (Subsection 4.1).Then, in Subsections 4.2 and 4.3, we introduce proceduresthat serve as building blocks by the IDAQ algorithm. Finally,in Subsection 4.5 we present the IDAQ algorithm.
Similarly to the Standard Algorithm, IDAQ is an iterativealgorithm: at the end of each iteration, say i ∈ { , .., K } ,IDAQ finds the the set of optimal Path s , v for each v ∈ V withrespect to λ i .However, unlike the Standard Algorithm, IDAQ sharesknowledge among its iterations. The basic idea is thefollowing: consider some node v ∈ V . While evaluat-ing a path p ∈ Path s , v , IDAQ checks whether p mightbe optimal with respect to λ I where I ∈ { i + , .., K } is some future iteration. In that case, IDAQ remembers p , and this allows IDAQ to execute iteration I more efficiently. In this subsection we present IDAQ Relevance Check, a pro-cedure used by IDAQ to determine whether an evaluated pathis potentially optimal with respect to any coefficient vector λ ∈ Λ . Specifically, in Subsection 4.2.1 we present the defini-tion of a relevant path and in Subsection 4.2.2 we present theprocedure’s pseudo-code. In this subsection we establish the relevance definition (defi-nition 12). Intuitively, a relevant path is a potential optimalpath with respect to any coefficient vector λ ∈ Λ and there-fore should not be ignored. We begin by introducing someauxiliary definitions. Definition 9 ( Q v ) . Consider some node, say v ∈ V , and a listof paths Q ⊆ Path s . Q v is defined as the sub-group of pathsin Q containing each paths b ∈ Q where b ∈ Path s , v . Definition 10 (relevant due to optimality with respect to Q v ) . Consider some node v ∈ V , a list of paths Q v ⊆ Path s , v andsome path p ∈ Path s , v where p / ∈ Q v . p is relevant due tooptimality with respect to Q v , if there exists a coefficientvector λ i ∈ Λ where for each path b ∈ Q v : Cost ( p , λ i ) ≤ Cost ( b , λ i ) Definition 11 (relevant due to dominance with respect to Q v ) . Consider some node v ∈ V , a list of paths Q v ⊆ Path s , v and some path p ∈ Path s , v . p is relevant due to dominance with respect to Q , if p is Pareto non-dominated by each path b ∈ Q v .We are ready to establish the definition of “relevance”. Definition 12 (relevant with respect to Q) . p is relevant withrespect to Q if it is either relevant due to optimality withrespect to Q v or relevant due to dominance with respect to Q . In this subsection, we present the Is-Relevant procedure usedby the IDAQ algorithm to determine whether a path p ∈ Path s , v is relevant with respect to a list of paths, Q ⊆ Path s .According to definition 12, p is relevant with respect to Q ifit meets either of the following conditions:1. p is relevant due to optimality with respect to Q v .2. p is relevant due to dominance with respect to Q v The following Is-Relevant procedure identifies which ofthe conditions (1 or 2) can be verified more efficiently.Eventually, this shall allow us to prove that, under reasonableassumptions, the IDAQ algorithm has lower time complexitythan the Standard Algorithm.We begin by introducing an auxiliary definition followedby the Is-Relevant procedure pseudo-code.
Definition 13 ( best v ) . Consider some node, say v ∈ V , anda list of paths Q ⊆ Path s . best v is define as an auxiliary listused by the Is-Relevant procedure, such that: best v = { best v [ ] , best v [ ] , ... best v [ K ] } where for each i = { , ..., K } and for any path p ∈ Q v , thefollowing holds: best v [ i ] ∈ Q v ∩ Cost ( best v [ i ] , λ i ) ≤ Cost ( p , λ i ) Assuming the minimal cost for each λ i ∈ Λ was calculated beforehand,it is easy to see that this can be verified in O ( K · W ) . Assuming the number of Pareto paths is given by O ( L ) , a non-dominancecheck can be verified in O ( L · W ) . Note that the number of Pareto paths L can be non-polynomial, however, in many practical applications L could berelatively small [20]. : procedure I S -R ELEVANT ( p , Q, Λ ) K ← length of Λ v ← p.Node if | Q v | < KW then //Check for condition 2 if p is Pareto Non-Dominated by Q v then P ← All paths that are dominated by p in Q Remove P from Q Return True else
Return False else //Check for condition 1 p .Costs ← p’s Costs For Each λ best v .Costs ← best v Costs For Each λ for i=1 to K do if p . Costs [ i ] ≥ best v [ i ] . Costs [ i ] then p . Costs [ i ] = null else best v [ i ] = p if All p . Costs are null then
Return False else P ← All path in Q v and not in best v Remove P from Q Return True
We turn to present the Adaptive Queue - a priority queuefor determining the next path to be developed by the IDAQalgorithm. The Adaptive Queue, being a priority queue, isdefined by the following operations:
Push, Pop, Is-Empty .Besides, the Adaptive Queue consists of one more operation,namely the
Adapt operation, used to sort the queue’s pathsaccording to a new coefficient vector. We begin with someauxiliary definitions.
Definition 14 ( Λ _ index ) . Index of coefficient vector in Λ initialized with 1. Definition 15 (Path Priority) . Consider some node v ∈ V ,path p ∈ Path s , v and Λ _ index . The Priority of p , denotedby p . Priority , is equal to either null or
Cost ( p , λ Λ _ index ) , asfollows:1. null - If there exists another path b ∈ Path s , v so that atleast one of the following conditions holds:(a) b is either in the Adaptive Queue or was popped from the Adaptive Queue, and: Cost ( b , λ Λ _ index ) < Cost ( p , λ Λ _ index ) (b) b is in the Adaptive Queue, was pushed to theAdaptive Queue before p and: Cost ( b , λ Λ _ index ) = Cost ( p , λ Λ _ index ) (c) b was popped from the Adaptive Queue and: Cost ( b , λ Λ _ index ) = Cost ( p , λ Λ _ index ) Cost( p , λ Λ _ index ) - otherwise. Definition 16 (Priority Heap) . A Fibonacci heap thatcontains each path in the Adaptive Queue with non-nullPriority. The
Priority Heap is managed by the AdaptiveQueue operations (to be defined later in this section).We are ready to define the Adaptive Queue operations:
Push( p ) - Insert a Relevant (see definition 12) path, say p ∈ Path s , v to the Adaptive Queue and perform the followingactions:1. Set p . Priority according to definition 15.2. In case p . Priority is not null:(a) Set each path in Q v Priority to null and removeit, if necessary, from the Priority Heap(b) Inset p into the Priority Heap. Is Empty() -
Check whether exists a path in the queue withnot null Priority value. In other words, check if the PrioryHeap is empty.
Pop() -
Using the Priority Heap (see definition 16), remove(and return) out of the Adaptive Queue a path with mini-mal not null Priority.
Adapt(i) -
Perform the following actions:1. Initialize the Priority Heap to a new empty heap.2. Sets Λ _ index = i .3. Calculate the Priority of each of the AdaptiveQueue paths according to definition 15.4. Insert into the Priority each path with not null pri-ority. The IDAQ algorithm manages a list of optimal paths with re-spect to any coefficient vector in Λ . To solve MOW SP , IDAQhas to convert such list to a set of path for each coefficientvector as required by the
MOW SP definition (2).Formally, the
Build − Sets procedure gets a list of paths, say PL , and returns for each coefficient vector λ i ∈ Λ , a set ofpaths: P i = { p v , p v , ..., p v n } where for each node v i ∈ V : p v i ∈ Path s , v i has minimum Cost ( p , λ i ) among all paths p ∈ PL ∩ Path s , vi .6 : procedure B UILD -S ETS ( PL , Λ , G ) for i=1 to K do P i ← null for each v ∈ G . V do paths ← All paths in PL ending in node v min ← ∞ optimal _ path ← null for each p ∈ paths do if Cost ( p , λ i ) < min then optimal _ path ← p min ← Cost ( p , λ i ) P i ← P i ∪ optimal _ path optimal _ sets ← optimal _ sets ∪ { P i } Return optimal _ paths _ set We present the IDAQ algorithm, an efficient algorithm thatsolves MOWSP. We begin by introducing some auxiliarydefinitions followed by IDAQ’s pseudo-code (Algorithm 2).IDAQ uses an Adaptive Queue instance in order tomanage a list of developed paths that is returned when thealgorithm terminates (per the following definitions 17 and 18).
Definition 17 ( queue ) . An Adaptive Queue used by the IDAQalgorithm.
Definition 18 ( optimal _ paths ) . A list of paths that werepopped from the queue as paths with minimal non-null prior-ity.Occasionally, we shall address the set of paths Q definedas follows. Definition 19 (Discovered Paths) . The set of paths that arein the queue or the optimal _ paths list. We denote the Discov-ered Paths by Q .IDAQ uses an auxiliary list of paths in order to make surethat unnecessary paths will not be pushed to the queue . Sucha list is defined as follows: Definition 20 ( pareto _ sample ) . A list of paths that is cal-culated in line 6 of IDAQ (Algorithm 2). Whenever the pareto _ sample list contains exactly one path ending at somenode v ∈ V , we denote it by pareto _ sample [ v ] .Indeed, we shall prove (Lemma 4) that the pareto _ sample list contains precisely a single Pareto non-dominated pathending at each node. Definition 21 (iteration) . A variable used by IDAQ. Thevalue of the iteration variable is initialized to 1 (line 8 of Algo-rithm 2) and increased by 1 each time the queue ’s Is − Empty operation returns true (line 14 of Algorithm 2). we shalldenote the period where iteration = i as "the i th iteration" or"iteration i ".The IDAQ algorithm is specified as follows. Algorithm 2
IDAQ procedure IDAQ(G,s, Λ ) E temp ← G . E for each e ∈ E temp do e . Cost ← Cost ( e , λ ) G temp ← ( G . V , E temp ) pareto_sample ← Di jkstra ( G temp , s ) optimal_paths ← empty list iteration ← queue ← Adaptive Queue (s, Λ , iteration) while True do while queue is not empty do if iteration > length of λ then Return BuildSets ( optimal_paths , Λ , G ) iteration ← iteration+1 queue.Adapt( iteration ) p ← queue.Pop() Insert p to optimal_paths for
Each neighbor of p.Node do next _ p ← Path(p , neighbor) pareto _ p ← pareto_sample[p.Node] if pareto _ p Pareto Dominates next _ p then Continue Q ← queue ∪ optimal _ paths if Is − Relevant ( next _ p , Q , Λ ) then Push next_p to queue The queue operations are defined in Section 4.3 IDAQ Analysis
In this section we prove the correctness of the IDAQ algorithmand analyze its time complexity.
Definition 22 (D) . Average node degree: D = | E || V | Definition 23 (MaxDeg + ) . Maximum in-degree of a node:
MaxDeg + = max { deg + ( v ) | v ∈ V } Definition 24 (developed path) . For the IDAQ algorithm,a developed path is a path that is popped from the queue (Algorithm 2 line 12-13), while for the Standard Algorithm,it is a path that is popped from the priority queue during aDijkstra iteration.
Definition 25 (scanned path) . Consider a path p ∈ Path s , v n where the list of nodes representing p is given by: { s , v , v , ..., v n − , v n } . p is defined as a scanned path if p (cid:48) is a developed path where: p (cid:48) = { s , v , v , ..., v n − } Definition 26 (developed node) . A node that is at the end ofa developed path.
Definition 27 (ancestor) . Consider a path p ∈ Path s , v n where the list of nodes representing p is given by: { s , v , v , ..., v n } . p ’s ancestors are defined to be paths of theform: { s , v , v , ... v m } where m < n . Definition 28 (first optimal path) . Consider some coefficientvector, say λ ∈ Λ , and an optimal path with respect to λ , say p ∈ Path s , v . p is defined as a first optimal path if at the time p was scanned, neither the queue nor the optimal _ paths listcontains another optimal Path s , v with respect to λ . Definition 29 (first developed optimal path) . Consider somecoefficient vector, say λ ∈ Λ , and an optimal path with respectto λ , say p ∈ Path s , v . p is defined as a first developed optimalpath if at the time p was developed, the optimal _ paths listdose not contain another optimal Path s , v with respect to λ . l We proceed with some auxiliary definitions. Each of the fol-lowing definitions depends on an input numerical integervalue, namely l . The precise definition of l shall be providedlater; intuitively, l corresponds to the maximal number ofPareto paths for most nodes, which can be expected to berelatively small in practice [20]. Definition 30 ( l -node) . A node that is at the end of at most l different Pareto paths. V L ( l ) - Set of all l -Nodes in G : V L ( l ) = { v ∈ V | v is an l -Node } α ( l ) - l -Nodes ratio. α ( l ) = | V L ( l ) || V | E L ( l ) - Set of all outgoing edges from l -Nodes: E L ( l ) = { e ∈ E | e . Start ∈ V L ( l ) } γ ( l ) - l -Node’s outgoing edges ratio: γ ( l ) = | E L ( l ) || E | D L ( l ) - Average l -Node’s degree: D L ( l ) = | E L ( l ) || V L ( l ) | N L ( l ) - The maximum number of paths non-dominated by asingle Pareto path to any l -Node. I ( l ) - Difference between K and l : I ( l ) = K − l Next, we determine a specific value of l , namely L . Intu-itively, L is a small-enough number so that most of G nodesare L -nodes. Definition 31 (L) . L is defined as the solution of the followingoptimization problem: L = arg min l l Subject to: α ( l ) ≥ − log ( | V | ) | V | In the following, whenever we do not state otherwise, L isthe default value of l for each of the above defined definitions,e.g: α = α ( L ) , V L = V L ( L ) , etc.8 .3 Assumptions We present several assumptions under which we can provethat IDAQ’s time complexity is lower than that of theStandard Algorithm. Before stating each assumption, weprovide some intuition that justifies it.In many classes of multi-objective optimization problemsthe number of objectives is relatively small, e.g. communi-cation network routing problems often deal with just twoobjectives, e.g., throughput and delay.
Assumption 1.
The number of objectives in a MOG is O ( ) ,i.e., W = O ( ) Moreover, many classes of networks are represented bysparse graphs, e.g. in road networks each intersection typicallyconsists of the crossing of at most 4 roads. Thus:
Assumption 2.
The maximum number of incoming/outgoingedges from a single node is upper bounded by O ( log ( | V | ) . Inother words, G is a sparse graph: MaxDeg − = MaxDeg + = O ( log ( | V | ) According to [20], in many practical applications, the num-ber of different Pareto paths is often relatively small. Hence,a small number of input coefficient vectors (which is equalto the number of returned paths ending at each node), shouldproduce paths with sufficient variety, i.e.:
Assumption 3.
The number of input coefficient vectors in Λ ,namely K (equation 4) is upper-bounded by O ( (cid:112) | V | ) . K = O ( (cid:112) | V | ) According to [20], in many practical applications, the vari-ous objectives are correlated. For example, in road networks,the shortest-distance route is among the fastest routes (albeitnot necessarily the fastest). Accordingly, we assume that thenumber of paths that are non-dominated by a Pareto path isrelatively small, i.e.:
Assumption 4.
The maximum number of paths non-dominated by a single Pareto-non-dominated path to an L -Node (denoted by N L ), is upper-bounded by O ( L ) N L = O ( L ) Consider some L -Node v ∈ V L . We assume that N L issmaller than KW . Thus, IDAQ checks whether a p ∈ Path s , v Is-Relevant in an efficient matter by checking if p is relevantby optimality (Definition 10).Note that KW = O ( (cid:112) | V | ) , while N L = O ( L ) = O ( log ( | V | )) ,thus implying that the following assumption is acceptable: Assumption 5.
The maximum number of paths non-dominated by a single Pareto-non-dominated path to L -Node, N L , is smaller or equal to KW N L ≤ KW According to [20], the number of Pareto paths for mostnodes is relatively small in practice. Intuitively, such a numbershould not be dramatically affected by the graph size; forexample, in transportation networks, an "optimal road" fromBoston to New-York would not pass through San Francisco.Hence:
Assumption 6. L = O ( F ( | V | )) where F is a sub-logarithmic function, e.g., F ( | V | ) = (cid:112) log | V | , F ( | V | ) = log log | V | . In this section, we prove that the IDAQ algorithm solves theMOWSP problem. In Theorem 1 we establish that, for anycoefficient vector in Λ and for each node v ∈ V , an optimal Path s , v is developed by the IDAQ algorithm. Next, based onTheorem 1, in Theorem 2 we shall prove that IDAQ solvesthe MOWSP problem. We begin by introducing and provingseveral auxiliary lemmas. Lemma 3.
An optimal
Path s , v with respect to any coefficientvector in Λ is Pareto non-dominated by any other Path s , v . Proof.
Consider an optimal
Path s , v with respect to λ ∈ Λ ,namely p v . We assume, by way of contradiction, that p v isnot Pareto-non-dominated, i.e., there exists some path p opv ∈ Path s , v that dominates p v . In other words, for each objective,say i : ∑ e ∈ p v w e [ i ] ≥ ∑ e ∈ p opv w e [ i ] and for at least one objective, say k : ∑ e ∈ p v w e [ k ] > ∑ e ∈ p opv w e [ k ] Note that any coefficient vector in Λ is composed by positiveweights. Hence: Cost ( p v , λ ) = ∑ e ∈ p v W ∑ j = λ [ j ] · w e [ j ] > ∑ e ∈ p opv W ∑ j = λ [ j ] · w e [ j ] = Cost ( P opv , λ ) in contradiction to the optimality of p v with respect to λ .Hence, p v is Pareto non-dominated.9 emma 4. The pareto _ sample list contains exactly onePareto non-dominated path ending at each node. Proof.
Recall that, in order to construct the pareto _ sample paths list, an auxiliary graph, namely G temp is generated andon that graph we execute the Dijkstra algorithm.In lines 2-5 of IDAQ (Algorithm 2), the graph G temp isgenerated. Similarly to the first iteration of the Standard Al-gorithm, the nodes of G temp are precisely those of G , namely V . The edges of G temp , namely E temp , are equal to E with thefollowing addition: the cost value of each edge e ∈ E temp ,denoted by e . Cost , is determined by the
Cost function (line 4).The Dijkstra algorithm (executed in line 6) returns for eachnode v ∈ V a path, namely p v ∈ Path s , v , which is the shortestpath ending at v , with respect to the cost values e . Cost foreach edge e ∈ E temp .The output of the Dijkstra algorithm is denoted as pareto _ sample where: pareto _ sample = { p v , p v , ..., p v n } Recall that G temp has the same nodes and edges as G hence,for any node v , each path p ∈ Path s , v is necessarily a path onboth G temp and G .From the correctness of the Dijkstra algorithm we concludethat the path p v is such that: p v = arg min p ∈ Path s , v f ( p ) where: f ( p ) = ∑ e ∈ p e . Cost = ∑ e ∈ p Cost ( e , λ ) = Cost ( p , λ ) In other words, for each p ∈ Path s , v the following equationholds: Cost ( p v , λ ) ≤ Cost ( p , λ t ) Hence, p v is by definition an optimal Path s , v with respect to λ and in view of Lemma 3 we conclude that p v is indeed aPareto non-dominated path. Lemma 5.
Consider an optimal path with respect to λ i ∈ Λ ,namely p ∈ Path s , v . p ’s ancestors are also optimal paths withrespect to λ i . Proof.
Assume by way of contradiction that there exists anancestor path of p , say b ∈ Path s , v , which is not optimal withrespect to λ i ; in other words, there exists another path, namely c ∈ Path s , v , which is optimal with respect to λ i , i.e.: Cost ( c , λ i ) < Cost ( b , λ i ) Let us construct a new path to v , say d ∈ Path s , v , where: d is the path c followed by the path between b and p . From theadditivity of the cost function we conclude that: Cost ( d , λ i ) < Cost ( a , λ i ) in contradiction to the optimality of p with respect to λ i .In the following lemmas (6,7) we establish some propertiesthat hold in case a first optimal path is scanned. Based onthese, we will then show (Theorem 1) that any first optimalpath is scanned by the time that IDAQ terminates. Lemma 6.
In case a first optimal path is scanned, it is pushedto the queue . Proof.
Consider the scan of a first optimal path, with respectto some coefficient vector λ i ∈ Λ ,say p ∈ Path s , v .Recall that, by definition, at the time that a first optimal pathis scanned, it is neither in the queue nor in the optima _ paths list.According to Lemma 3, p is non-dominated by another Path s , v , in particular, pareto _ sample [ v ] . Therefore, the Is-relevant procedure is executed in order to determine whether p is inserted to the queue .From the definition of a first optimal path we can concludethat, for each path b ∈ Q v : Cost ( p , λ i ) < Cost ( b , λ i ) Therefore, according to definition 10, p is relevant due tooptimality with respect to Q v .From Lemma 3 we conclude that p is Pareto non-dominatedby any other Path s , v , in particular Q v . Hence, according toDefinition 11, p is relevant by dominance with respect to Q v .Since p is relevant by dominance with respect to Q v andit is relevant by optimality with respect to Q v , it is identifiedas relevant with respect to Q by the Is-Relevant procedure(4.2.2) and pushed to the queue (lines 24-25 of Algorithm 2),as required.In the following Lemma 7, we shall prove that not onlya scanned first optimal path is pushed to the queue (as es-tablished by Lemma 6), but also it is not removed fromthe queue unless the first developed optimal path is in the optimal _ paths list. Lemma 7.
From the point in the execution of the algorithmthat the first optimal path is scanned, either the first optimalpath is in the queue or the first developed optimal path is inthe optimal _ paths list. Proof.
Consider a first optimal path p ∈ Path s , v with respectto some coefficient vector λ i ∈ Λ .According to Lemma 6, in case p is scanned, it is pushed tothe queue . Note that p can only be removed from the queue either by the queue . pop operation or during the scan of someother path.In case the first developed optimal path is popped from the queue , it is inserted to the optimal _ paths list (lines 16-17 ofAlgorithm 2), as required.10therwise, assume by way of contradiction that p was re-moved from the queue during the scan of some other path,say b ∈ Path s , v . One out of the following two cases must hold:1. b dominates p .2. All p . Costs are null.Consider case 1. From Lemma 3 we conclude that p is Paretonon-dominated by any other Path s , v , in particular b , hencethis scenario is not possible.Consider case 2. Since p is optimal with respect to λ , thefollowing holds: Cost ( p , λ i ) ≤ Cost ( b , λ i ) Since p has been inserted to the queue before b , p . Cost [ i ] isnot null, this scenario is not possible.To conclude, we have established that none of the two scenar-ios is possible, in contradiction to our assumption, thus thelemma follows. Theorem 1.
Consider any coefficient vector λ i ∈ Λ and anynode v ∈ V . An optimal Path s , v with respect to λ i has beendeveloped by the time that the IDAQ algorithm returns. Proof.
Assume by way of contradiction that there exists somenode, say v ∈ V , and some coefficient vector λ i ∈ Λ , so thatno optimal Path s , v with respect to λ i has been developed bythe end of the i th iteration (see Definition 21).Consider the first optimal path with respect to λ i , namely b ∈ Path s , v . From Lemma 7 we can conclude that, in case that b is scanned, it must be in the queue . Hence, by the time thatthe i th iteration ends, one of the following two cases musthold:1. b is in the queue .2. b has yet to be pushed to the queue .Consider case 1. b . Priority must be null since the iterationends only when the priority of all the paths in the queue isnull. Consider the priority calculation of path b (either bythe queue . adapt operation or by the queue . push operation).According to the path priority definition (15), since b is a firstoptimal path, its priority can be set to null only if an optimal Path s , v was developed, in contradiction to our assumption.Turning to case 2, consider the list of ordered nodes repre-sented by path b : b . Nodes = { s , v b , v b , ... v } Let us define node v e as the last node in b . Nodes forwhich an optimal
Path s , v e with respect to λ i has already beendeveloped. We also denote by e the first developed optimal Path s , v e .We note that v e and e must exist since the first developedpath, which contains only the start node s (in other words: v e = s and e . Nodes = { s } ) is a first developed optimal Path s , v e with respect to λ i . In addition, v e (cid:54) = v since otherwisean optimal Path s , v with respect to λ i has been developed,contrary to our assumption.Let v f be the node after v e on the path b . Let f ∈ Path s , v f be the path e followed by the node v f .Consider the ancestor (see Definition 27) of b ending in v f ,namely b f . According to Lemma 5, b f is optimal with respectto λ i . From the additivity of Cost and since e is optimal withrespect to λ i as well, we conclude that: Cost ( f , λ i ) = Cost ( b f , λ i ) . Hence, f is optimal Path s , v f with respect to λ i .Recall that v e is followed by v f on the b . Nodes list and that v e is the last node in the b . Nodes list for which an optimal
Path s , v e with respect to λ i has already been developed, i.e.,anoptimal Path s , v f with respect to λ i has not been developed.Additionally, f was scanned, since its ancestor, e , had beendeveloped. Hence, either f is the first optimal Path s , v f , or thefirst optimal Path s , v f is already in the queue ; in either case,the first optimal Path s , v f with respect to λ i must be in the queue . According to Definition 15, such a path does not havenull priority. Hence, the iteration has not concluded, which isa contradiction.To conclude, we have established that none of the sce-narios is possible, thus contradicting our assumption. Thus,after the i th iteration, an optimal Path s , v with respect to λ i has been developed.The IDAQ algorithm returns only when the last iteration ends,hence the theorem follows. Theorem 2.
IDAQ solves the
MOW SP problem.
Proof.
Recall that the IDAQ algorithm returns the followingset: optimal _ sets = Build − Sets ( optimal _ paths , Λ , G ) The Build-Sets procedure described in Section 4.4 returns foreach coefficient vector λ i ∈ Λ , a set of paths P i = { p v , p v , ..., p v n } where for each node v i ∈ V : p v i ∈ Path s , v i Note that e is not necessarily an ancestor of b (see Definition 27) optimal _ sets , say P j , and some node, say v ∈ V ,such that a p v ∈ P j is not an optimal Path s , v with respect to λ j .We shall denote the first developed optimal Path s , v withrespect to λ j by op v . Note that, according to Theorem 1, anoptimal Path s , v with respect to λ j has been developed bythe time that the IDAQ algorithm returns, i.e., op v has beendeveloped by that time. Recall that any path that has beendeveloped is inserted into the optimal _ paths list (lines 16-17of Algorithm 2), hence op v is in the optimal _ paths list. Inother words, op v ∈ optimal _ paths ∩ Path s , v According to the description of the Build-Sets proce-dure (Section 4.4), for any paths set in optimal _ sets , say P j ,and for any node in V , say v , the following holds: p v ∈ P j ,achieves the minimum value of Cost ( p , λ j ) among all paths p ∈ optimal _ paths ∩ Path s , v .Since op v ∈ optimal _ paths ∩ Path s , v the following holds: Cost ( p v , λ j ) ≤ Cost ( op v , λ j ) According to Definition 8, since op v is optimal with respectto λ j , for any p ∈ Path s , v the following holds: Cost ( op v , λ j ) ≤ Cost ( p , λ j ) Hence,
Cost ( p v , λ j ) ≤ Cost ( op v , λ j ) ≤ Cost ( p , λ j ) Thus, p v is by definition an optimal Path s , v with respect to λ j ,which is a contradiction, hence establishing the theorem. We turn to analyze the time complexity of the IDAQ algorithm.We divide IDAQ operations into four parts and analyze eachseparately.1. Developing paths (theorem 3).2. Scanning paths ( theorem 5).3. Adapting the queue between iterations (theorem 6).4. Executing the Build-Sets procedure.The overall time complexity of IDAQ shall be established inTheorem 8.
In this subsection we establish the time complexity analysisof developing paths in IDAQ (Part 1). The main motivationfor IDAQ is to avoid developing paths that have already beendeveloped in previous iterations, therefore we expect to gethere a lower bound on the number of developed paths (and,as a result, a lower time complexity) than for the StandardAlgorithm.First, we calculate the time complexity of developing paths(Theorem 3). We begin by introducing and proving severalauxiliary lemmas.
Lemma 8.
Consider a first optimal path with respect to λ i ∈ Λ , say p ∈ Path s , v . In case p is pushed to the queue during the i th iteration, the priority of each of the queue ’s paths endingat node v is set to null. Proof.
Consider any path b ∈ Path s , v . Note that, since p isfirst optimal with respect to λ , at the time p is pushed to thequeue, the following holds: Cost ( p , λ i ) < Cost ( b , λ i ) Hence, by the definition of path priority (Definition 15), b ’spriority is set to null, as required.In the following lemma we establish that the IDAQ algo-rithm does not develop non-optimal paths. This shall allow usto reach an upper bound on the number of developed paths. Lemma 9.
For i ∈ { , , ..., K } , a developed path in iteration i is optimal with respect to λ i . Proof.
Consider some iteration (see definition 21), say i , anda path p ∈ Path s , v that was developed during the i th iteration.Assume by way of contradiction that p is not optimal withrespect to λ . In other words, there exists another path b ∈ Path s , v such that b is first optimal with respect to λ i ∈ Λ , i.e.: Cost ( b , λ i ) < Cost ( p , λ i ) One of the following cases must hold:1. b and p were pushed to the queue during a previousiteration.2. b was pushed to the queue before p ; p was pushed to the queue during iteration i .3. p was pushed to the queue before b ; b was pushed to the queue during iteration i .4. b has yet to be pushed to the queue .12onsider case 1. At the beginning of the i th iteration, p isin the queue and b is in either the queue or the optimal _ paths list. We examine the priority calculation of p by the Adapt operation at the beginning of the i th iteration. According toDefinition 15, p ’s priority is set to null, thus implying that itcould not have been developed during the i th iteration.Consider case 2. According to Lemma 7, during thePush of p to the queue , either b is in the queue or the firstdeveloped optimal Path s , v is in the optimal _ paths list. Weexamine the priority calculation of p by the Push operation.According to Definition 15, p ’s priority is set to null, thusimplying that it could not have been developed during the i thiteration.Consider case 3. b is first optimal with respect to λ i , there-fore, at the time that b is being pushed to the queue (duringiteration i ), b .Priority is not null. According to Lemma 8, thepriority of each of the queue ’s paths ending at node v is setto null, in particular, the priority of p , thus implying that p could not have been developed during the i th iteration.Consider case 4. Note that, Since b is first optimal, Cost ( b , λ i ) < Cost ( p , λ i ) Consider the list of ordered nodes represented by path b : b . Nodes = { s , v b , v b , ... v } Let us define node v e as the last node in b . Nodes forwhich an optimal
Path s , v e with respect to λ i has already beendeveloped. We also denote by e the first developed optimal Path s , v e .We note that v e and e must exist since the first developedpath, which contains only the start node s (in other words: v e = s and e . Nodes = { s } ) is a first developed optimal Path s , v e with respect to λ i . In addition, v e (cid:54) = v since otherwisean optimal Path s , v with respect to λ i has been developed,contrary to our assumption.Let v f be the node after v e on the path b . Let f ∈ Path s , v f : f be the path e followed by the node v f .Consider the ancestor (see Definition 27) of b ending in v f ,namely b f . According to Lemma 5, b f is optimal with respectto λ i . From the additivity of Cost and since e is optimal withrespect to λ i as well, we conclude that: Cost ( f , λ i ) = Cost ( b f , λ i ) Hence, f is optimal Path s , v f with respect to λ i .Recall that v e is followed by v f on the b . Nodes list and that v e is the last node in the b . Nodes list for which an optimal
Path s , v e with respect to λ i has already been developed, i.e., an Note that e is not necessarily an ancestor of b (see Definition 27) optimal Path s , v f with respect to λ i has not been developed.In addition, f was scanned, since its ancestor, e , had beendeveloped. Hence, either f is first optimal Path s , v f , or the firstoptimal Path s , v f is already in the queue ; in either case, thefirst optimal Path s , v f with respect to λ i must be in the queue .We shall denote such a path by g . According to Definition 15, g . Priority is not null. Additionally, we have: g . Priority = Cost ( g , λ i ) = Cost ( f , λ i ) = Cost ( b f , λ i ) ≤ Cost ( b , λ i ) < Cost ( p , λ i ) i.e., g . Priority < p . Priority , in contradiction to p being apath with minimal not null priority in the queue .To conclude, we have established that none of the sce-narios is possible, in contradiction to our assumption. Lemma 10.
In each iteration, IDAQ develops each node atmost once.
Proof.
Assume by a way of contradiction that there existsa node that was developed more than once, say duringiteration i . Consider b and p as the first two Path s , v s that weredeveloped during the i th iteration. Without loss of generality,we assume that b was pushed to the queue before p .According to Lemma 9, both p and b have minimal costwith respect to λ i among all paths in Path s , v , i.e.: Cost ( p , λ i ) = Cost ( b , λ i ) . One of the following two cases must hold:1. b and p were pushed to the queue in a previous iteration.2. b was pushed to the queue before p , while p was pushedto the queue during the i th iteration.Consider case 1. At the beginning of the i th iteration, p and b are in the queue . We examine the priority calculation of p by the Adapt operation at the beginning of the i th iteration.According to definition 15, p ’s priority is set to null, thusimplying that it could not have been developed during the i thiteration.Consider case 2. Namely b is in the queue during the scanof p . Therefore, at the time that p is being pushed to the queue , p .Priority is set to null (Definition 15). According tothe definition of the Push operation, the priority of each ofthe queue ’s paths ending at node v is set to null, in particular,the priority of b , thus implying that b could not have beendeveloped during the i th iteration.To conclude, we have established that none of the scenariosis possible, in contradiction to our assumption.13 emma 11. IDAQ Develops any path no more than once. Proof.
Consider some node v ∈ V . By way of contradiction,let us assume that there exists a path b ∈ Path s , v , which waspushed to the queue after path p ∈ Path s , v so that both p and b represent the same path ending at node v (i.e. p = b ) andhave been developed at the time that the IDAQ algorithmreturns.Consider the scan of b . Since p was developed and p waspushed to the queue before b , p is either in the queue or inthe optimal _ paths list. Recall that Q is defined as the groupof paths that are either in the queue or in the optimal _ paths list (Definition 19), i.e., p ∈ Q . According to Definition 12, b is not Relevant with respect to Q , hence, p could not havebeen inserted to the queue and cannot be developed, in con-tradiction to our assumption. Lemma 12.
The number of nodes that are not L -Nodes (seeDefinition 30) is bounded by O ( log ( | V | ) : ( − α ) · | V | = O ( log ( | V | ) Proof.
According to Definition 31, L is determined so that: α ≥ − log ( | V | ) | V | ⇐⇒ ( − α ) · | V | ≤ log ( | V | ) i.e: ( − α ) · | V | = O ( log ( | V | )) thus the lemma follows. Lemma 13.
Consider any L -node, say v ∈ V L . There are atmost L different Path s , v ’s that are optimal with respect to anycoefficient vector in Λ . Proof.
In Lemma 3 we have established that each optimalpath is Pareto non-dominated. Consider some L -node, say v ∈ V L . According to Definition 30, v is at the end of at most L different Pareto paths. Therefore, the number of optimalpaths with respect to any coefficient vector is upper-boundedby L , as required. Lemma 14.
The number of developed paths that end at an L -node is upper-bounded by: | D L − nodes | = O ( | V L | · L ) = O ( | V | · α · L ) Proof.
By definition (see Section 5.2): α = | V L || V | Out of the set of all possible paths in
Path s Hence, the number of L -nodes is given by: | V L | = | V | · α Recall that:1. Due to Lemma 13, for any L -node, say v ∈ V L , there areat most L different Path s , v ’s that are optimal with respectto any coefficient vector in Λ .2. Due to Lemma 9, each path developed by IDAQ is opti-mal.3. Due to Lemma 11, during an execution of the IDAQalgorithm, a path is developed no more than once.Therefore, the number of developed paths that end at an L -node is upper-bounded by: | D L − nodes | = O ( | V L | · L ) = O ( | V | · α · L ) , as required. Lemma 15.
The number of developed paths ending at a nodethat is not an L -node is upper-bounded by: | D Not − L − nodes | = O ( | V \ V L | · K ) = O ( | V | · ( − α ) · K ) Proof.
By definition (see Section 5.2): α = | V L || V | ⇐⇒ | V L | = | V | · α ⇐⇒ | V | − | V L | = | V | · ( − α ) Since V L ⊆ V , we conclude that the number of non- L -nodesis given by: | V \ V L | = | V | · ( − α ) In Lemma 10 we have established that, at each iteration,IDAQ develops each node at most once. Recall that the num-ber of iterations is given by K , i.e., the number of developedpaths ending at any node is upper-bounded by K . Hence thenumber of developed paths ending at a node that is not an L -node is upper-bounded by: | D Not − L − nodes | = O ( | V \ V L | · K ) = O ( | V | · ( − α ) · K ) , as required.Finally, we employ lemmas 14 and 15 to get the total timecomplexity of developing nodes in IDAQ, which is presentedby the following theorem. Theorem 3.
The time complexity of developing paths inIDAQ (part 1) is : O ( L · | V | · log ( | V | )) = O ( F ( | V | ) · | V | · log ( | V | )) Recall that, according to Assumption 6, F ( | V | ) is a sub-logarithmic fun roof. In Lemma 14, we have established that the number of de-veloped paths that end at an L -node is upper-bounded by: | D L − nodes | = O ( | V | · α · L ) In Lemma 15, we have demonstrated that the number of de-veloped paths ending at a node that is not an L -node isupper-bounded by: | D Not − L − nodes | = O ( | V | · ( − α ) · K ) Obviously, each path in
Path s must end either at an L -node orat a node that is not an L -node, hence the number of developedpaths is upper-bounded by | P Developed | , where: | P Developed | = | D Not − L − nodes | + | D L − nodes | = | V | · ( − α ) · K (cid:124) (cid:123)(cid:122) (cid:125) (I) + | V | · α · L (cid:124) (cid:123)(cid:122) (cid:125) (II) = ( I ) + ( II ) and: ( I ) = | V | · ( − α ) · K ( II ) = | V | · α · L Using Lemma 12 and Assumption 3 we conclude that: ( I ) = K · O ( log ( | V | )) = O ( (cid:112) | V | · log ( | V | )) . Since α < ( II ) = O ( L · | V | ) = O ( F ( | V | ) · | V | ) We thus get: | P Developed | = O ( L · | V | ) = O ( F ( | V | ) · | V | ) . Note that each developed path has to be popped out of the queue as a path with minimal non-null priority.From Definition 15 we conclude that, for each node, say v ∈ V , the queue contains no more then a single Path s , v withnon-null priority. Hence, the total number of paths withnon-null priority in the queue , which is equal to the numberof paths in the Priority Heap (definition 16), is upper-boundedby | V | .The pop operation (described in Section 4.3) consists offinding a path with minimal priority in the Priority Heap(which is an instance of the Fibonacci Heap data structure).Therefore, a single pop is done in O ( log ( | V | )) [8].We thus conclude that the time complexity of developingpaths in IDAQ is: O ( | P Developed | · log ( | V | )) = O ( L · | V | · log ( | V | ) = O ( F ( | V | ) · log | V | · | V | ) We proceed to analyze the time complexity of scanningpaths in IDAQ (part 2). IDAQ checks whether a scannedpath p ∈ Path s is potentially optimal (by the Is-Relevantprocedure defined in Section 4.2.2). In that case, IDAQpushes p to the queue , which make it unnecessary for p ’sancestor to be developed again at a future iteration. We shallshow that, despite the fact that a single IDAQ scan is moretime-consuming than a scan of the Standard Algorithm, thetotal time complexity of the scans is lower for IDAQ.We begin by establishing the following lemma. Lemma 16.
The following equation holds: I · ( − γ ) = O ( L ) (5) Proof.
Since I = K − L , we have: I · ( − γ ) = O ( L ) ⇐⇒ O ( K ) · ( − γ ) = O ( L ) ⇐⇒ − γ = O ( L ) O ( K ) ⇐⇒| E | · ( − γ ) = O ( L · | E | ) O ( K ) To sum up, Equation 5 holds if the following Equation 6 holds: | E | · ( − γ ) = O ( L · | E | ) O ( K ) (6)Since E = | V | · D = O ( | V | · MaxDeg + ) , where MaxDeg + is defined as the maximum number of edges emanating froma single node, we conclude that: O ( L · | E | ) O ( K ) = O ( L · | V | · MaxDeg + ) O ( K ) From Assumption 3 we conclude that: = O ( L ) · O ( | V | · MaxDeg + )) O ( (cid:112) | V | )= O ( L ) · O ( | V | ) · O ( MaxDeg + ))) O ( (cid:112) | V | )= O ( L ) · O ( (cid:112) | V | )) · O ( MaxDeg + ) From assumptions 2 and 6 we conclude that: = O ( F ( | V | ) · O ( (cid:112) | V | )) · O ( log ( | V | )))= O ( F ( | V | ) · (cid:112) | V | ) · log ( | V | ))= O ( (cid:112) | V | · log ( | V | ) · F ( | V | )) | E | · ( − γ ) = O ( (cid:112) | V | · log ( | V | ) · F ( | V | )) (7)Note that the number of edges emanating from nodes that arenot L -nodes is upper-bounded by the number of such nodestimes the maximum nodal degree, namely: | E | · ( − γ ) = ( | V | − | V L | ) · O ( MaxDeg + )= ( − α ) · | V | · O ( MaxDeg + ) = O (( − α ) · | V | · MaxDeg + ) Using Lemma 12 and Assumption 2 we conclude that: | E | · ( − γ ) = O ( log ( | V | ) · log ( | V | )) = O ( log ( | V | )) Hence, Equation 7 holds, thus implying that Equation 5 holds,and the lemma follows.Next, we employ lemmas 14, 15 and 16 to establish anupper-bound on the total number scans performed during anexecution of the IDAQ algorithm.
Theorem 4.
An upper-bound of the number of scans per-formed during an execution of the IDAQ algorithm is givenby | P Scanned | , where: | P Scanned | = O ( | E | · L ) . (8) Proof.
Note that a path that was developed causes all of itsneighbors to be scanned. Hence, the number of scanned pathsequals the number of outgoing edges from each developedpath.Recall that E L is defined as the set of all outgoing edgesfrom V L (see Section 5.2). In Lemma 14, we have establishedthat the number of developed paths ending at an L -node isupper-bounded by: | D L − nodes | = O ( | V L | · L ) Hence, the number of scans of paths that are neighbors of an L -nodes is given by: | S L − nodes | = O ( | E L | · L ) Recall that the set of nodes that are not L -nodes is given by V \ V L . Since the set of edges is given by E , and each nodeis either an L -node or a non- L -node, the set of all outgoingedges from a V \ V L is given by E \ E L . In Lemma 15 we haveestablished that the number of developed paths ending at anode that is not an L -node is upper-bounded by: | D Not − L − nodes | = O ( | V \ V L | · K ) Hence, the number of scans of paths that are neighbors ofnon- L -nodes is given by: | S Not − L − nodes | = O ( | E \ E L | · K ) Thus, the total number of scans is given by | P Scanned | ,where: | P Scanned | = | S L − nodes | + | S Not − L − nodes | = O ( | E L | · L + | E \ E L | · K )= L · | E L | + ( | E | − | E L | ) · K = | E | · ( L · | E L || E | + K · ( − | E L || E | )) From the definition of γ (Section 5.2), we conclude that: | P Scanned | = | E | · ( L · γ + K · ( − γ )) Since K = L + I : | P Scanned | = | E | · ( L · γ + L + I − L · γ − I · γ )= | E | · ( L + I · ( − γ )) In Lemma 16 we have established that: I · ( − γ ) = O ( L ) , hence, | P Scanned | = | E | · ( L + O ( L )) = | E | · O ( L ) = O ( | E | · L ) , as required.We proceed to calculate (in Lemma 18) the time complex-ity of scanning a single path ending at an L -node. We beginby establishing an auxiliary lemma.For the following lemmas we consider the set of paths Q (definition 19), and the subset of paths Q v ⊆ Q (definition 9). Lemma 17.
For any L -node v ∈ V L , Q contains no more than N L paths ending at v . | Q v | ≤ N L Proof.
According to Lemma 4, after initialization, the pareto _ sample list contains a Pareto non-dominated pathfor each L -node. Consider such a Pareto non-dominated path p ∈ Path s , v where v ∈ V L . According to assumption 4, thereexist at most N L paths ending at v that are non-dominated by p .A path that is pushed to the queue must be non-dominatedby p (lines 21-22 of Algorithm 2), thus implying that thereexist at most N L paths ending at node v that can be pushed tothe queue during an execution of the IDAQ algorithm. Onlypaths that were pushed to the queue can be inserted to the optimal _ paths list, thus the lemma follows. Lemma 18.
Scanning a single path that ends at an L -node isdone in O ( L ) .16 roof. Consider some L -node v ∈ V L and a path p ∈ Path s , v .Recall that, during a scan of a path p , the IDAQ algorithmchecks whether p Is-Relevant with respect to Q (defined inSection 4.2.2), in which case IDAQ pushes p to the queue (line 25 of Algorithm 2).Note that, by Lemma 17, Q contains no more then N L pathsending at any L -node, i.e., | Q v | < N L In addition, due to Assumption 4, N L = O ( L ) . Hence, | Q v | = O ( L ) . We shall calculate the time complexity of scanning p . Theoperations performed during the scan of p are as follows:1. Checking whether p is non-dominated by the paths Q v (Is-Relevant procedure).2. Checking whether p dominates paths in Q v and removingthem (Is-Relevant procedure).3. Updating the priority of queue ’s paths ending at node v (Push operation).4. Inserting p to the queue (Push operation).Consider operation 1. A single Pareto dominance check can bedone in O ( w ) . i.e, the time complexity of checking whether p is Pareto non-dominated by each path in Q v is upper boundedby: O ( N L · W ) = O ( L · W ) . Consider operation 2, In a similar manner to operation 1 above,this can be done in O ( L · W ) .Consider operation 3. It involves checking if p ’s cost is lowerin comparison to each of the queue paths ending at v . i.e, thiscan be done in O ( L ) .Consider operation 4. p is added to the queue ’s data structure,which is done in O ( ) . In case p is inserted to the queue ’s Pri-ority Heap (Definition 16), it has to be inserted to a FibonacciHeap, which is also executed in O ( ) [8].By Assumption 1, W = O ( ) We thus get, that a scan of an L -node is done in O ( L ) asrequired.Next, we calculate the time complexity of scanning pathsthat end at nodes which are not L -nodes. We begin by estab-lishing several auxiliary lemmas. Lemma 19. Q contains no more then K paths ending at anynode v ∈ V . | Q v | ≤ K Proof.
Consider some node v ∈ V . According to Lemma 17,in case v is an L -node: | Q v | ≤ N L ≤ KW ≤ K . Otherwise, the Is-Relevant procedure updates Q v to containonly paths that have the best cost for at least a single coef-ficient vector λ ∈ λ . Since | Λ | = K , there exist at most K different paths in Q v . Lemma 20.
A single IDAQ scan of a path that ends at a nodethat is not an L -nodes is done in O ( K ) . Proof.
Consider some node that is not an L -node, v / ∈ V L andpath p ∈ Path s , v . During a scan of p , the IDAQ algorithmchecks whether p Is-Relevant with respect to Q (defined inSection 4.2.2), in which case IDAQ pushes p to the queue (line 25 of Algorithm 2).In case the number of paths in Q v is smaller than KW , theactions involved in scanning p are identical as if v were an L -node. In other words, it can be done in O ( L ∗ w ) (Lemma18). Otherwise, the actions performed during the scan of p are as follows:1. Calculating p ’s cost for each iteration (Is-Relevant pro-cedure).2. Finding a path with minimal cost for each iteration in Q v (Is-Relevant procedure).3. Updating p ’s cost to null for each iteration i where p . Cost [ i ] > Best [ i ] . Cost [ i ] (Is-Relevant procedure).4. Removing unnecessary paths from Q v (Is-Relevant pro-cedure).5. Updating the priority of queue ’s paths ending at node v (Push operation).6. Inserting p to the queue (Push operation).Consider operation 1. The Cost calculation of p with respectto a single coefficient vector λ ∈ Λ is done in O ( w ) . Since | Λ | = K , the action can be done in O ( K · W ) .Consider operation 2. The paths with minimal cost in Q v foreach iteration can be calculated in an incremental manner,hence during the relevance check it is simply read in O ( ) .Consider operation 3. It involves iterating through each of p . Costs , which can be done in O ( K ) .Consider operation 4, It involves removing paths from Q v thatare no longer part of best v (see definition 13). According toLemma 19 | Q v | < K , this action can be done in O ( K ) .Consider operation 5. It involves checking if p ’s cost is lowerthan that of each of the queue paths ending at v . Note that, byLemma 19, the number of paths in Q v is at most K , i.e, thisoperation can be done in O ( K ) .17onsider operation 6. p is added to the queue data structure,which is done in O ( ) . In case p is inserted to the queue ’s Pri-ority Heap (Definition 16), it has to be inserted to a FibonacciHeap, which is also executed in O ( ) [8].By Assumption 1, W = O ( ) We thus get that a scan of a node that is not an L -node is donein O ( K ) , as required.We proceed to calculate the time complexity of the scansof nodes that are not L -nodes. Lemma 21.
The time complexity of scans of nodes that arenot L -nodes is given by O ( | V | · log ( | V | )) Proof.
Recall that, according to the definition of V L (Section5.2), the set of L -nodes is given by V L , hence the set of nodesthat are not L -nodes is given by V \ V L .Since each node has at most MaxDeg − incoming edgesand since during a single iteration each node is developed atmost once (Lemma 10), each node can be scanned at most MaxDeg − times during a single iteration, thus implying thatthe number of scans of nodes that are not L -nodes is upper-bounded by NotLNodesScans , where:
NotLNodesScans = K · | V \ V L | · MaxDeg − = K · ( − α ) · V · MaxDeg − In Lemma 20 we have established that a single IDAQ scan isperformed in O ( K ) . Therefore, the time complexity of scansof nodes that are not L -nodes is given by: O ( NotLNodesScans · K ) = O ( K · ( − α ) · | V | · MaxDeg − ) . By Lemma 12, the number of nodes that are not L -nodes isgiven by: O (( − α ) · | V | ) = O ( log ( | V | ) . By Assumption 2,
MaxDeg − = O ( log ( | V | ) . By Assumption 3: K = O ( (cid:112) | V | ) . Thus, the time complexity of scans of paths to nodes that arenot L -nodes is given by: O ( | V | · log ( | V | )) as required. Next, we employ the upper bound on the number ofscans (as established in Theorem 4), the time complexity ofscanning a single L -node (as established in Lemma 18) andthe time complexity of scanning a single node that is not an L -node (as established in Lemma 21) in order to calculate thetotal time complexity of IDAQ scans. We begin by provingan auxiliary lemma.First, we provide some intuition for the lemma.Consider a Path s , v that is scanned during the executionof IDAQ. Recall that, in case | Q v | > KW , the Is-Relevantprocedure uses the set best v (see Definition 13).The best v set is calculated in an incremental manner (line 20of the Is-Relevant procedure), however, for the first time it isbeing used, it has to be initialized.In the following lemma, we shall calculate the time complex-ity of such an initialization during the execution of the IDAQalgorithm. Lemma 22.
The time complexity of checking whether eachpath in
Path s , v Is-Relevant for the first time where Q v > KW isgiven by: O ( | V | · log ( | V | )) Proof.
Consider some node that is not an L -node, say v / ∈ V L . Consider the first time that the Is-Relevant procedureidentifies more than KW paths in Q v .The Is-Relevant procedure has to find all paths in Q v withminimal cost for each λ ∈ Λ ( Best paths list). This involvescalculating the cost of each path p ∈ Q v for each coefficientvector in λ ∈ Λ . This is done in: O ( | Q v | · K · W ) = O ( KW · K · W ) = O ( K ) and, due to Assumption 3: = O ( | V | ) According to Lemma 12, the number of nodes that are not L -nodes is given by: O ( | V | · ( − α )) = O ( log ( | V | ) . This implies that identifying all nodes that are not L -nodes isdone in: O ( | V | · log ( | V | )) . Theorem 5.
The total time complexity of scans in IDAQ isgiven by O ( | E | · L + | V | · log ( | V | )) Proof.
In Theorem 4 we have established that the number ofscans during an execution of the IDAQ algorithm is upper-bounded by | P Scanned | , where: | P Scanned | = O ( | E | · L ) (9)18n Lemma 18 we have established that a scan of an L -node isdone in O ( L · W ) . The number of scans of L -Nodes is upper-bounded by the total number of scans | P Scanned | , therefore thescans of L -Nodes in IDAQ is done in: O ( | P Scanned | · L · W + | V | · log ( | V | ))= O ( | E | · L · W + | V | · log ( | V | )) In Lemma 21 we have established that the scans nodes thatare not L -nodes is done in O ( | V | · log ( | V | )) .In Lemma 22 we have established that the time complexityof checking whether each path in Path s , v Is-Relevant for thefirst time where Q v > KW is given by: O ( | V | · log ( | V | )) Hence, the time complexity of scans in IDAQ is: O ( | E | · L · W + | V | · log ( | V | ))+ O ( | V | · log ( | V | )) + O ( | V | · log ( | V | ))= O ( | E | · L · W + | V | · log ( | V | ) + | V | · log ( | V | )) = By Assumption 1, W = O ( ) Thus we get, O ( | E | · L + | V | · log ( | V | )) We proceed to establish the time complexity of adapting the queue between IDAQ iterations (part 3). We shall show that,even though this part is relatively time-consuming, it is stillmore efficient than developing paths in the Standard Algo-rithm, which is done in: O ( K · | V | · log ( | V | ) Theorem 6.
Adapting the queue between IDAQ iterations isdone in: O ( K · | V | · L ) = O ( K · | V | · F ( | V | )) Proof.
Consider the beginning of a new iteration, i . In order toadapt the queue , the following operations need to be executed:1. Setting each path’s priority for iteration i .2. Initialize a new priority queue with the priorities calcu-lated in 1 Consider operation 1. According to definition 15, thisinvolves finding for each node v ∈ V a path p ∈ Path s , v withminimal Cost ( p , λ i ) among all the path in the Q v . For a nodethat is not an L -node, this can be done in O ( ) , since for sucha node the queue holds such a path for each iteration ( Best path list calculated by the Is-Relevant procedure). For an L -node, this can be done in O ( L · W ) . In the worst case, i.e,when all nodes are L -nodes, this is done in O ( | V | · L · W ) .Consider operation 2. Using Fibonacci heaps for thepriority queue, this is done in O ( V ) .In summary, we get that adapting the queue between itera-tions is done in: O ( | V | · L · W ) Since there is a total of K iterations we get that the total timecomplexity of adapting the queue is: O ( K · | V | · L · W ) = O ( K · | V | · F ( | V | ) · W ) By Assumption 1, W = O ( ) thus we get = O ( K · | V | · L ) = O ( K · | V | · F ( | V | )) At the end of the IDAQ algorithm, the Build-Sets procedureconverts the list of discovered optimal paths with respect toany coefficient vector to a set of paths for each coefficientvector, as required from a solution of the problem.In this section, we calculate the time complexity of the Build-Sets procedure (line 11 of algorithm 2).
Theorem 7.
The complexity of the Build-Sets procedure(line 11 in algorithm 2) is given by: O ( K · | V | · L ) = O ( (cid:112) | V | · | V | · F ( | V | )) Proof.
For each coefficient vector λ i ∈ Λ , the Build-Sets pro-cedure finds optimal paths ending in each node with respectto λ i by searching among the paths in the optimal _ paths list.Recall that in Lemma 9 we have established that eachdeveloped path is optimal, hence, the optimal _ paths list,which is the input paths list for the Build-Sets procedure,holds only optimal paths.We begin by calculating the complexity of finding anoptimal path with respect to λ i ending in a some node whichis not an L -node, say v ∈ V \ V L . In Lemma 10 we have19stablished that, at each iteration, IDAQ develops each nodeat most once. Recall that the number of iterations is given by K , i.e., the number of developed paths ending at any node isupper-bounded by K . Therefore, finding an optimal path withrespect to λ i is done in O ( K · W ) .We proceed to calculate the complexity of finding anoptimal path with respect to λ i ending at some L -node, say v ∈ V L . Due to Lemma 13, for any L -node, say v ∈ V L , thereare at most L different Path s , v that are optimal with respect toany coefficient vector in Λ . Therefore, finding the optimalpath with respect to a single coefficient vector is done in O ( L · W ) .We now calculate the complexity of finding an optimal pathwith respect to λ i ending at any node. Recall that the numberof nodes that are not L -Nodes is bounded by O ( log ( | V | )) (Lemma 12) and the number of L -Nodes is bounded by thetotal number of nodes, namely | V | . i.e, the time complexity isgiven by: O ( log ( | V | ) · K + | V | · L ) Finally, we are ready to calculate the complexity of theBuild-Sets procedure. The Build-Sets procedure finds an opti-mal path with respect to any coefficient vector ending in anynode. i.e, its time complexity is given by: O ( K · ( log ( | V | ) · K · W + | V | · L )) = O ( log ( | V | ) · K · W + | V | · L · K · W ) By Assumption 1, W = O ( ) Thus we get, = O ( log ( | V | ) · | V | + | V | · F ( | V | ) · (cid:112) ( | V | ))= O ( | V | · F ( | V | ) · (cid:112) ( | V | )) = O ( K · | V | · L ) as required. In Sections 5.5.1, 5.5.2, 5.5.3, 5.5.4 we analyzed the timecomplexity of each of the four parts of the IDAQ algorithm,namely: developing paths, scanning path, adapting the queue between iterations, and executing the Build-Sets procedure.This now allow us to establish the total time complexity ofIDAQ, as presented in the following theorem.
Theorem 8.
The time complexity of IDAQ is given by: O ( | E | · F ( | V | ) + (cid:112) | V | · | V | · F ( | V | )) = O ( | E | · L + K · | V | · L ) Proof.
By Theorem 3, the time complexity of developingpaths is: O ( L · | V | · log ( | V | )) = O ( F ( | V | ) · | V | · log ( | V | )) . By Theorem 5, the time complexity of scanning paths is: O ( | E | · L + | V | · log ( | V | )) . By Theorem 6, the time complexity of adapting the queue between IDAQ iterations is: O ( K · | V | · L ) = O ( (cid:112) | V | · | V | · F ( | V | )) . By Theorem 7, the time complexity of executing the Build-Sets procedure is: O ( K · | V | · L ) = O ( (cid:112) | V | · | V | · F ( | V | )) . We thus conclude that the time complexity of IDAQ is givenby: O ( F ( | V | ) · | V | · log ( | V | ))+ O ( | E | · L + | V | · log ( | V | ))+ O ( (cid:112) | V | · | V | · F ( | V | ))+ O ( (cid:112) | V | · | V | · F ( | V | ))= O ( | E | · F ( | V | ) + (cid:112) | V | · | V | · F ( | V | ))= O ( | E | · L + K · | V | · L ) we are ready to formally claim that under the assumptionspresented in section 5.3, IDAQ’s time complexity (Theorem 8)is asymptotically lower than that of the Standard Algorithm. Theorem 9.
The time complexity of IDAQ is asymptoticallylower than that of the Standard Algorithm by a factor of: Ω ( log | V | F ( | V | ) Proof.
In Theorem 8 we established that the time complexityof IDAQ is given by: O ( L · | E | (cid:124) (cid:123)(cid:122) (cid:125) (I1) + K · | V | · L | (cid:124) (cid:123)(cid:122) (cid:125) (I2) ) = O ( I + I ) (10)where: I = L · | E | I = K · | V | · L In Lemma 2 we established that the time complexity of theStandard Algorithm is given by: O ( K · W · | E | + K · | V | · log | V | )
20y Assumption 1, W = O ( ) Thus we get that the time complexity of the Standard Algo-rithm is given by: O ( K · | E | (cid:124) (cid:123)(cid:122) (cid:125) (S1) + K · | V | · log | V | (cid:124) (cid:123)(cid:122) (cid:125) (S2) ) = O ( S + S ) (11)where: S = K · | E | S = K · | V | · log | V | Recall that, according to Assumption 6, L = O ( F ( | V | )) Also recall that according to Assumption 3: K = O ( (cid:112) ( | V | )) Denote: ω = (cid:112) | V | F ( | V | ) ω = log | V | F ( | V | ) Note that O ( I ) · Θ ( ω ) = O ( K · | V | · L ) · Θ ( log | V | F ( | V | ) )= O ( K · | V | · F ( | V | ) · log | V | F ( | V | ) )= O ( K · | V | · log | V | )= O ( S ) (12)In addition, O ( I ) · Θ ( ω ) = O ( L · | E | ) · Θ ( (cid:112) | V | F ( | V | ) )= O ( L · | E | · (cid:112) | V | F ( | V | ) )= O ( F ( | V | ) · | E | · (cid:112) | V | F ( | V | ) )= O ( (cid:112) | V | · | E | ) = O ( K · | E | )= O ( S ) (13)Since F is a sub-logarithmic function (Assumption 6): ω = (cid:112) | V | F ( | V | ) > Θ ( log ( | V | )) and ω < Θ ( log ( | V | )) The following inequality holds: Θ ( ω ) < Θ ( ω ) (14)From expressions 13 and 14 we can conclude that the follow-ing holds: O ( I ) · Θ ( ω ) < O ( I ) · Θ ( ω ) = O ( S ) (15)Finally, from expressions 12 and 15 we can conclude that O ( I + I ) · Θ ( ω ) = O ( I ) · Θ ( ω ) + O ( I ) · Θ ( ω )= O ( S ) + O ( S )= O ( S + S ) (16)Since the complexity of IDAQ is given by O ( I + I ) (ex-pression 10) and the complexity of the Standard Algorithmis given by O ( S + S ) (expression 11), we conclude thatIDAQ’s complexity is lower than that of the Standard Algo-rithm by at least a factor of ω . Thus, we get that, indeed, thetime complexity of IDAQ is asymptotically lower than that ofthe Standard Algorithm by a factor of: Ω ( ω ) = Ω ( log ( | V | ) F ( | V | ) ) In the previous Theorem 9, we established that the timecomplexity of IDAQ is asymptotically lower than that ofthe Standard Algorithm by a factor of Ω ( log | V | F ( | V | ) . Recall that,according to Definition 31, L = O ( F ( | V | )) corresponds tothe maximal number of Pareto paths for most nodes, whichcan be expected to be relatively small in practice [20]. Forexample, if F ( | V | ) = O ( ) , the factor of improvement isgiven by Ω ( log | V | ) ; if F ( | V | ) = log log | V | , it is Ω ( log | V | loglog | V | ) ;and if F ( | V | ) = log − β | V | , for some 0 < β <
1, then it is Ω ( log β ( | V | ) . In this section, we present computational experiments con-ducted in order to assess the performance of IDAQ (Algorithm2) in comparison to the Standard Algorithm (Algorithm 1).Both algorithms have been implemented in a MATLAB envi-ronment. All experiments were conducted on a PC with 32GBRAM and 5 th Generation Intel R (cid:13) Core TM i5 Processor. In Sec-tion 6.1, we describe experiments conducted using randomlygenerated MOG s. In Section 6.2 ,we describe experimentsconducted on
MOG s generated using actual data representinga more practical setting (provided by Open Street [1]). Asshall be presented, in each experiment, we obtained identicalresults for IDAQ and for the Standard Algorithm, in termsof the quality (optimality) of the solution, as indeed impliedby the established correctness of IDAQ (Theorem 2). In eachexperiment, we measured the performance of each algorithmin terms of running time.21umber of Nodes Number Of Edges Density ( | E || V | ) )221 8344 0.1708287 14290 0.1734236 9682 0.1738245 10474 0.1744226 8566 0.1677266 12306 0.17394238 9716 0.1715233 9370 0.1725Table 1: Randomly Generated Waxman graph parameters,used in the experiments conducted in Section 6.1. The graphswere generated using the following Waxman model parame-ters: Domain = { [ , ] , [ , . ] } ; λ = α = β = . In this section, we demonstrate the advantage of using IDAQto solve a randomly generated instance of the
MOW SP prob-lem (Problem 2). We describe two different experiments (Ex-periment 1 and Experiment 2) conducted in order to assesIDAQ’s improvement in performance, in terms of runningtime, with respect to the Standard Algorithm. In Section 6.1.1we describe the
MOG (Definition 2) instances employed bythe experiments (we used the same
MOG s in the two experi-ments). In Sections 6.1.2 and 6.1.3 we describe the conductedexperiments.
MOG instances for Experiments 1 and 2
In this section we describe the generation of
MOG s employedby Experiment 1 and Experiment 2.First, we generated random Waxman graphs [29] using var-ious parameters. The properties of the generated graph andgeneration parameters are described in Table 1. In order togenerate an
MOG out of our generated Waxman graphs, weselected for each edge, uniformly at random, five objectives(see Definition 2), each assuming a value between 0 and 1.
In this section, we describe the experiment conducted in orderto asses IDAQ’s improvement in running time with respect tothe Standard Algorithm.Fist, we generate a set of
MOG s, as described in Section6.1.1).Next, we construct a
MOW SP out of each
MOG by selectinguniformly at random K coefficient vectors (see definition4 (recall that K = | Λ |)). Each coefficient is a randomlyuniformly generated number between 0.1 and 1.1. wecompared between the running times of IDAQ and theStandard Algorithm under various values of K . For each value of K we calculated the average running time of IDAQand the Standard Algorithm (Figure 1). As can be seen, IDAQexhibits better performance (in terms of running time), andits advantage is significant (up to an improvement of about50%) for large numbers of coefficient vectors. As describedin Section 4.1, similarly to the Standard Algorithm, IDAQis an iterative algorithm, which produces at each iteration atmost a single solution for each v ∈ V . However, unlike theStandard Algorithm, IDAQ shares knowledge between itsiterations. Therefore, we expect that in MOW SP s with a largesize of the coefficient vector, namely with a large K , IDAQwould exhibit better performance, as indeed demonstrated inFigure 1.Figure 1: Average running times of the Standard Algorithmand IDAQ for the MOWSP problem with different values of K . In this section we describe an experiment conducted inorder to compare between the running times of IDAQand the Standard Algorithm in scenarios in which IDAQdevelops a significantly smaller number of paths than theStandard Algorithm. In other words, we investigated IDAQ’sperformance improvement in scenarios where there isconsiderable knowledge that can be shared between thealgorithm’s iterations (in particular, considerably more thanin the Waxman topologies of Experiment 1).We found out that an easy way to control the number ofIDAQ developed paths is through the
MOW SP ’s coefficientvectors. Intuitively, using coefficient vectors that exhibitsimilarity increases the probability that a path that is optimalwith respect to a specific coefficient vector would be optimalalso with respect to other coefficient vectors, thus loweringthe amount of paths developed by IDAQ.The experiment runs as follows. We construct a set of22
OW SP in a similar manner to Experiment 1 (Section 6.1.2).We use the same set of
MOG s, but now create the coefficientvectors with a small change: instead of setting each coefficientto a uniformly distributed number between 0 . . . . MOW SP problem with a different number of coeffi-cient vectors K . The coefficient vectors were selected so thatiterations are more correlated than in Experiment 1. In this section we describe several experiments conducted on
MOW SP generated from actual data.We consider an application that finds several "optimal" routesfor a bicycle rider in Manhattan (New York, USA). To gener-ate our
MOG , we used data provided by Open Street Map [1].Each edge’s (=road) objective is determined by the following: C1 - Road distance. C2 - If bicycle road : C , C C3 - If road not close to highway : C , C C3 - If road not close to buildings : C , C K . We investigated the fundamental problem of routing withmultiple objectives. More specifically, we considered theproblem of providing several routes that minimize differentoptimization criteria. While this can be simply achieved byconsecutively executing a standard shortest path algorithm,in case of a large number of different optimization criteriathis may require an excessively large number of executions,thus incurring a prohibitively large running time.Our major contribution is a novel efficient algorithm for theconsidered problem, namely the IDAQ algorithm. Similarlyto the standard-approach algorithm, IDAQ iteratively searchesfor routes, one per optimization criteria; however, insteadof executing each iteration independently, it reduces theaverage running time by skilfully sharing information amongthe iterations. By doing so, it exploits the similarity amongoptimal routes with respect to different optimization cri-teria, so as to improve the performance of the solution scheme.We showed that both IDAQ and the standard algorithmprovide an optimal solution for the considered problem. Wethen showed that, under reasonable assumptions, IDAQ typi-cally provides considerably lower computational complexitythan that of the standard algorithm. We confirmed this findingthrough several computational experiments on both randomlygenerated settings, as well as settings that correspond toreal-world environments (specifically using data generatedfrom Open Street Map [1]).Several important issues are left for future work. One is toinvestigate whether assumptions employed in this paper canbe applied to speed up other multi-objective routing solutionschemes. For instance, in this study, we presented an efficientalgorithm that takes advantage of small Pareto sets to gain significant speed-up in comparison to a standard approachalgorithm that consecutively executes a (standard) shortestpath algorithm. We employed the assumption that, eventhough the number of Pareto paths can be non-polynomial,it is often relatively small in practice [20]. It is of interestto investigate whether such an assumption can be appliedto speed up other multi-objective routing schemes, such asResource Constrained Shortest Path algorithms or FullyPolynomial Time Approximation Schemes (FPTAS).Another interesting direction is to investigate whethersimilar results can be obtained in a setting where more thanone computational unit is allocated to solve the MOWSPproblem. A major advantage of the standard approachalgorithm over our proposed algorithm is that it is easyto break it into several processes: each iteration (in otherwords, execution of the Dijkstra algorithm) can be executedindependently, hence different computational units cantake care of different iterations, simultaneously. It is ofinterest to investigate whether in the case where more than asingle computational unit is available, an efficient algorithmcan be established to solve the MOWSP problem whilemaintaining a significant speedup in comparison to a standardapproach algorithm. This is, of course, quite challengingsince our approach is based on iterative steps where eachiteration depends on the previous one. It might be interestingto consider an iterative algorithm where each iterationexecutes a distributed version of a shortest-path algorithm,e.g. Bellman-Ford’s [4]. This may allow us to use similarideas to those implemented in IDAQ while taking advantageof multiple available computation units.Another important aspect is to compare our approachwith sub-optimal algorithms that provide an estimation ofthe Pareto set. In particular, it is of interest to investigateunder which conditions our approach provides better results(in terms of the quality of the solution or running time).The latter has to consider that, unlike Pareto sub-optimalalgorithms, our approach depends on pre-selected coefficientvectors.Last, in some settings, a heuristic scheme can be applied tospeed up a shortest path search, while still providing optimalsolutions (e.g, the A* algorithm [24] or other informed searchalgorithms ). In the case where an admissible heuristic issupplied for each coefficient vector, a standard informed al-gorithm can be proposed that is based on executions of aninformed search algorithm (instead of Dijkstra’s). It is of inter-est to investigate whether an efficient informed algorithm canbe proposed, based on similar ideas to those implemented inIDAQ, while reaching a similar speedup factor in comparisonto the standard informed algorithm. I.e., an algorithm guided by some heuristic eferences εε