# Improved Shortest Path Algorithms for Nearly Acyclic Directed Graphs - PowerPoint PPT Presentation

1 / 16

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?

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

Improved Shortest Path Algorithms for Nearly Acyclic Directed Graphs

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

## Improved Shortest Path Algorithms for Nearly Acyclic Directed Graphs

L. Tian and T. Takaoka

University of Canterbury

New Zealand

2007

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

### 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

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

### 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);

• }

### 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;

• }

• }

### 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);

• }

### 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.

### 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});

AC2

AC4

AC1

AC5

AC3

SC1

SC2

### Hierarchical Approach

• This approach is based on modifications of the sc-component and 1-dominator approaches.

### 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

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. }

### 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

### 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. }

### 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. }

### 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);

• }

### 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)?