1 / 16

Improved Shortest Path Algorithms for Nearly Acyclic Directed Graphs

Improved Shortest Path Algorithms for Nearly Acyclic Directed Graphs. L. Tian and T. Takaoka University of Canterbury New Zealand 2007. e 1. e 1. e 2. e 2. SC 1. SC 1. SC 2. SC 1. Introduction. What is nearly acyclic directed graphs?

reba
Télécharger la présentation

Improved Shortest Path Algorithms for Nearly Acyclic Directed Graphs

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Improved Shortest Path Algorithms for Nearly Acyclic Directed Graphs L. Tian and T. Takaoka University of Canterbury New Zealand 2007

  2. e1 e1 e2 e2 SC1 SC1 SC2 SC1 Introduction • What is nearly acyclic directed graphs? (1) Takaoka (1998) explained this using a strongly connected component (sc-component) approach, cyc(G). In this example, cyc(G) = 3

  3. Solve the SSSP problem using sc-component decomposition • Compute sc-components Vr,Vr-1, …,V1; • forv∈Vdod[v] ←∞; • d[s]←0; • fori ← r to 1 do{ • Solve the GSS for Gi; • forVj such that (Vi, Vj)∈Edo • forv∈Vi and w∈Vj such that (v, w)∈Edo • d[w] ← min{d[w], d[v] + cost(v,w)}; • } The time complexity of this algorithm is O(m + nlogk), where m is the number of edges in a graph and n is the number of vertices. K is the maximum size of sc components

  4. e1 e2 e3 AC1 AC2 Introduction (continue) (2) Saunders and Takaoka (2005) used a 1-dominator approach to explain that. The SSSP algorithm based on the approach is O(m+rlogr) where r is the number of triggers. e1 e2 e3 AC1 AC2

  5. Restricted Depth First Search for 1-dominator decomposition • functionAcyclicSetA(u){ • VertexSet A, L; • procedurerdfs(v){ • A←A + {v}; • for each w ∈ OUT(A) do{ • ifw LthenL ← L + {w}; // w is visited • inCount[w] ← inCount[w] – 1; • ifinCount[w] = 0 thenrdfs(w); // w is unlocked • } • } • A ← ; L ← {u}; • inCount[u] ← inCount[u] + 1; // prevents re-traversal of u • rdfs(u); • VertexSet B ← L–A; // boundary vertices • for each w ∈ LdoinCount[w] ← |IN(w)|; • return (A,D); • }

  6. Computing the 1-Dominator Set • for all v ∈ VdoinCount[v] ← |IN(v)|; • for all v ∈ VdovertexType[v] ←unknown; • a queue Q← {s}; • whileQ ≠ do{ • Remove the next vertex u from Q; • ifvertexType[u] = unknownthen { • (A, B) ←AcyclicSetA(u); • for each v ∈ Ado Let AC[v] refer to A; • for each v ∈ AdovertexType[v] ←nontrigger; • vertexType[u] ←trigger; • for each v ∈ Bdo • ifvertexType[v] = unknownandvQthen Add v to Q; • } • }

  7. SSSP Algorithm using Acyclic Decomposition • proceduredecreaseKey(u){ • for each v ∈ AC[u] in topological order do • for each w ∈ OUT[v] andw Sdo • d[w] ← min{d[w], d[v] + cost(v,w)}; • } • for all v ∈ Vdod[v] ←∞; • solution set S←; • insert all triggers into frontier set F; • d[s] ← 0; // s is the source vertex • ifs is not a trigger thendecreaseKey(s); • whileF is not empty do{ • find u from F with minimum key and delete u from F; • S ← {u}; • decreaseKey(u); • }

  8. Higher-Order Approach • This approach extends the technique of sc-component decomposition, denoted by cych(G). cyc1(G) cyc2(G) In the second order decomposition, it eats the black node and then decomposes the subgraph.

  9. Higher-Order SSSP Algorithm • procedureDynamic(G, SV){ • Compute hth order sc-components Vhr, Vhr-1, …,Vh1; • fori ← r to 1 do{ • forVhj such that (Vhi, Vhj)∈Ehdo • forv∈Vhi and w∈Vhj such that (v, w)∈Edo • d[w] ← min{d[w], d[v] + cost(v,w)}; • vmin ← w that gives min{d[w] | w ∈Vhi-1 }; • SV ← {vmin }; • if (|Ghi-1|>c1) and (h+1< c2) • then { h ← h+1; Dynamic(Ghi-1; SV); } • else solve the GSS for Ghi-1; • } • } • for all v ∈ Vdod[v] ← ∞; • d[s] ← 0; // s is the source vertex • Dynamic(G, {s});

  10. AC2 AC4 AC1 AC5 AC3 SC1 SC2 Hierarchical Approach • This approach is based on modifications of the sc-component and 1-dominator approaches.

  11. Hierarchical Decomposition Algorithm 1. functionHierarchySets(v0 ) { 2. procedurehdfs(v) { 3. (A, B) ← AcyclicSet(v); 4. Let AC[v] refer to A; 5. vertexType[v] ← trigger ; 6. for all u ∈ A do vertexType[u] ← non-trigger; 7. for all u ∈ Bdo 8. ifvisitNum[u] = 0 do{ 9. c ← c + 1 ; visitNum[u] ← c ; lowlink[u] ← c; 10. T ← T + {u} ; 11. hdfs(u) ; // search from unvisited v ∈ B 12. if u ∈ T thenlowlink[v] ← min(lowlink[u],lowlink[v] ); 13. elselowlink[v] ← min(lowlink[v], vsistNum[u] ); //update lowlink[v] from connected triggers 14. } 15. iflowlink[v] = visitNum[v] andv∈ T do { 16. VertexSet C ← pop up vertices from T until v; 17. p ← p + 1; // count sc-components 18. Let SC[p] refer to C; 19. } 20. } 21. VertexSet AC ← , SC ← , T ← ; 22. for all v ∈ Vdo { 23. inCount[v] ← |IN(v)|; vertexType[v] ← unknown; 24. visitNum[v] ← 0; lowlink[v] ← ; 25. } 26. p ← 0; c ← 0; 27. for all unvisitedv0 ∈ Vdo { 28. c ← c + 1; visitNum[v0] ← c; lowlink[v0 ] ← c; 29. T ← T + v0; 30. hdfs(v0 ); 31. } 32. return(AC, SC, p); 33. }

  12. 1-2-dominator sets • Difficulty on 2-dominator sets: • A 1-2-dominator set is a generalization of the 1-dominator set. u1 u1 u2 u3 u2 u3 v1 v1 Vj+1 Vj+1 v2 v2 v3 Vj+2 v3 Vj+2 vj V2j-1 vj V2j-1

  13. Restricted Depth First Search for 1-2-dominator decomposition • functionAcyclicSetA(u){ • VertexSet A, L; • procedurerdfs(v){ • A←A + {v}; • for each w ∈ OUT(A) do{ • ifw LthenL ← L + {w}; // w is visited • inCount[w] ← inCount[w] – 1; • ifinCount[w] = 0 thenrdfs(w); // w is unlocked • } • } • A ← ; L ← {u}; • inCount[u] ← inCount[u] + 1; // prevents re-traversal of u • rdfs(u); • VertexSet B ← L–A; // boundary vertices • for each w ∈ Bdo { 15.1inc(v,w) ← |IN(w)| –inCount[w]; 15.2BS[v] ← (w, inc(v,w)); 15.3 inCount[w] ← |IN(w)|; 15.4 } 16. return (A,B); 17. }

  14. 1-2-Dominator Set Algorithm 1. proceduregdfs(u1, u2, v) { 2. for all w ∈ BS[v] do { 3. inCount[w] ← inCount[w] - inc(v, w) ; 4. ifinCount[w] = 0 do { // w is unlocked 5. T1 ← T1 - {w} ; // 1-dominator set T1 6. AC[u1] ← AC[u1] + {w}; 7. AC[u2] ← AC[u2] + {w}; 8. gdfs(u1, u2 , w); 9. } 10. } 11. } /***** main program *****/ 12. Compute 1-dominator set T1 ; 13. foru1 ∈ T1do{ 14. inCount[u1] ← inCount[u1] + 1; 15. for all v ∈ BS[u1] doinCount[v] ← inCount[v] - inc(u1, v); 16 foru2 ∈ T1 - {T1} do { 17. inCount[u1] ← inCount[u2] + 1; 18. gdfs(u1, u2, u2 ); 19. } 20. T1 ← T1 - {u1} ; 21. for all v ∈ BS[u1] doinCount[v] ← |IN(v)|; 22. }

  15. SSSP Algorithm using Acyclic Decomposition • proceduredecreaseKey(u){ • for each v ∈ AC[u] in topological order do • for each w ∈ OUT[v] andw Sdo • d[w] ← min{d[w], d[v] + cost(v,w)}; • } • for all v ∈ Vdod[v] ←∞; • solution set S←; • insert all triggers into frontier set F; • d[s] ← 0; // s is the source vertex • ifs is not a trigger thendecreaseKey(s); • whileF is not empty do{ • find u from F with minimum key and delete u from F; • S ← {u}; • decreaseKey(u); • }

  16. Future research • 1-2-...-k domnator approach: Acyclic structures are dominated by up to k trigger vertices • All Pairs with 1-dominator set O(mn + r2log r) General feedback set approach for all pairs: If we have a feedback vertex set of size r, the best time is O(mn + r3). Conjecture O(mn + r2log r)?

More Related