Doorzoeken van grafen Algoritmiek

Algoritmiek: Divide & Conquer2 Vandaag Methoden om door grafen te wandelen –Depth First Search –Breadth First Search –Gerichte Acyclische Grafen en topologische sorteringen

Algoritmiek: Divide & Conquer3 Doolhof start eind

Algoritmiek: Divide & Conquer4 Depth First Search Methode om systematisch alle knopen (en eventueel ook alle kanten) van een graaf te bekijken Als in doolhof: –Ga steeds verder waar je laatst was, tot je niet meer verder kan, ga dan terug tot het laatste punt waar je nog een andere kant op kan.

Algoritmiek: Divide & Conquer5 DFS op ongerichte samenhangende grafen Begin in een willekeurige knoop v Elke knoop heeft variable bezocht, die aangeeft of we al eerder in die knoop geweest zijn. Initieel zetten we voor elke v: bezocht(v) = false. Wanneer we een knoop bezoeken wordt bezocht op true gezet voor die knoop.

Algoritmiek: Divide & Conquer6 DFS Procedure dfs(v) –bezocht (v) = true –for all w grenzend aan v do if (bezocht(w) == false ) then dfs(w) recursie

DFS zonder recursie Procedure dfs-nr(v) –Maak lege stack S; –Voor alle knopen v, zet bezocht(v) = false; –Push(S,v) –while (not(emptystack(S))) do x = pop(S); bezocht(v) = true; for all w grenzend aan v do if (bezocht(w) == false ) then push(S,w) Algoritmiek: Divide & Conquer7

8 h a d e i b c f g

9 h a d e i b c f g

10 Als G niet samenhangend is Hoofdloop, initialiseert en begint 1 keer per samenhangende component Procedure dfSearch (graaf G) –for all v do bezocht(v) = false –for all v do if (bezocht(v) == false) then dfs(v) Initialisatie, net als bij samenhangende grafen Initialisatie, net als bij samenhangende grafen Een keer per samenhangende component Een keer per samenhangende component

Algoritmiek: Divide & Conquer11 Samenhangende componenten Een samenhangende component van een graaf G is een maximale samenhangende deelgraaf van G. G

Algoritmiek: Divide & Conquer12 DFS en samenhangende componenten DFS is eenvoudig te gebruiken om een gegeven graaf te splitsen in samenhangende componenten. Nuttig o.a., voor divide & conquer preprocessing: –Veel graafproblemen kunnen opgelost worden door oplossingen voor samenhangende componenten samen te voegen.

Algoritmiek: Divide & Conquer13 Een eigenschap van DFS DFS bouwt een boom op. Als G ongericht, dan zijn er twee soorten kanten in G: –Kanten in de DFS- boom: tree-edges –Kanten tussen knoop en voorouder in DFS boom: backedges

Algoritmiek: Divide & Conquer14 Articulatiepunten Een knoop v is articulatiepunt, als de samenhangende component die v bevat niet langer samenhangend is als v en zijn aangrenzende kanten verwijderd worden.

Algoritmiek: Divide & Conquer15 Dubbelsamenhangende grafen Een graaf G is dubbelsamenhangend (biconnected) als –G is samenhangend –G heeft geen articulatiepunten

Algoritmiek: Divide & Conquer16 Toepassingen van dubbelsamenhangendheid Betrouwbaarheid van netwerken Preprocessing (divide&conquer) door splitsen in dubbelsamenhangende componenten.

Algoritmiek: Divide & Conquer17 Hoe vinden we de articulatiepunten? (1) De wortel r van de DFS-boom is een articulatiepunt als r minstens 2 kinderen in de boom heeft Er zijn geen kanten tussen de verschillende deelbomen onder r Er zijn geen kanten tussen de verschillende deelbomen onder r

Algoritmiek: Divide & Conquer18 Hoe vinden we de articulatiepunten? (2) We nummeren de knopen in volgorde dat ze bezocht worden. Initieel: pnum = 1 Procedure dfs(v) –bezocht (v) = true; –prenum(v) = pnum; pnum ++; –for all w grenzend aan v do if (bezocht(w) == false ) then dfs(w) prenum geeft preorder nummering van de DFS-boom prenum geeft preorder nummering van de DFS-boom

Algoritmiek: Divide & Conquer19 Vinden van articulatiepunten (3) Bepaal voor elke knoop v een getal highest(v), wat het nummer van de hoogste voorouder van v die bereikt kan worden met een pad van eerst 0 of meer tree-edges omlaag, en dan 0 of 1 back-edge omhoog highest is dus een zo laag mogelijk nummer van pnum highest is dus een zo laag mogelijk nummer van pnum Kan in O(n+a) tijd Kan in O(n+a) tijd

Algoritmiek: Divide & Conquer20 Bepalen van highest Ga door T van beneden naar boven (postorder). highest(v) is het minimum van –prenum(v) –prenum(w) over alle backedges (v,w) –highest(x) over alle kinderen x van v in T Werkt in O(n+a) tijd Werkt in O(n+a) tijd

Algoritmiek: Divide & Conquer21 Vinden van articulatiepunten (4) Stelling. Stel v is niet de wortel van de DFSboom. v is een articulatiepunt, dan en slechts dan als v een kind w in de DFSboom heeft met highest(w)  prenum(v)

Algoritmiek: Divide & Conquer22 Algoritme voor vinden articulatiepunten Doe DFS, en bereken DFS-boom en waardes prenum Bereken waardes highest Doorloop DFSboom, en test voor elke knoop v of het een articulatiepunt is –Wortel: kijk of meerdere kinderen –Niet wortel: kijk of kind x bestaat met highest(x)  prenum(v) Werkt in O(n+a) tijd Werkt in O(n+a) tijd

Algoritmiek: Divide & Conquer23 DFS op gerichte grafen Procedure dfs(v) –bezocht (v) = true –for all arcs (v,w) –do if (bezocht(w) == false ) then dfs(w) Vier types pijlen: Tree-arcs Back-arcs Cross-arcs Forward-arcs Vier types pijlen: Tree-arcs Back-arcs Cross-arcs Forward-arcs O(n+a) tijd

Algoritmiek: Divide & Conquer24 Strongly connected components Gerichte graaf G is sterk samenhangend als –Er tussen van elke knoop naar elke andere knoop een pad is (en terug) Sterk samenhangende component: –Maximale deelgraaf die sterk samenhangend is Er is een O(n+a) algoritme dat –Test of een gegeven gerichte graaf sterk samenhangend is –Een gegeven gerichte graaf splitst in sterk samenhangende componenten. Werkcollegeopgave!

Algoritmiek: Divide & Conquer25 Gerichte acyclische grafen Een gerichte graaf is acyclisch als het geen cycle bevat. Toepassingen o.a.: Representatie van partiele ordeningen Afhankelijkheden van scheduling van taken Spreadsheet

Algoritmiek: Divide & Conquer26

Algoritmiek: Divide & Conquer27 Topologische sortering Een nummering van de knopen 1, …, n, zodat voor elke pijl (v,w) in A: –nr(v) < nr(w) Stelling. G is acyclisch, d.e.s.d. als G een topologische sortering heeft –  : stel wel een cycle. Kijk naar de nummers als je langs de cycle gaat … –  : constructie … (2 verschillende manieren)

Algoritmiek: Divide & Conquer28 Vinden van topologische sortering by g.a.g. (Algoritme 1) Verandering van DFS: Initieel: teller = n Procedure dfs(v) –bezocht (v) = true –for all arcs (v,w) –do if (bezocht(w) == false ) then dfs(w) –nb(v) = teller; teller -- ; Er zijn geen backedges. Er zijn geen backedges.

Algoritmiek: Divide & Conquer29 Vinden van topologische sortering (Algoritme 2) Als G acyclisch is, dan heeft G een knoop zonder inkomende pijlen. –(Want anders …) Mogelijk algoritme teller = 1; While G heeft nog ongenummerde knopen do neem knoop v zonder inkomende pijlen vanuit andere ongenummerde knopen nb(v) = teller; teller ++;

Algoritmiek: Divide & Conquer30 Implementatie algoritme 2 Elke knoop heeft variable unnumin(v): geeft het aantal pijlen naar v vanuit ongenummerde knopen. Verzameling B van knopen met unnumin 0. Initialiseer: For all v do unnumin(v) = ingraad van v. if (unnumin(v) == 0 ) then zet v in B. teller = 1;

Algoritmiek: Divide & Conquer31 Vervolg implementatie While B niet leeg do haal knoop v uit B; nb(v) = teller; teller++; for all (v,w) do unnumin(w) --; if (unnumin(w) == 0 ) then zet w in B. Als we niet alle knopen hebben genummerd als we klaar zijn, dan had de graaf een cycle. Als we wel alle knopen hebben genummerd, dan is de nummering een topologische sortering. O(n+a) tijd

Algoritmiek: Divide & Conquer32 Samenvatting DFS Gaat verder van laatst bezochte knoop waar iets nieuws te ontdekken is Kan gebruikt worden om graaf te splitsen in –Samenhangende componenten (ongericht) –Dubbelsamenhangende componenten (ongericht) –Sterk samenhangende componenten (gericht) Kan gebruikt worden om te testen of gerichte graaf acyclisch is, en zo ja, topologische sortering te geven –Ook een ander algoritme voor top. sort., zonder DFS

Algoritmiek: Divide & Conquer33 Breadth First Search Graaf doorzoeken als een olievlek Waar DFS een stack gebruikt (bijv. door de recursie) gebruikt BFS een queue Kan ook gebruikt worden voor vinden van samenhangende componenten Voor bepalen van afstanden als alle kanten/pijlen dezelfde lengte hebben

Algoritmiek: Divide & Conquer34 Pseudocode voor BFS Procedure BFS(v) Q = lege queue; bezocht[v] = true; Zet v op Q. while Q is niet leeg do haal eerste element x uit Q for each w grenzend aan x do if (bezocht[w] == false) then bezocht[w] = true; zet w op Q. O(n+a) tijd Procedure BFSearch(G) For all v: do bezocht[v] = false; For all v: do if (not bezocht[v]) then BFS(v) Procedure BFSearch(G) For all v: do bezocht[v] = false; For all v: do if (not bezocht[v]) then BFS(v) Dezelfde soort code als voor DFSearch Dezelfde soort code als voor DFSearch

Algoritmiek: Divide & Conquer35 Gerichte grafen: net zo Procedure BFS(v) Q = lege queue; bezocht[v] = true; Zet v op Q. while Q is niet leeg do haal eerste element x uit Q for each (x,w) in A do if (bezocht[w] == false) then bezocht[w] = true; zet w op Q.

Algoritmiek: Divide & Conquer36 h a d e i b c f g

Algoritmiek: Divide & Conquer37 BFS bezoekt knopen in volgorde afstand tot startknoop h a d e i b c f g Alle knopen met een kortste pad naar v met i knopen worden bezocht voor de knopen met een kortste pad met i+1 knopen naar v

Algoritmiek: Divide & Conquer38 h a d e i b c f g

Algoritmiek: Divide & Conquer39 Kortste paden probleem als alle kanten / pijlen lengte 1 hebben Definieer de afstand in G van s naar t als het minimum aantal kanten op een pad van s naar t. BFS kan gebruikt worden om deze afstanden (single source) uit te rekenen

Algoritmiek: Divide & Conquer40 BFS met afstanden Procedure BFS(v) Q = lege queue; bezocht[v] = true; d[v] = 0; Zet v op Q. while Q is niet leeg do haal eerste element x uit Q for each w grenzend aan x (elke pijl (x,w) ) do if (bezocht[w] == false) then bezocht[w] = true; d[w] = d[x] + 1; zet w op Q.

Algoritmiek: Divide & Conquer41 Correctheid afstanden Voor elke w: d[w] is minstens de afstand van v naar w –Met inductie: er is een pad van v naar w met d[w] kanten. Voor elke w: d[w] is hooguit de afstand van v naar w –Kijk naar een kortste pad van v naar w. Laat v i de i de knoop op dit pad zijn. –Met inductie: d[v i ]  i.

Algoritmiek: Divide & Conquer42 Concrete en impliciete grafen Alle behandelde algoritmen kosten O(n+a) tijd als we de graaf met de adjacency list representatie gekregen hebben. Algoritmen werken ook voor grafen die we impliciet hebben gekregen: –Mechanisme dat van een gegeven knoop vertelt welke buren het heeft –Omdat grafen heel (soms zelfs oneindig) groot kunnen worden slaan we de graaf niet geheel op. Toepassingen: game graphs; optimization problems; …

Algoritmiek: Divide & Conquer43 Conclusie DFS Samenhangen: samenhangende componenten; sterk samenhangend; dubbel samenhangend Acyclische grafen en topologisch sorteren BFS