Efficient Algorithms for Efficient Algorithms for Alternate Paths & Bridges in Alternate Paths & Bridges in

Networks and Geometric Networks and Geometric GraphsGraphs

Amit M BhosleAmit M BhosleDepartment of Computer ScienceDepartment of Computer Science

University of California, Santa BarbaraUniversity of California, Santa Barbara

OverviewOverview

► Transient failures and proactive recovery schemesTransient failures and proactive recovery schemes

► Single Single linklink failure recovery: definition and solutions failure recovery: definition and solutions Related link failure problemsRelated link failure problems Improvements for restricted graphsImprovements for restricted graphs

► Single Single nodenode failure recovery: definition and solutions failure recovery: definition and solutions

► Bridges connecting polygonsBridges connecting polygons

► Open ProblemsOpen Problems

Failures in IP BackbonesFailures in IP Backbones

► Five 9s availability (99.999% uptime) is highly desirableFive 9s availability (99.999% uptime) is highly desirable VOIP, VPN, Banking, Multimedia Conferencing, Shopping, … VOIP, VPN, Banking, Multimedia Conferencing, Shopping, …

► Failures occur quite frequentlyFailures occur quite frequently Faulty interfaces, router/link failures, maintenance activityFaulty interfaces, router/link failures, maintenance activity

► Markopolu, et al. (2004) characterized the failures in IP backbonesMarkopolu, et al. (2004) characterized the failures in IP backbones

► About 20% failures due to planned activity (e.g. maintenance)About 20% failures due to planned activity (e.g. maintenance)

► Most Most unplanned unplanned failures in communication networks are failures in communication networks are transienttransient and affect a and affect a single single elementelement 46% last less than 1 minute46% last less than 1 minute 86% last less than 10 minutes86% last less than 10 minutes 85% of all failures affect a 85% of all failures affect a single single link or nodelink or node

► Handling transient single node or link failures is key to ensuring high availabilityHandling transient single node or link failures is key to ensuring high availability

Proactive Recovery SchemesProactive Recovery Schemes

► Popular technique of handling transient failuresPopular technique of handling transient failures

► Precompute alternate paths that avoid the failed elementPrecompute alternate paths that avoid the failed element

► When a failure actually occursWhen a failure actually occurs Suppress the failure, instead of the traditional approach of Suppress the failure, instead of the traditional approach of

advertising it across the network (and hope that it is a transient advertising it across the network (and hope that it is a transient issue)issue)

Use the precomputed alternate paths to reroute traffic (and Use the precomputed alternate paths to reroute traffic (and survive the failure)survive the failure)

Single Link Failure Recovery Single Link Failure Recovery (SLFR)(SLFR)

► Given an edge weighted graph Given an edge weighted graph G G ((V,EV,E), and the shortest paths ), and the shortest paths tree tree TTss = = {{ee1 1 , e, e2 2 ,…, e,…, en-1n-1}} of a node of a node s, s, wherewhere e eii= = {{xxi i , y, yii} and } and xxi i is is the parent of the parent of yyii in in TTss

► For For 1 1 ≤ ≤ i i ≤ ≤ n-1n-1, find the shortest path from , find the shortest path from yyii to to s s in the graph in the graph

GG-i-i = = G G \ \ eeii GG-i -i is obtained from is obtained from G G by deleting the edge by deleting the edge eeii

► G G assumed to be 2-edge-connected, and undirectedassumed to be 2-edge-connected, and undirected

Single Node Failure Recovery (SNFR)Single Node Failure Recovery (SNFR)

► Given an edge weighted graph Given an edge weighted graph GG((V,EV,E), and the shortest paths ), and the shortest paths tree tree TTss of a node of a node s, s, where where CCxx= = {{xx1 1 , x, x2 2 , x, x3 3 ,…, x,…, xkk}} denote the denote the children of children of x x in in TTss

► For each node For each node x x єє G G, and , and x x ≠≠ s s, find a path from each , find a path from each xxii єє CCxx to to ss in the graph in the graph GG-x-x = ( = (V V \ \ x, E x, E \\ E Exx)) GG-x-x is obtained from is obtained from G G by deleting the node by deleting the node xx and all its edges and all its edges

► G G assumed to be 2-node-connected, and undirectedassumed to be 2-node-connected, and undirected

SLFR SNFRSLFR SNFR

s

y

x

s

x

xjxi

SLFR, SNFR: Naïve AlgorithmSLFR, SNFR: Naïve Algorithm

► Recompute the shortest paths tree of Recompute the shortest paths tree of s s separately in each of separately in each of

the the n-1 failure n-1 failure graphs (graphs (GG-i-i graphs for SLFR problem, and graphs for SLFR problem, and

GG-x-x graphs for SNFR problem)graphs for SNFR problem)

► Time Complexity: Since we have Time Complexity: Since we have OO((nn)) failure graphs, the failure graphs, the naïve algorithm requires naïve algorithm requires OO((nn((m+nm+n log log nn)))) timetime

► Simple, but inefficient (at least for undirected graphs)Simple, but inefficient (at least for undirected graphs)

SLFR, SNFR: Our ResultsSLFR, SNFR: Our Results

► SLFR: SLFR: OO((m + nm + n log log nn)) time for computing optimal alternate pathstime for computing optimal alternate paths Planar undirected graphs: linear timePlanar undirected graphs: linear time Undirected, integer edge weights: Undirected, integer edge weights: OO((m + Tm + Tsortsort((nn))))

► Currently Currently TTsortsort((nn) = ) = OO((n log log nn log log n) [Han ’02]) [Han ’02] Some improvements for replacement-paths problemSome improvements for replacement-paths problem

► Given an Given an s-t s-t shortest path, find alternate shortest path, find alternate s-t s-t paths if each edge of the original s-t paths if each edge of the original s-t shortest path fails, one at a timeshortest path fails, one at a time

► SNFR: SNFR: OO((m m log log nn)) time algorithm time algorithm Computes Computes good good alternate paths – within alternate paths – within 15% 15% of optimal for randomly of optimal for randomly

generated graph with generated graph with 100 – 1000 100 – 1000 nodes, and an average degree of nodes, and an average degree of 10 – 3010 – 30

SLFR: Key PropertiesSLFR: Key Properties

vu

y

x

s

► ((u, vu, v) offers an alt path with weight ) offers an alt path with weight pp((u,vu,v) = ) = dd((y,vy,v)) + w + w((v,uv,u)) + d + d((u,su,s))

► Shortest alternate path minimizes Shortest alternate path minimizes p p over all such escape edgesover all such escape edges► p’p’((u,vu,v) = ) = dd((s,ys,y)) + p + p((u,vu,v)) = d = d((s,vs,v)) + w + w((v,uv,u)) + d + d((u,su,s))

does not changedoes not change the the final final answeranswer is independent of (is independent of (x,yx,y))

SLFR: A Recursive AlgorithmSLFR: A Recursive Algorithms

► b b edges have both end points within the subtree of edges have both end points within the subtree of xx, and are not valid escape edges for , and are not valid escape edges for xx. .

x

► gg edges have exactly one end point inside the subtree of edges have exactly one end point inside the subtree of xx, and are valid escape , and are valid escape edges for edges for x.x.

b1b2 g1 g2

► All these were valid escape edges for the children of All these were valid escape edges for the children of xx

How do we efficiently determine whether an edge is a valid escape edge or not?How do we efficiently determine whether an edge is a valid escape edge or not?

DFS Start / End LabelsDFS Start / End Labels

► Assign Assign start start and and end end labels to nodes as a depth-first-search traversal of the tree labels to nodes as a depth-first-search traversal of the tree starts or ends at the nodestarts or ends at the node

v

u

(1,14)

(2,11)

(3,4)

(8,9)(6,7)

(5,10)

(12,13)w

► A node A node vv belongs to the subtree of belongs to the subtree of u u iff iff dfsStartdfsStart((uu) < ) < dfsStartdfsStart((vv) < ) < dfsEnddfsEnd((vv) < ) < dfsEnddfsEnd((uu))

► Valid escape edges have exactly one end point in the node’s subtreeValid escape edges have exactly one end point in the node’s subtree

SLFR AlgorithmSLFR Algorithm

► Organize escape edges in a heap Organize escape edges in a heap HH, with the , with the p’ p’ weights as the weights as the priority of the heap elementspriority of the heap elements

► For leaf nodes, For leaf nodes, HH..findMin findMin retrieves the best escape edgeretrieves the best escape edge

► HHxx meldmeld((HHxx, , HHx1x1, , HHx2 x2 ,…, ,…, HHxkxk) where ) where xixi is a child node of is a child node of xx At this point, At this point, HHxx may contain some invalid edgesmay contain some invalid edges

► To find the escape edge for x:To find the escape edge for x: while (while (HHxx..findMin findMin is is invalidinvalid))

HHxx.deleteMin.deleteMin

x.escapeEdge x.escapeEdge = = HHxx.findMin.findMin

SLFR Algorithm: Time ComplexitySLFR Algorithm: Time Complexity

► The previous algorithm has The previous algorithm has OO((mm) ) deleteMindeleteMin, , OO((m+nm+n) ) findMinfindMin and and OO((nn) ) meld meld operationsoperations

► F-heaps have F-heaps have OO((log nlog n) for ) for deleteMindeleteMin, and , and OO((11) for ) for findMin findMin and and meld meld operations. Thus, this algorithm has operations. Thus, this algorithm has OO((m log nm log n) total time complexity) total time complexity

► We can reduce the number of candidate escape edges from We can reduce the number of candidate escape edges from OO((mm) to ) to OO((nn) in ) in OO((m + n log nm + n log n)) time using an MST property. time using an MST property. This improves time complexity to near-optimal This improves time complexity to near-optimal OO((m + n log nm + n log n))

► DAGs admit a linear time solutionDAGs admit a linear time solution

SLFR Algorithm: SLFR Algorithm: kk-RE-MST-RE-MST

► k-RE-MST:k-RE-MST: For each edge of the MST, find the For each edge of the MST, find the k k least cost edges of least cost edges of G G across the cut across the cut

induced by deleting the edgeinduced by deleting the edge

► Sub-problem in Shen’s randomized algorithm [Shen ’99] for finding the Sub-problem in Shen’s randomized algorithm [Shen ’99] for finding the k k most vital edges of an MSTmost vital edges of an MST

► Shen’s algorithm has O(Shen’s algorithm has O(nn22) time complexity, bottlenecked at the k-RE-) time complexity, bottlenecked at the k-RE-MST solutionMST solution

► SLFR can be easily generalized to solve this problem in SLFR can be easily generalized to solve this problem in OO((m + n log nm + n log n)) time, and achieve corresponding improvement in Shen’s algorithmtime, and achieve corresponding improvement in Shen’s algorithm For each node, find not just For each node, find not just 11, but , but k k cheapest valid edgescheapest valid edges Insert the valid edges thus found back after a node has been processedInsert the valid edges thus found back after a node has been processed

SNFR: Key PropertiesSNFR: Key Properties

s

► Green Green edges (e.g. edges (e.g. ggii, , ggjj) have one end point outside the subtree of ) have one end point outside the subtree of xx..

ggii and and ggjj can be used by can be used by xxii and and xxjj respectively to reach respectively to reach ss..

x

bpbq

gj

gi

x1xjxi

► Blue edges (e.g. Blue edges (e.g. bbpp, , bbqq) run between subtrees of siblings. ) run between subtrees of siblings. Together with green edges, they can offer a valid alternate paths. Together with green edges, they can offer a valid alternate paths. E.g. E.g. bbpp offers an alternate path to offers an alternate path to xx11 (either (either bbqq ggjj, or directly using , or directly using ggii).).

G

SNFR: Constructing SNFR: Constructing RRxx

sx

bpbq

gj

gi

x1xjxi

y1yi yj

sx

y1 yi yj

sx

TsxRx

G

SNFR AlgorithmSNFR Algorithm

► Recursive algorithm somewhat similar to the SLFR algorithmRecursive algorithm somewhat similar to the SLFR algorithm

► Each node needs the following informationEach node needs the following information Cheapest green edge for each child nodeCheapest green edge for each child node Blue edges among the subtrees of the child nodesBlue edges among the subtrees of the child nodes

► An edge is green for a node if it has one end point in the An edge is green for a node if it has one end point in the node’s subtree, and the other outside the node’s parent’s node’s subtree, and the other outside the node’s parent’s subtreesubtree

► An edge is blue in An edge is blue in RRxx if if x x is the nearest-common-ancestor of is the nearest-common-ancestor of the two end points of the edgethe two end points of the edge

SNFR Algorithm (Contd.)SNFR Algorithm (Contd.)

► Using Using NCA NCA data structures, precompute the set of blue edges data structures, precompute the set of blue edges in each in each RRxx

► Merge green edges heaps of child nodes to build the green Merge green edges heaps of child nodes to build the green edges heap for a parent nodeedges heap for a parent node At this point, parent node’s heap may contain some invalid edgesAt this point, parent node’s heap may contain some invalid edges

► Use DFS start/end labels to check if edge is a valid green Use DFS start/end labels to check if edge is a valid green edge; discard if notedge; discard if not

► Using heaps with Using heaps with OO((log nlog n) time for ) time for deleteMin, findMin deleteMin, findMin and and meld meld operations, we have an operations, we have an OO((m log nm log n) solution) solution OO((mm) ) deleteMin, OdeleteMin, O((nn) ) meld meld and and OO((m+nm+n) ) findMin findMin operationsoperations

SNFR Algorithm: Empirical EvaluationSNFR Algorithm: Empirical Evaluation

A Proactive Recovery Scheme Using A Proactive Recovery Scheme Using Paths Computed by SLFR/SNFRPaths Computed by SLFR/SNFR

► SLFR/SNFR assign an escape edge to each nodeSLFR/SNFR assign an escape edge to each node The escape edge defines the alternate path that avoids the failed The escape edge defines the alternate path that avoids the failed

elementelement

► If (If (u,vu,v) is the escape edge of node ) is the escape edge of node xx, if , if xx’s parent (or the parent ’s parent (or the parent linklink) is down, send message to ) is down, send message to uu

► Embed control information in the message so that intermediate Embed control information in the message so that intermediate nodes know how to handle the message nodes know how to handle the message Message should be routed to Message should be routed to uu, and not , and not ss Important to provide Important to provide loop-free loop-free routingrouting

► u u sends message to sends message to v v along (along (u,vu,v), after which it is ), after which it is vv’s ’s responsibility to send the message to responsibility to send the message to s s ((u u deletes the control deletes the control information)information)

SLFR/SNFR: Improvements to Related SLFR/SNFR: Improvements to Related ProblemsProblems

► Anti-block vital edge [SXX ’07]Anti-block vital edge [SXX ’07] Very similar to the SLFR problem, except that the aim is to find the edge Very similar to the SLFR problem, except that the aim is to find the edge

which results in the largest ratio which results in the largest ratio PPG-eG-e(u,s) / (u,s) / PPGG(u,s) (u,s) Authors present an Authors present an OO((nn33) algorithm for this problem) algorithm for this problem An An OO((nn) post-processing of SLFR results suffices to solve this problem in near-) post-processing of SLFR results suffices to solve this problem in near-

optimal optimal OO((m + n log nm + n log n) total time) total time

► Most Vital Node under Uncertainty [Yan ’06]Most Vital Node under Uncertainty [Yan ’06] Given an s-t path, alternate paths are defined as those in SNFR problem (from Given an s-t path, alternate paths are defined as those in SNFR problem (from

child of failed node to child of failed node to tt).). Find node Find node uu ( (nextHop = vnextHop = v) which produces longest path: ) which produces longest path: PPGG((s,us,u) + ) + PPG-vG-v((u,tu,t)) Using our path weight functions, and techniques similar to those for the most-Using our path weight functions, and techniques similar to those for the most-

vital-node solution [NPW03], this problem can be solved in near-optimal vital-node solution [NPW03], this problem can be solved in near-optimal OO((m + n log nm + n log n) total time) total time

Some Open Problems Related to Some Open Problems Related to SLFR/SNFRSLFR/SNFR

► Directed graphsDirected graphs Our upper bounds are strictly for undirected graphsOur upper bounds are strictly for undirected graphs ((mm n n) lower bound holds for directed graphs in path comparison model (as ) lower bound holds for directed graphs in path comparison model (as

long as long as m = Om = O((nn n n) )) ) Recently, replacement paths problem solved in Recently, replacement paths problem solved in OO((n logn log33 nn) time for directed ) time for directed

planarplanar graphs [EPR ’08] graphs [EPR ’08]

► Multiple link failuresMultiple link failures Any two links in the network?Any two links in the network? We presented an We presented an OO((nn33) algorithm for computing alternate ) algorithm for computing alternate s-t s-t paths when the 2 paths when the 2

failed links are on the original failed links are on the original s-t s-t pathpath Trivial lower bound of Trivial lower bound of ( (nn22) for 2-link version) for 2-link version

► Multiple node failuresMultiple node failures Any two nodes in the networkAny two nodes in the network Failure of Failure of related related nodesnodes

► Two end points of an edgeTwo end points of an edge► A node and all of its A node and all of its k - k - hop neighborshop neighbors

Some Open Problems Related to Some Open Problems Related to SLFR/SNFR (Contd.)SLFR/SNFR (Contd.)

► Faster algorithm and/or better alternate paths for SNFR problemFaster algorithm and/or better alternate paths for SNFR problem Our solution runs in Our solution runs in OO((m log nm log n) time, and does not compute optimal alternate ) time, and does not compute optimal alternate

pathspaths Naïve upper bound for computing optimal alt paths: Naïve upper bound for computing optimal alt paths: OO((nn((m + n log nm + n log n)) ))

► Distributed algorithms for the SLFR/SNFR problemsDistributed algorithms for the SLFR/SNFR problems All known algorithms are centralized, and need information of the entire All known algorithms are centralized, and need information of the entire

network graph as inputnetwork graph as input Especially of interest if all other steps performed at setup time are distributed Especially of interest if all other steps performed at setup time are distributed

algorithmsalgorithms

► A proactive recovery scheme that uses these efficient paths and doesn’t A proactive recovery scheme that uses these efficient paths and doesn’t need to alter/wrap the original messageneed to alter/wrap the original message Enriching message headers (with escape edge information) not always Enriching message headers (with escape edge information) not always

desirabledesirable Original message may need to be split into multiple messages if we wrap it in a Original message may need to be split into multiple messages if we wrap it in a

new message along with the escape edge informationnew message along with the escape edge information

Bridge Connecting Simple PolygonsBridge Connecting Simple Polygons

► P & Q P & Q are two simple, disjoint polygonsare two simple, disjoint polygons

► Bridge (Bridge (p, qp, q), with ), with p p єє ρρ ((PP), ), qq єє ρρ ((QQ)) ρρ () defines the region enclosed by the boundary of the polygon() defines the region enclosed by the boundary of the polygon

► Weight of the bridge (Weight of the bridge (p,qp,q)) is:is: w w ((p,qp,q) = ) = gdgd((p, Pp, P) + ) + dd((p,qp,q) + ) + gdgd((q, Qq, Q))

gdgd((x, Xx, X): Geodesic distance between ): Geodesic distance between x x and its geodesic furthest and its geodesic furthest neighbor in neighbor in XX

dd((a,ba,b): Euclidean distance between points ): Euclidean distance between points aa and and bb

► Problem is to find a bridge connecting Problem is to find a bridge connecting P P and and Q Q which has which has minimum weightminimum weight

Bridge IllustrationBridge Illustration

q’p’

qp

QP

w(p,q) = d(p,q) + gd(p,p’) + gd(q,q’)

gd(p,P) = gd(p,p’)gd(q,Q) = gd(q,q’)

Bridge PropertiesBridge Properties

P

y

x

y

z

Q

w(opt visible bridge) ~ 2x + 2y

x >> y >> z

w(opt bridge) ~ x + 2y

Opt bridge’s end points may not be mutually visible: a restriction imposed/assumed in earlier results on the bridge problem

Opt Bridge has End Points on the Polygon BoundariesOpt Bridge has End Points on the Polygon Boundaries

qp

Q

Pq’

r’r

gd(q,Q) = gd(q,r)gd(q’,Q) = gd(q’,r’)

gd(q’,r’) ≤ d(q’,q) + gd(q,r’) ≤ d(q’,q) + gd(q,r) gd(q’,Q) ≤ d(q’,q) + gd(q,Q)

w(p,q) = gd(p,P) + d(p,q) + gd(q,Q)w(p,q’) = gd(p,P) + d(p,q’) + gd(q’,Q) ≤ gd(p,P) + d(p,q’) + d(q’,q) + gd(q,Q) = gd(p,P) + d(p,q) + gd(q,Q) w(p,q’) ≤ w(p,q)

OO((n log nn log n)) Algorithm for Optimal Algorithm for Optimal Vertex BridgeVertex Bridge

► Vertex bridge is between the vertices of the 2 polygonsVertex bridge is between the vertices of the 2 polygons

► Additively weighted nearest-point Voronoi diagramAdditively weighted nearest-point Voronoi diagram Each Voronoi point Each Voronoi point u u has an associated weight has an associated weight wwvv

Query for point Query for point p p returns a point returns a point v v such thatsuch that

dd((p, vp, v)) + w + wvv = MIN = MIN u u єє V V {{dd((p,up,u)) + w + wuu}} Can be built in Can be built in OO((n log nn log n) time [Aurenhammer-Imai ’88]) time [Aurenhammer-Imai ’88] Query can be answered in Query can be answered in OO((log nlog n) time) time

► Geodesic furthest neighbors of all vertices of a simple polygon Geodesic furthest neighbors of all vertices of a simple polygon can be found in can be found in OO((n log nn log n) time [Suri ’89]) time [Suri ’89]

Optimal Vertex Bridge (Contd.)Optimal Vertex Bridge (Contd.)

► For each vertex For each vertex q q єє Q Q, assign weight , assign weight wwqq = = gdgd((q, Qq, Q)) OO((n log nn log n) total time) total time

► For each vertex For each vertex p p єє P P, find the vertex , find the vertex q q єє Q Q with minimum with minimum dd((p, qp, q)) + w + wqq This would be the best vertex bridge with This would be the best vertex bridge with p p as one end pointas one end point Each query in Each query in OO((log nlog n) time) time

► Check all vertices of Check all vertices of P P for the optimal vertex bridgefor the optimal vertex bridge

► Total time Total time OO((n log nn log n))

Approximately Optimal BridgeApproximately Optimal Bridge

► Divide each edge into Divide each edge into k k uniform segmentsuniform segments Run the vertex bridge algorithm: Run the vertex bridge algorithm: OO((kn log knkn log kn) time) time Approximation ratio: Approximation ratio: 1 + 2/k 1 + 2/k

qa

c

p

p’

a’gd(p,P) = gd(p,p’) = xgd(a,P) = gd(a,a’)gd(q,Q) = y

d(a,p) = gd(a,p) ≤ xgd(a,P) = gd(a, a’) ≤ d(a,p) + gd(p,a’) ≤ 2x

Analysis can be extended to prove the ratio of 1 + 2/k

QP

w(a,c) = gd(a,P) + d(a,c) + gd(c,Q) ≤ 2x + (x + d(p,q) + y) + 2y ≤ 3 (x + d(p, q) + y)

d(a,c) ≤ d(a,p) + d(p,q) + d(q,c) ≤ x + d(p,q) + y

x

Optimal BridgeOptimal Bridge

► We narrow the set of points that can support an We narrow the set of points that can support an optimal bridge to optimal bridge to OO((nn22) ) anchors anchors on each polygon’s on each polygon’s boundaryboundary

► These These OO((nn22) anchors can be found in ) anchors can be found in OO((nn2 2 log nlog n) time) time

► The optimal vertex bridge algorithm takes an The optimal vertex bridge algorithm takes an additional additional OO((nn22 log nlog n) time for finding the bridge ) time for finding the bridge the polygons can be considered to have the polygons can be considered to have OO((nn22) vertices each) vertices each

Open Problems Related to BridgesOpen Problems Related to Bridges

►Faster algorithm for the optimal bridge and Faster algorithm for the optimal bridge and optimal vertex bridge connecting optimal vertex bridge connecting simple simple polygonspolygons

►What if the bridge itself is geodesic (instead of What if the bridge itself is geodesic (instead of Euclidean)?Euclidean)? Exact algorithm?Exact algorithm? Approximation schemes?Approximation schemes?

Thank YouThank You

SLFR => RE-MSTSLFR => RE-MST

► RE-MST:RE-MST: For each edge of the MST, find the least cost edge of For each edge of the MST, find the least cost edge of G G across across

the cut induced by deleting the edgethe cut induced by deleting the edge

► Has been exhaustively studied as the Has been exhaustively studied as the MST sensitivity MST sensitivity problemproblem Efficient algorithms knownEfficient algorithms known

► OO((m m αα((m,nm,n)))) for general graphsfor general graphs► Linear time for planar graphsLinear time for planar graphs

► SLFR and the replacement paths problems can be reduced to SLFR and the replacement paths problems can be reduced to the RE-MST problem in the RE-MST problem in OO((TTmstmst((m,nm,n)) + T + Tssspsssp((m,nm,n)) time)) time Reduced graph has Reduced graph has OO((nn) nodes and ) nodes and OO((2n2n) edges) edges Linear time for planar graphsLinear time for planar graphs OO((m + n m + n αα((2n,n2n,n)) for integer edge weight graphs)) for integer edge weight graphs