Abstract For a weighted 2-edge connected graph G = (V ,E), we are to find a “min-imum risk path” from source s to destination t . This is a shortest s − t path under theassumption that at most one edge on the path may be blocked. The fact that the edgeis blocked is known only when we reach a site adjacent to the blocked edge.
If n and m are the number of nodes and edges of G, then we show that this prob-lem can be solved in O(n2) time using only simple data structures. This is an im-provement over the previous O(mn + n2 logn) time algorithm. Moreover, with useof more complicated data structures like Fibonacci Heaps and transmuters the timecan be further reduced to O(m + n logn).
Let G(V,E) be an undirected weighted graph with n nodes and m edges. Let s bethe source node and t the destination node. The shortest path problem is to find a pathP = {s = v0, v1, . . . , vk = t} such that the cost of P is minimised. This problem hasbeen extensively studied and has wide applications.
Xiao et al. (2009) consider the problem of going from a source node s to a destina-tion node t in the case of real time edge failure. A traveller is moving along the s − t
path P . When he reaches a node u on the path, he finds that the next edge (u, v) ∈ P
is blocked. So, he has to take a detour path from node u to reach the destination t . Thedetour path is a shortest u − t path in the graph G \ (u, v). Hence, the actual distancetravelled in case (u, v) ∈ P fails is the sum of distance from s to u along the path P
and the length of the detour path from u to t in G \ (u, v). The risk of a path P is the
J. Mahadeokar · S. Saxena (�)Dept. of Computer Science and Engineering, Indian Institute of Technology, Kanpur, India 208 016e-mail: [email protected]
maximum distance that needs to be travelled in case any edge (u, v) ∈ P fails giventhat this information is only available upon reaching the site of failure. The anti-riskpath problem is to find a path from s to t with the minimum risk.
Note that if the length of the path is very high, the s − t distance can be largeeven if there are no edge failures. In the other extreme case, the actual length of thepath maybe small, but if some edge on the path fails then the length of the real timedetour path maybe large. An edge for which the real time detour path length is highestamong all the edges on the path is called the most vital real time edge, or the detourcritical edge of the path (Nardelli et al. 1998).
This problem is different from the shortest path problem, as a shortest path be-tween s and t may not be a path with the minimum risk. Xiao et al. (2009) describescenarios in which travelling along the s − t path with minimum risk will be useful.They describe an algorithm which finds an anti-risk path in O(n(m + n logn)) time.
In this paper, we describe an improved algorithm to find an anti-risk path betweens and t . Our algorithm consist of three main parts:
1. Determining a shortest path tree T rooted at t .2. For every edge (u, v) ∈ T finding the length of detour path from u to t in case
edge (u, v) fails.3. Finding an anti-risk path from s to t using the detour path lengths determined
earlier.
Using some combinatorial properties, we describe a simple algorithm to solve theproblem in O(n2) time. This algorithm does not use data structures like Fibonacciheaps and transmuters which have large constant factors hidden in the asymptoticnotation. The proposed algorithm is optimal for dense graphs (where m = Θ(n2)).
For sparse graphs (where m = o(n2)), we show that if Fibonacci heaps are usedthen we can reduce the asymptotic time bounds. Assuming detour paths are known (inStep 2), we show that the anti-risk path from s to t can be found using O(m+n logn)
additional time (in Step 3). The algorithm can be used to build an anti-risk tree whichdescribes anti-risk paths from all nodes v ∈ V to destination node t in the same timebound. Finally, we show that the time required in Step 2, for computing detour pathlengths can be reduced (for sparse graphs) to O(m + n logn) using transmuters andpath compression techniques (Tarjan 1979; Nardelli et al. 2001).
The paper is organised as follows: In Sect. 2, we describe the relevant notation.In Sect. 3, we describe a simple O(n2) time algorithm for finding the “detour pathlength” for each failed edge in a shortest path tree rooted at t . In Sect. 4 we de-scribe the new algorithm for computing the anti-risk path and prove its correctness.In Sect. 5, we present a faster algorithm to find detour path lengths which takesO(m + n logn) time. Some concluding remarks are presented in Sect. 6.
2 Notation
Let G(V,E) be an undirected graph with positive edge weights, here V is the set ofnodes and E is the set of edges. Let n = |V | and m = |E|. Let s be the source nodeand t the destination node. PG(s, t) = {s = v0, v1, . . . , vk−1, vk = t} will denote a
J Comb Optim
path from s to t . For convenience, we will sometimes use P instead of PG(s, t).SPG(s, t) will denote a shortest path from s to t in G and dG(s, t) will denote itslength.
Consider a path PG(s, t) = {s = v0, . . . , vi−1, vi, . . . , vk = t}. If the edge ei =(vi−1, vi) fails, then in order to reach t , we must take an alternate path which avoidsthe edge ei .
We recall the following definitions from Xiao et al. (2009):
Definition 1 (Xiao et al. 2009) A detour path SPG\ei(vi−1, t) at node vi−1 is a short-
est path from vi−1 to t which does not make use of edge ei incident at vi−1.
Definition 2 (Xiao et al. 2009) The risk R(P ) of a path PG(s, t)
R(P ) = maxvi
{dG(s, t), dG(s, vi) + dG\{(vi ,vi+1)}(vi, t)
}
This is the length of a longest travel from s to t under the assumption that at mostone edge e ∈ P may be blocked.
The anti-risk path problem is to find a path P ∗G(s, t) such that R(P ∗) ≤ R(P )
holds for any s − t path PG(s, t).
3 Finding detour paths
To find an anti-risk path between s and t in an undirected graph G(V,E); we firstfind the detour path lengths from each node u to t , in case an edge (u, v) adjacent tou fails. Let T be a shortest path tree rooted at node t . Now, if edge (u, v) /∈ T then adetour path from u to t is the u − t path in shortest path tree T . Thus, it is trivial tofind a detour path and its length in case edge (u, v) /∈ T .
Hence, we only consider the case of finding the detour path length if (u, v) ∈ T .Xiao et al. (2009) state that this can be done in O(mn) time using algorithm givenby Nardelli et al. (1998). We give an algorithm to find the detour path lengths forevery edge (u, v) ∈ T in O(n2) time for graphs with general (not necessarily integer)weights.
We first find a shortest path tree T rooted at t . As the graph is undirected, we runDijkstra’s algorithm (Dijkstra 1959) from t . Now consider the case when an edge(u, v) fails. The shortest path tree gets divided into two subtrees, subtree Tu rooted atu and subtree Tt rooted at t as shown in Fig. 1.
Lemma 1 A detour path for edge (u, v) from u to t passes through only one non-treeedge (x, y) such that x ∈ Tu and y ∈ Tt .
Proof A detour path from u to t is a shortest u− t path in G \ (u, v). Since the graphis undirected, the detour path is also a shortest t − u path in G \ (u, v).
For each node y ∈ Tt a shortest t − y path is the path from t to y in Tt . We nextclaim that:
J Comb Optim
Fig. 1 The shortest path treerooted at t and the detour pathfrom u to t passing throughedge (x, y)
Claim 1 Shortest path in G, from u to any node x ∈ Tu is the u − x path in Tu.
Proof The claim follows as subtree Tu, of shortest path tree T , is rooted at u and x
is a node in Tu. �
Consider a detour path Π(u,v), for the edge (u, v). The path Π(u,v) must passthrough at least one non-tree edge (say) (x, y). Path P(t, y), the path between t andy in T , is a shortest path in G. According to Claim 1, P(u,x), the path between u
and x in T is also a shortest path in G. Hence, any t − y or u− x path will be at leastas large as P(t, y) or P(u,x) respectively. Thus, Π(u,v) need not use any non-treeedge either on t − y or u − x part. The lemma now follows. �
Thus, for any detour path for edge (u, v), the quantity dG(t, y) + c(x, y) +dG(x,u) should be minimum over all possible choices of non-tree edges (x, y).Moreover, the edge (x, y) must belong to the fundamental cut set (Deo 1974) of(u, v). Also observe that, as for x ∈ Tu, the path P(x, t) in T passes through u, wehave
Claim 2 For every node x ∈ Tu, dG(u, x) = dG(t, x) − dG(t, u).
We carry out preorder traversal on our shortest path tree T . Let pre(v) denotethe preorder number of node v and desc(v) denote the number of descendants of v,including v. Let α(v) = pre(v) + desc(v).
Corresponding to each non-tree edge (x, y) we associate a reduced cost ϕ(x, y)
which represents the detour path length, if that edge is used for some detour path.Like Nardelli et al. (2001), we define the reduced cost to be ϕ(x, y) = dG(x, t) +c(x, y)+dG(y, t), where dG(x, t) is the length of shortest path from x to t , c(x, y) isthe weight of edge (x, y) and dG(y, t) is the length of shortest path from y to t . Thelength of detour path from u to t using edge (x, y) is dG(u, x)+ c(x, y)+dG(y, t) =dG(u, x) + ϕ(x, y) − dG(x, t), which according to Claim 2, is ϕ(x, y) − dG(u, t),where dG(u, t) is the length of shortest path from u to t in the original graph G.
Let A be a two dimensional array consisting of n × n entries. Initialise all en-tries of A to a number more than the sum of lengths of all edges. We consider eachnon-tree edge (x, y) in turn and make the entries A[pre(x)][pre(y)] = ϕ(x, y) and
J Comb Optim
A[pre(y)][pre(x)] = ϕ(x, y). We next preprocess this array to answer two dimen-sional range minima queries. Yuan and Attalah (2010) have shown that a two dimen-sional array of n × n entries can be preprocessed in O(n2) time so that queries of thefollowing form can be answered in O(1) time:
Given parameters x1, x2, y1 and y1, return RMQ(x1, x2, y1, y2), the minimumvalue A[x][y] such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2.
A detour path for tree edge (u, v) must pass through an edge (x, y), with x ∈ Tu
and y ∈ Tt . Recall, that as nodes are labelled in preorder, the descendants of a node u
are exactly the nodes whose preorder number is between pre(u) and α(u). We havethe following cases:
1. A node y is visited before node u during the preorder traversal, if and only if,(pre(t) ≤ pre(y) ≤ pre(u) − 1).
Further as, x is descendant of u, we have (pre(u) ≤ pre(x) ≤ α(u)).2. A node y is visited after node u during preorder traversal, if and only if, (α(u) +
1 ≤ pre(y) ≤ α(t)).Since x is descendant of u we have (pre(u) ≤ pre(x) ≤ α(u)).
A detour path for edge (u, v) will be a minimum cost path which satisfies eitherof these conditions. To determine the length of a detour path, we perform followingtwo dimensional range minima queries on A:
The smaller of β1 and β2 will be the length of a detour path for edge (u, v). Thuswe can find the length of a detour path corresponding to a tree edge in O(1) time.
We can find a shortest path tree using Dijkstra’s algorithm is O(n2) time (see e.g.Aho et al. 1974, Theorem 5.8). We can easily determine the values pre(v), α(v) andϕ(u, v) in O(m) time. The two dimensional range minima preprocessing takes O(n2)
time. Since it takes O(1) time to find the detour path length corresponding to a treeedge, we can find the detour paths lengths corresponding to all n − 1 tree edges inO(n) time. To summarise, our proposed algorithm finds the length of detour pathscorresponding to all tree edges of T in O(n2) time.
4 Finding anti-risk path
Like in Dijkstra’s shortest path algorithm, we maintain a set S of “currently explored”nodes; in other words, for each node v ∈ S we have determined an anti-risk path v− t .
We will maintain a number r(v) for each node v. This number will denote thelength of “minimum risk path” from v to t . We initialise the array r to infinity (a num-ber larger than sum of all weights). To begin with, S = {t} and r(t) = 0.
Let u be a node not in S. Let us assume that u has a neighbour v ∈ S. To determinethe risk of the u − t path through v we consider two cases:
• If edge u − v fails, then let r ′v(u) be the distance between u to t in G \ (u, v) i.e.
r ′v(u) = dG\(u,v)(u, t).
J Comb Optim
• If edge u − v does not fail, then r ′′v (u) will be the sum of the cost of edge (u, v)
and the length of minimum risk path from v to t , i.e. r ′′v (u) = c(u, v) + r(v).
Thus the risk of u− t path through v will be rv(u) = max{r ′v(u), r ′′
v (u)}, the largerof the two values. Let r(u) = minv rv(u). As in Dijkstra’s algorithm, we choose anode u ∈ V \ S for which the value of r(u) is minimum, add it to set S. To track thepath, we also keep a parent pointer p(u) corresponding to each node. We set p(u) = v
to remember that the next node on our anti-risk path from u to t is v.Algorithm 1 gives a formal description of our anti-risk path algorithm. The overall
structure is similar to Dijkstra’s shortest path algorithm. However, the way in which“label” r( ) is updated is different.
Algorithm 1 Find anti-risk pathfor all nodes v ∈ V , r(v) ← ∞S ← {t}, r(t) ← 0while S �= V do
Select a node v /∈ S adjacent to a one node in S for which r(v) is minimumS ← S ∪ v
for each edge (u, v) ∈ E doif r(u) > max{r(v) + c(u, v), dG\(u,v)(u, t)} then
Note that each node u ∈ S has a parent pointer p(u).
Lemma 2 The parent pointers of nodes in S always form a tree rooted at t .
Proof The proof follows by an easy induction on |S|, the number of nodes in S. When|S| = 1, S = {t} and a single node is trivially a tree.
Assume that the claim is true till |S| = k for some k ≥ 1.Now consider adding another node u to S. As v, the parent of u is a node in S, the
parent pointers of nodes in S (including u) will continue to form a rooted tree at t . �
Let P(u, t) denote the unique path which is obtained if we follow the parent point-ers from u to t .
Lemma 3 At any point during the execution of the algorithm, for any node u ∈ S,P(u, t) is an anti-risk path from node u to t .
Proof We prove this by induction on |S|, the number of nodes in S.When |S| = 1, the claim is true, as in this case, S = {t} and r(t) = 0.Assume that the claim is true till |S| = k for some k ≥ 1.Now consider adding another node u to S. We claim that the risk of any other u− t
path Π is at least as large as that of P(u, t).
J Comb Optim
Fig. 2 The anti-risk pathP(u, t) and an alternate u − t
path Π
Let y be the first node not in S, encountered when moving from t on Π (see Fig. 2).As t ∈ S and u /∈ S such a node must exist. Note that y may be u. Let Πyt denote thesubpath of Π from y to t . Let x be the node just before y in Π ; by choice of y, x isin S. Since x ∈ S, by induction hypothesis we know that P(x, t) is an anti-risk pathfrom x to t .
The risk of path Πyt is R(Πyt ) = max{r(x)+c(x, y), dG\(x,y)(y, t)}. When x wasadded to S, we looked at edge (x, y) and made
r(y) = min{r(y),max
{r(x) + c(x, y), dG\(x,y)(y, t)
}}
Thus, r(y) ≤ R(Πyt ). Now, since the algorithm selected u in the (k + 1)th iteration,we know that r(y) ≥ r(u). Combining the inequalities, R(Πyt ) ≥ r(u).
If y = u, we have R(Π) = R(Πyt ) ≥ r(u). Next consider the case when y �= u.From the definition of risk of a path, we know that risk of a path is at least as large asthe risk of its subpath, i.e. R(Π) ≥ R(Πyt ). Thus we again have, R(Π) ≥ r(u).
Let p(u) = v, i.e. let (u, v) be the first edge on the path P(u, t). Consider the timewhen the algorithm added node v to S. At that point in time, as p(u) was made v,r(u) must have been more than max{r(v) + c(u, v), dG\(u,v)(u, t)} and the algorithmupdated the value of r(u) to max{r(v) + c(u, v), dG\(u,v)(u, t)}.
Since, even now, p(u) = v, this must be the last change that was made to r(u).Thus r(u) is the risk of path from u to t through node v i.e. path P(u, t). SinceR(Π) ≥ r(u), we have R(Π) ≥ R(P (u, t)). Hence, the risk of any other u − t pathΠ is at least as large as the risk of path P(u, t). �
The algorithm terminates when, all the nodes of the graph are part of the set S, thefollowing corollary follows:
Corollary 1 The algorithm correctly finds an anti-risk path from s to t .
After the execution of the algorithm, each node u ∈ V \ {t} is assigned a uniqueparent, say v ∈ V . Let ART denote the tree formed by connecting the nodes usingparent pointers. We call this the Anti-Risk Tree rooted at t . Lemma 3 also implies thefollowing corollary:
J Comb Optim
Corollary 2 For each node u ∈ ART , P(u, t) is an anti-risk path from node u tonode t in G.
We first describe an O(n2) implementation. First preprocess the graph in O(n2)
using algorithm of Sect. 3. After preprocessing, the length of detour paths from eachnode u to t can be obtained in O(1) time.
Let us use an array to store the r-values. The node with minimum r-value can beeasily identified in O(n) time (by looking at each r value in turn). As there can be atmost n − 1 edges (u, v) entering a node v, the inner-for-loop will be executed O(n)
times. Finally as after each iteration of the outer loop, exactly one node is added to theset S, there will be exactly n iterations of the outer while loop. Thus, the algorithmwill take O(n2) time.
5 Faster algorithm using Transmuter and Fibonacci heaps
If we use Fibonacci heaps, Dijkstra’s shortest path algorithm will take O(n logn+m)
time (Fredman and Tarjan 1987). We will use another Fibonacci Heap to maintain ther(u) values for each node u during the execution of the algorithm. The algorithm willdo O(n) deleteMin operations to find and remove the node u with minimum r(u).Also, there will be O(m) decreaseKey operations which will lead to decrease in r(u)
values in case a path with smaller risk is found when an edge (v,u) is considered.So, the time to find an anti-risk paths can be reduced to O(m + n logn).
Nardelli et al. (2001) have shown that the detour-critical edge on a s − t path canbe found in O(mα(m,n)) time on RAM model with integer weights. Here α(m,n)
is an inverse Ackermann function. We use their ideas and show that we can obtainthe detour path lengths corresponding to each tree edge (u, v) ∈ T in O(m + n logn)
time for general positive weighted graphs.Like Nardelli et al. (2001) we also make use of transmuter (Tarjan 1979, 1982).
Tarjan (1979, Sect. 7) has shown that a directed acyclic graph D called the trans-muter, for a tree T of a graph G can be constructed in O(mα(m,n)) time (Tarjan1982). Transmuter has following properties:
a. D has O(mα(m,n)) nodes and edges.b. Each tree edge (u, v) corresponds to a node a(u, v) of in-degree zero in D. Let
us call these nodes as the source nodes.c. Each non-tree edge (x, y) corresponds to a node b(x, y) of out-degree zero in
D. Let us call these nodes the sink nodes.d. There is a path from node a(u, v) to node b(x, y) in D if and only if (u, v)
is on the tree path joining x and y. In other words, edge (x, y) must be in thefundamental cut set of (u, v).
Like Nardelli et al. (2001), we first label each sink node b(x, y) of the transmuterwith its reduced cost ϕ(x, y). We then process the nodes of the transmuter in the re-verse topological order, labelling each node with the smallest label of its immediatesuccessors. As a result, each source node a(u, v) will be associated with a label, say
J Comb Optim
δ(u, v) which is the minimum of the reduced costs of non-tree edges in the funda-mental cut set of (u, v). As we saw in Sect. 3, the detour path length in case edge(u, v) fails will be equal to δ(u, v) − dG(u, t).
A shortest path tree for positive weighted graphs, can be built in O(m + n logn)
time using Dijkstra’s algorithm (Dijkstra 1959), with Fibonacci heaps (Fredman andTarjan 1987). The transmuter can be built in O(mα(m,n)) time. Since there areO(mα(m,n)) nodes in transmuter, it takes O(mα(m,n)) time to process them inreverse topological order. Thus, using this algorithm, we can obtain the detour pathlengths corresponding to each edge (u, v) ∈ T in O(mα(m,n) + n logn) time.
Note that if m ≥ n log logn then α(m,n) becomes a constant and hence, in thiscase, the algorithm will take O(m) time. For the case when m ≤ n log logn, m willalso be less than n logn. Thus, the term O(mα(m,n) + n logn) = O(m + n logn).
As shown in beginning of this section, if the detour path lengths are knownfor every edge (u, v) ∈ T , an anti-risk path between s and t can be found usingO(m + n logn) (additional) time. Thus, if we use this algorithm to find the detourpath lengths, the anti-risk path problem can be solved in O(m + n logn) time.
6 Conclusion
We describe a simple O(n2) time algorithm for finding an anti-risk path i.e. a min-imum cost path from any node s to t in case of real time single edge failures. Eventhough the algorithm is described for positive edge weights, it is easy to see that itwill also work for non-negative edge weights (i.e., even if some edge weights arezero).
Using Fibonacci heaps and transmuters, the time can be improved to O(m +n logn) time, the same as the time taken by the present best known algorithm tofind single source shortest path.
The problem of finding a simple O(m + n logn) time algorithm without usingtransmuter, and the problem of finding linear time algorithm for integer weights isstill open.
Acknowledgements We thank an anonymous referee for a very careful reading of the manuscript, andhis/her critical comments and suggestions. We believe these suggestions have helped in improving thereadability of the manuscript.
References
Aho AV, Hopcroft JE, Ullman JD (1974) The design and analysis of computer algorithms. Addison-Wesley,Reading
Deo N (1974) Graph theory with applications to engineering and computer science. Prentice-Hall, NewYork
Dijkstra EW (1959) A note on two problems in connexion with graphs. Numer Math 1(4):269–271Fredman M, Tarjan R (1987) Fibonacci heaps and their uses in improved network optimization algorithms.
J ACM 34(3):596–615Nardelli E, Proietti G, Widmayer P (2001) Faster computation of the most vital edge of a shortest path. Inf
Process Lett 79:81–85Nardelli E, Proietti G, Widmayer P (1998) Finding the detour-critical edge of a shortest path between two
nodes. Inf Process Lett 67(1):51–54
J Comb Optim
Yuan H, Attalah M (2010) Data structures for range minimum queries in multidimensional arrays. In:SODA’10, pp 150–160
Tarjan R (1979) Applications of path compression on balanced trees. J ACM 26:690–715Tarjan R (1982) Sensitivity analysis of minimum spanning trees and shortest path trees. Inf Process Lett
14(1):30–33Xiao P, Xu Y, Su B (2009) Finding an anti-risk path between two nodes in undirected graphs. J Comb
