Grafen en netwerken I Datastructuren en doorzoeken

Grafen en netwerken I Datastructuren en doorzoeken
Algoritmiek

Algoritmiek: Divide & Conquer
1 Inleiding Algoritmiek: Divide & Conquer

Netwerken Veel toepassingen, bijvoorbeeld: Sociale netwerken, electrische netwerken, wegennetwerken, communicatie netwerken, … Control flow graaf van imperatief programma, model van combinatorisch spel, model van bedrijfsstructuur, etc. Worden gemodelleerd met behulp van een graaf Algoritmiek: Divide & Conquer

Ongerichte Grafen Ongerichte graaf 𝐺=(𝑉,𝐸): 𝑉 eindige verzameling (knopen, vertices, nodes), elk element van 𝐸 is een verzameling van 2 elementen uit 𝑉 (kanten, edges) Algoritmiek: Divide & Conquer

Gerichte graaf Gerichte graaf G=(V,A): V eindige verzameling (knopen, vertices, nodes), elk element van A een geordend paar elementen uit V (pijlen, gerichte kanten, arcs, directed edges) staart, tail kop head Algoritmiek: Divide & Conquer

Start grafentheorie: Euler
Bruggen van Königsberg (Koningsbergen, tegenwoordig Kaliningrad) Algoritmiek: Divide & Conquer

Veluwe zwerfpad Een wandelpad dat gebruik maakt van het principe van een Eulertour Algoritmiek: Divide & Conquer

Een paar colleges over grafen
Wat centrale graaf-algoritmen Ook vaak gebruikt als subroutine in grotere algoritmen Maar eerst: Hoe sla je een graaf op? (Datastructuren voor grafen) Hoe doorzoek je een graaf? (BFS en DFS) Algoritmiek: Divide & Conquer

Notaties 𝑛: aantal knopen van graaf 𝑚: aantal kanten van ongerichte graaf (we gebruiken hier soms ook 𝑎 voor) 𝑎: aantal pijlen van gerichte graaf (literatuur gebruikt hier ook vaak 𝑚 en wij ook) Algoritmiek: Divide & Conquer

Datastructuren voor grafen
2 Datastructuren voor grafen Algoritmiek: Divide & Conquer

Taken Tel of enumereer alle knopen of kanten in graaf
Tel of enumereer alle buren van een knoop of alle incidente kanten (ingaande/uitgaande pijlen) Test of er kant tussen twee knopen is Toevoegen van kanten en knopen Verwijderen van kanten en knopen Algoritmiek

Oplossing 1: lijsten Lijst van knopen en lijst van kanten
Alle knopen of kanten tellen/enumereren is snel Rest is traag: 𝑂(𝑎) per operatie Hoe vind ik een kant tussen 2 knopen in de lijst? Hele lijst doorzoeken Hoe vind ik een incidente kant? Hele lijst doorzoeken Voordeel: 𝑂(𝑛+𝑎) ruimte Algoritmiek

Oplossing 2: adjacency list
Lijst van knopen Voor iedere knoop: lijst van incidente kanten of van buren (ingaande/uitgaande pijlen/buren) 1 2 𝑣1 𝑣2 𝑣3 𝑣4 𝑣5 𝑣6 3 𝑎12 𝑎12 a23 𝑎34 𝑎45 𝑎56 Lijst: array of linked list 4 𝑎23 𝑎34 𝑎45 𝑎56 5 6 Algoritmiek

Oplossing 2: adjacency list
Lijst van knopen Voor iedere knoop: lijst van incidente kanten of van buren (ingaande/uitgaande pijlen/buren) 1 2 𝑣1 𝑣2 𝑣3 𝑣4 𝑣5 𝑣6 𝑣2 𝑣1 𝑣3 𝑣5 𝑣4 𝑣6 3 Lijst: array of linked list 4 5 6 Algoritmiek

Adjacency list: implementatie (1)
Alle knopen of kanten tellen/enumereren is snel Alle buren van een knoop of alle incidente kanten (ingaande/uitgaande pijlen) enumeren is snel Testen of er een kant tussen 𝑢,𝑣 is: traag Kijk naar lijst met buren/incidente kanten van 𝑢 of 𝑣 erin voorkomt Θ(maximum graad) 𝑂(log maximum graad) als knopen gesorteerd en in array Lijst: array of linked list Algoritmiek

Adjacency list: implementatie (2)
Toevoegen: 𝑂(1) tijd Verwijderen: zelfde tijd als om kant tussen u,v te vinden Nog steeds 𝑂(𝑛+𝑎) ruimte Lijst per knoop kan een linked list of een array/vector zijn Algoritmiek

Oplossing 3: adjacency matrix
𝑛 bij 𝑛 matrix: elementen 0 of 1 (0,1,−1) element (𝑖,𝑗) is 1 dan en slechts dan als er een kant is tussen knoop 𝑖 en knoop 𝑗 Gerichte grafen: gebruik 1,−1 voor richting 1 2 1 2 3 4 5 6 3 4 5 6 Algoritmiek

Oplossing 3: adjacency matrix
Testen er een kant tussen twee knopen is: 𝑂(1) Bekijk juiste element in matrix Alle knopen tellen/enumereren is snel Rest is traag Bijv.: incidente kanten tellen kost Θ(𝑛) Hele rij moet bekeken worden Kant toevoegen/verwijderen is snel: 𝑂(1) Nadeel: Θ(𝑛2) bits ruimte Algoritmiek

Afweging (1) Adjacency matrix Adjacency list
Eenvoudig te implementeren 𝑂(𝑛2) bits Kan nog efficiënt zijn bij kleine grafen Adjacency list Meest ruimte-efficiënt, vooral voor grote of ijle grafen (𝑂 𝑛+𝑎 log 𝑛 bits) Meeste operaties zeer snel Meest gebruikt in praktijk Algoritmiek

Afweging (2) Kijk goed naar welke operaties je nodig hebt in je algoritme Is je graaf ijl? Is geheugenruimte een probleem? Meest gebruikt: adjacency list Combinatie ook mogelijk, maar lastig te implementeren Gewichten: in beide datastructuren goed op te slaan Pas op: gewicht is misschien op 2 plekken opgeslagen Algoritmiek

Incidentie matrix 𝑛 bij 𝑎 matrix: ieder element 0 of 1 (0,1,−1)
Element (𝑖,𝑗) is 1 dan en slechts dan als kant j incident is op knoop 𝑖 Gerichte grafen: gebruik −1, 1 Traag en ruimteverkwistend Maar wel handig voor sommige wiskundige operaties Algoritmiek

Doorzoeken van grafen: DFS
3 Doorzoeken van grafen: DFS Algoritmiek: Divide & Conquer

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

Doolhof eind start Algoritmiek: Divide & Conquer

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 & Conquer

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

DFS Procedure dfs(𝑣) bezocht (𝑣) = true for all 𝑤 grenzend aan 𝑣 do if (bezocht(𝑤) == false) then dfs(𝑤) Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. recursie Algoritmiek: Divide & Conquer

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) Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. Algoritmiek: Divide & Conquer

f h b i c Algoritmiek: Divide & Conquer

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 Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. Een keer per samenhangende component Algoritmiek: Divide & Conquer

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

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. Een illustratief voorbeeld van zo’n graafprobleem is het kleuringsprobleem: geef elke knoop een kleur uit een gegeven verzameling, zodat aangrenzende knopen verschillende kleuren hebben. Algoritmiek: Divide & Conquer

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: boomkanten, tree-edges Kanten tussen knoop en voorouder in DFS boom: terugkanten, backedges 1 2 5 3 Er kan bijvoorbeeld geen kant tussen 4 en 6 lopen: want dan zou 6 vanuit 4 ontdekt zijn. 6 7 4 Algoritmiek: Divide & Conquer

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

4 Doorzoeken van grafen:
Articulatiepunten, dubbelsamenhangende componenenten, etc. Algoritmiek: Divide & Conquer

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

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

Hoe vinden we de articulatiepunten? (1)
De wortel 𝑟 van de DFS-boom is een articulatiepunt dan en slechts dan als 𝑟 minstens 2 kinderen in de boom heeft. 1 4 2 5 6 3 Bewijs: als r 2 kinderen heeft gaat elk pad tussen die kinderen via r. Als r 1 kind heeft, dan is G-r samenhangend, want de rest zit in een boom Er zijn geen kanten tussen de verschillende deelbomen onder 𝑟 Algoritmiek: Divide & Conquer

Hoe vinden we de articulatiepunten? (2)
We nummeren de knopen in volgorde dat ze bezocht worden. Initieel: pnum = 1 Procedure dfs(𝑣) bezocht (𝑣) = true; prenum(𝑣) = pnum; pnum ++; for all w grenzend aan 𝑣 do if (bezocht(𝑤) == false) then dfs(𝑤) prenum geeft preorder nummering van de DFS-boom Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. Algoritmiek: Divide & Conquer

Vinden van articulatiepunten (3)
Kan in 𝑂(𝑛+𝑎) tijd Bepaal voor elke knoop v een getal highest(𝑣), wat het nummer van de hoogste voorouder van 𝑣 die bereikt kan worden met een pad van eerst 0 of meer tree-edges omlaag, en dan 0 of 1 back-edge omhoog. 1 1 1 2 5 3 2 1 2 1 6 7 4 highest is dus een zo laag mogelijk nummer van pnum 6 Algoritmiek: Divide & Conquer

Bepalen van highest Werkt in 𝑂(𝑛+𝑎) tijd Ga door 𝑇 van beneden naar boven (postorder). highest(𝑣) is het minimum van prenum(𝑣) prenum(𝑤) over alle backedges (𝑣,𝑤) highest(𝑥) over alle kinderen 𝑥 van 𝑣 in 𝑇 Algoritmiek: Divide & Conquer

Vinden van articulatiepunten (4)
Stelling. Stel 𝑣 is niet de wortel van de DFSboom. v is een articulatiepunt, dan en slechts dan als 𝑣 een kind 𝑤 in de DFSboom heeft met highest(𝑤) ³ prenum(𝑣). 1 1 1 2 5 3 2 1 Uitleg op bord. Kijk naar de verschillende gevallen die zich kunnen voordoen. 2 1 6 7 4 6 Algoritmiek: Divide & Conquer

Algoritme voor vinden articulatiepunten
Werkt in 𝑂(𝑛+𝑎) tijd 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 𝑥 bestaat met highest(𝑥) ≥ prenum(𝑣) Algoritmiek: Divide & Conquer

DFS: gerichte grafen, strongly connected components
5 DFS: gerichte grafen, strongly connected components Algoritmiek: Divide & Conquer

DFS op gerichte grafen 1 Procedure dfs(𝑣) bezocht (𝑣) = true for all arcs (𝑣,𝑤) do if (bezocht(𝑤) == false) then dfs(𝑤) 2 5 6 3 7 8 4 Vier types pijlen: Tree-arcs Back-arcs Cross-arcs Forward-arcs Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. 𝑂(𝑛+𝑎) tijd Algoritmiek: Divide & Conquer

Strongly connected components
Gerichte graaf 𝐺 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 𝑂(𝑛+𝑎) algoritme dat Test of een gegeven gerichte graaf sterk samenhangend is Een gegeven gerichte graaf splitst in sterk samenhangende componenten. Dit noem ik alleen even. De werkcollegeopgave is belangrijk! Algoritmiek: Divide & Conquer

Opzet algoritme SCCs Aanpassing van DFS met start en finish-tijden Doe DFS en noteer voor elke knoop finish tijd Maak 𝐺 𝑇 : draai alle pijlen om Doe DFS op 𝐺 𝑇 met in hoofdloop knopen op volgorde dalende finishtijd Elke DFS-boom in het DFS woud is een scc! Algoritmiek: Divide & Conquer

Aanpassing DFS hoofdloop (tijd)
Procedure dfSearch (graaf G) tijd = 0; for all v do bezocht(v) = false for all v do if (bezocht(v) == false) then dfs(v) Algoritmiek: Divide & Conquer

Aanpassing DFS recursieve aanroepen (tijd)
Procedure dfs(𝑣) tijd ++; d[𝑣] = tijd; {d: discovery} bezocht (𝑣) = false; for all arcs (𝑣,𝑤) do if (bezocht(𝑤) == false) then dfs(𝑤) tijd++; f[𝑣] = tijd; {f: finish} Algoritmiek: Divide & Conquer

Algoritme om scc’s te bepalen
Doe dfSearch(G) en bepaal alle f[𝑣]-waardes Bereken de graaf 𝐺 𝑇 , die je uit G krijgt door alle pijlen om te draaien Bekijk de knopen in volgorde van dalende waardes f[𝑣]. Als een knoop v nog niet bezocht is, start een dfs uit die knoop: alle knopen die je bereikt zitten samen met 𝑣 in dezelfde scc Algoritmiek: Divide & Conquer

Opmerkingen Correctheid: zie boek Speciaal eenvoudiger geval: werkcollege Zie ook prakticumopgave Dungeon Algoritmiek: Divide & Conquer

DFS: gerichte acyclische grafen
6 DFS: gerichte acyclische grafen Algoritmiek: Divide & Conquer

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 & Conquer

Topologische sortering
Een nummering van de knopen 1, … , 𝑛, zodat voor elke pijl 𝑣,𝑤 ∈𝐴: nr(𝑣) < nr(𝑤) 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) 5 2 1 4 3 6 Algoritmiek: Divide & Conquer

Vinden van topologische sortering by g.a.g. (Algoritme 1)
Verandering van DFS: Initieel: teller = 𝑛 Procedure dfs(v) bezocht (𝑣) = true for all arcs 𝑣,𝑤 ∈𝐴 do if (bezocht(𝑤) == false) then dfs(𝑤) nb(𝑣) = teller; teller -- ; 1 6 2 3 7 5 4 Er zijn drie soorten edges, en het algoritme zorgt er precies voor dat elke soort edges goed gaat. Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. 8 Er zijn geen backedges. Algoritmiek: Divide & Conquer

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

Implementatie algoritme 2
Elke knoop heeft variable unnumin(𝑣): geeft het aantal pijlen naar v vanuit ongenummerde knopen. Verzameling 𝐵 van knopen met unnumin 0. Initialiseer: For all 𝑣∈𝑉 do unnumin(𝑣) = ingraad van 𝑣. if (unnumin(𝑣) == 0 ) then zet 𝑣 in 𝐵. teller = 1; Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. Algoritmiek: Divide & Conquer

Vervolg implementatie
While 𝐵 niet leeg do haal knoop 𝑣 uit 𝐵; nb(𝑣) = teller; teller++; for all 𝑣,𝑤 ∈𝐴 do unnumin(𝑤) --; if (unnumin(𝑤) == 0 ) then zet 𝑤 in 𝐵. 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. 𝑂(𝑛+𝑎) tijd Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. Algoritmiek: Divide & Conquer

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 & Conquer

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 & Conquer

7 BFS Algoritmiek: Divide & Conquer

Pseudocode voor BFS Procedure BFS(𝑣) 𝑄 = lege queue; bezocht[𝑣] = true; Zet 𝑣 op 𝑄. while 𝑄 is niet leeg do haal eerste element x uit 𝑄 for each 𝑤 grenzend aan 𝑥 do if (bezocht[w] == false) then bezocht[𝑤] = true; zet w op 𝑄. 𝑂(𝑛+𝑎) tijd Procedure BFSearch(𝐺) For all v: do bezocht[v] = false; For all v: do if (not bezocht[𝑣]) then BFS(𝑣) Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. Dezelfde soort code als voor DFSearch Algoritmiek: Divide & Conquer

Gerichte grafen: net zo
Procedure BFS(𝑣) 𝑄 = lege queue; bezocht[𝑣] = true; Zet 𝑣 op 𝑄. while 𝑄 is niet leeg do haal eerste element x uit 𝑄 for each 𝑥,𝑤 ∈𝐴 do if (bezocht[𝑤] == false) then bezocht[𝑤] = true; zet 𝑤 op 𝑄. Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. Algoritmiek: Divide & Conquer

f h b i Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. c Algoritmiek: Divide & Conquer

BFS bezoekt knopen in volgorde afstand tot startknoop
Alle knopen met een kortste pad naar 𝑣 met 𝑖 knopen worden bezocht voor de knopen met een kortste pad met 𝑖+1 knopen naar 𝑣 g e a d f h b i Wat is de overeenkomst tussen uien, grafen, en ogres? c Algoritmiek: Divide & Conquer

3 g e 4 a 2 d f 4 2 h 5 b 1 i 3 c Algoritmiek: Divide & Conquer

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

BFS met afstanden Procedure BFS(𝑣) 𝑄 = lege queue; bezocht[v] = true; 𝑑[𝑣] = 0; Zet 𝑣 op 𝑄. while 𝑄 is niet leeg do haal eerste element x uit 𝑄 for each 𝑤 grenzend aan 𝑥 (elke pijl (𝑥,𝑤) ) do if (bezocht[𝑤] == false) then bezocht[𝑤] = true; d[𝑤] = d[𝑥] + 1; zet 𝑤 op 𝑄. Disclaimer: pseudocode in deze slides kan fouten bevatten. Gebruik ‘m niet als startpunt voor je programma’s. Raadpleeg liever het boek. Algoritmiek: Divide & Conquer

Correctheid afstanden
Voor elke 𝑤: 𝑑[𝑤] is minstens de afstand van 𝑣 naar w Met inductie: er is een pad van 𝑣 naar 𝑤 met 𝑑[𝑤] kanten. Voor elke w: d[w] is hooguit de afstand van v naar w Kijk naar een kortste pad van 𝑣 naar 𝑤. Laat 𝑣𝑖 de 𝑖de knoop op dit pad zijn. Met inductie: 𝑑 𝑣𝑖 ≤𝑖. Algoritmiek: Divide & Conquer

Concrete en impliciete grafen
Alle behandelde algoritmen kosten 𝑂(𝑛+𝑎) 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 & Conquer

8 Conclusies Algoritmiek: Divide & Conquer

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

Grafen en netwerken I Datastructuren en doorzoeken

Verwante presentaties

Presentatie over: "Grafen en netwerken I Datastructuren en doorzoeken"— Transcript van de presentatie:

Verwante presentaties

Over het project

Feedback

Inloggen

Inloggen via een sociaal netwerk:

Grafen en netwerken I Datastructuren en doorzoeken

Verwante presentaties

Presentatie over: "Grafen en netwerken I Datastructuren en doorzoeken"— Transcript van de presentatie:

Verwante presentaties

Over het project

Feedback