Grafalgoritmer
Vi skal se på grafalgoritmer for: Traversering: Oppsøk alle nodene i grafen en og bare en gang, på en eller annen systematisk måte Nåbarhet: Finnes det en vei fra en node til en annen node? Korteste vei: Hvor lang er den korteste veien mellom par av noder i en vektet graf?
Traversering av grafer Traversering (kalles også søking i grafen ): Gå innom/søke opp alle noder i grafen en og bare en gang Problemer ved graftraversering: Det er ofte ingen rot eller naturlig startpunkt i en graf Grafen kan være cyklisk slik at en node oppsøkes flere ganger Grafen kan være usammenhengende eller svakt sammenhengede, slik at ikke alle noder kan nås fra en gitt node
DFS og BFS To standard rekkefølger for traversering av grafer: DFS: Dybde-først søk (Depth-First Search) BFS: Bredde-først søk (Breadth-First Search) Felles for begge traverseringsmetoder: Starter med en første node som markeres oppsøkt Går deretter videre til sist oppsøkte nodes uoppsøkte naboer, på en eller annen systematisk måte Traversering med nabomatrise er alltid O(n²)
Forskjellen på DFS og BFS Dybde-først: Går rekursivt direkte videre til første uoppsøkte node Vil gå i dybden langs veier med uoppsøkte noder Bredde-først: Lagrer uoppsøkte noder i en (FIFO) kø De uoppsøkte nodene nærmest startnoden oppsøkes først Søkingen brer seg i ringer fra utgangspunktet
Traversering: Eksempel Urettet graf, starter i node 2 Uoppsøkte naboer oppsøkes i stigende rekkefølge DFS: 2 1 0 3 4 6 5 BFS: 2 1 3 4 0 6 5
Traversering: Eksempel Rettet graf, starter i node 2 Uoppsøkte naboer oppsøkes i stigende rekkefølge DFS: 2 3 4 1 6 5 BFS: 2 3 6 4 1 5
Urettet graf, starter i node A Traversering: Eksempel Uoppsøkte naboer oppsøkes i alfabetisk rekkefølge DFS: A D M E B C F I G K J P O Q L H N BFS: A D F M B C E H Q I J L N G K P O
Animasjon av DFS og BFS
Traversering og spenn-trær * Spenn-tre: Et tre som består av alle nodene i en graf og et utvalg av kantene, slik at alle nodene er forbundet I læreboka: Algoritme for å finne spenn-treet med minst total veilengde (minimum spanning tree) i en vektet graf Kantene som følges i en traversering, vil alltid utgjøre et spenn-tre: Dybde-først: Spenn-treet blir høyt og ubalansert Bredde-først: Lavere, mer balansert spenn-tre * Engelsk: spanning tree
Spenntrær for DFS og BFS
Dybde-først søk: Algoritme DFS implementeres naturlig rekursivt: DFS(node x) { oppsøk(x) for hver node y som er nabo med x hvis y ikke er oppsøkt DFS(y) } Læreboka implementerer grafer som en generisk ADT med en ikke-rekursiv DFS-iterator som bruker en stack
Bredde-først søk: Algoritme BFS implementeres iterativt med bruk av en kø: BFS(node start) { enqueue(start) så lenge kø ikke tom { x = dequeue() oppsøk(x) for hver node y som er nabo med x hvis y ikke er oppsøkt eller ligger i kø enqueue(y) } } Læreboka implementerer en generisk BFS-iterator
Enkel implementasjon av DFS og BFS Utvider klassen enkelgraf.java med metoder for dybde-først og bredde-først traversering DFS: Rekursiv Bruker boolsk array til å merke noder som er oppsøkt BFS: Bruker lærebokas kømodul Boolsk array merker noder som er oppsøkt eller i kø Java-kode: traversergraf.java
Nåbarhet * En node er nåbar fra en annen node hvis det finnes en vei i grafen mellom de to nodene En vanlig problemstilling for grafer er å finne ut hvilke noder som er innbyrdes nåbare kan vi reise fra A til B? Bestemmelse av nåbarhet kan også brukes til å avgjøre om en graf er (sterkt eller svakt) sammenhengende *: Engelsk: Reachability
To standardproblemer for nåbarhet i grafer SSRP Single Source Reachability Problem : Finn alle noder som er nåbare fra en bestemt node APRP All-Pairs Reachability Problem Finn alle noder som kan nås fra enhver node i grafen
Single Source Reachability Problem Alle noder nåbare fra 1: 4, 5, 6 Enkel O(n²) løsning på SSRP: Gjør en dybde-først eller bredde-først traversering fra startnoden Alle noder som oppsøkes i traverseringen er nåbare
All-Pairs Reachability Problem Alle noder nåbare fra: 1: 4, 5, 6 2: 1, 3, 4, 5, 6 3: 1, 2, 4, 5, 6 4: 1, 5, 6 5: 1, 4, 6 6: 1, 4, 5
Enkel løsning av APRP Traversér grafen n ganger (med DFS eller BFS), én gang med start i hver node i grafen Denne løsningsmetoden er alltid O(n³) hvis grafen er lagret med nabomatrise Kan også brukes for å teste konnektivitet: Hvis alle traverseringene er innom alle n noder, er grafen (sterkt) sammenhengende Implementasjon: traversergraf.java
Løsningsmatrise for APRP Løsningen på APRP kan representeres som en boolsk matrise/2-d tabell A, der A[ i ] [ j ] er true hvis og bare hvis det går en vei fra node i til node j 1 2 3 4 5 6 1 T F F T T T 2 T T T T T T 3 T T T T T T 4 T F F T T T 5 T F F T T T 6 T F F T T T
Løsningsmatrise og nabomatrise Løsningsmatrisen for APRP kan betraktes som en utbygging av nabomatrisen for grafen 1 2 3 4 5 6 1 T F F F F T 2 F T T F F T 3 F T T T F T 4 T F F T T F 5 F F F T T T 6 T F F T F T Nabomatrise 1 2 3 4 5 6 1 T F F T T T 2 T T T T T T 3 T T T T T T 4 T F F T T T 5 T F F T T T 6 T F F T T T Løsningsmatrise
Warshall-algoritmen* Løser APRP ved å transformere nabomatrisen til løsningsmatrisen Bruker følgende prinsipp: Det finnes en vei fra node i til node j, hvis det finnes en vei fra node i til node k, og fra node k til node j Algoritmen bygger stegvis ut nabomatrisen med alle mulige veier mellom alle par av noder Etter n steg vil garantert alle veier i hele grafen ligge lagret i løsningsmatrisen *: Warshall, Stephen: "A theorem on Boolean matrices", Journal of the ACM, 1962
Warshall: Stegvis løsning Steg 1: Finn alle veier av lengde 2 Steg 2: Finn alle veier av lengde 3... Steg n: Alle veier funnet 1 2 3 4 5 6 1 T F F F F T 2 F T T F F T 3 F T T T F T 4 T F F T T F 5 F F F T T T 6 T F F T F T Nabomatrise 1 2 3 4 5 6 1 T F F T T T 2 T T T T T T 3 T T T T T T 4 T F F T T T 5 T F F T T T 6 T F F T T T Løsningsmatrise etter to steg
Warshall-algoritmen: Effektivitet og implementasjon Programmeres enkelt med tre løkker: Ytre løkke går n ganger, i hvert steg finnes alle veier av lengde 1, 2, 3,... To indre løkker som går gjennom hele nabomatrisen og kobler node i og j hvis begge har en vei til node k Warshall er alltid O(n³) for graf lagret i nabomatrise Enkel implementasjon: warshall.java
Uvektet, rettet graf for testing av APRP-metoder Fil: graf_13.txt
Korteste-vei problemer for vektede grafer * Single Source Shortest Path Problem Finn lengden av korteste vei fra én bestemt node til alle andre noder i grafen All-Pairs Shortest Path Problem Finn lengden av korteste vei fra alle noder til alle andre noder i grafen *: For uvektede grafer finnes korteste veier enkelt med bredde-først søk
Anvendelser av korteste-vei algoritmer Ruteplanlegging GPS Google Maps Travelling Salesman's Problem Flåtestyring Ulike typer optimaliseringer Og veldig mye mer...
Vektede grafer for korteste-vei problemer Representerer grafen som en nabomatrise med kantlengder Hvis det ikke går en kant mellom to noder, legger vi inn en uendelig stor kantlengde 0 1 2 3 4 5 6 0 0 2 1 1 0 3 10 2 4 0 5 3 2 0 2 8 4 4 0 6 5 0 6 1 0
All-Pairs Shortest Path 0 1 2 3 4 5 6 0 0 2 1 1 0 3 10 2 4 0 5 Finn lengden av korteste vei mellom alle par av noder Kan løses ved å transformere nabomatrisen til en løsningsmatrise med korteste veilengder 3 2 0 2 8 4 4 0 6 5 0 6 1 0 0 1 2 3 4 5 6 0 0 2 3 1 3 6 5 1 9 0 5 3 5 8 7 2 4 6 0 5 7 5 9 3 6 8 2 0 2 5 4 4 0 7 6 5 0 6 1 0
Floyds algoritme * Starter med nabomatrisen, bygger opp løsningsmatrisen steg for steg Samme prinsipp som i Warshall-algoritmen: Det finnes en vei fra node i til node j, hvis det finnes en vei fra node i til node k, og fra node k til node j Sjekker alle mulige veier, tar hele tiden vare på den korteste veien som til nå er funnet mellom to noder I hvert steg øker antall noder langs veiene med 1 Etter n steg vil garantert lengden til alle de korteste veiene i hele grafen ligge lagret i løsningsmatrisen *: Floyd, Robert W.: "Algorithm 97: Shortest Path", Communications of the ACM, 1962
Floyd: Stegvis løsning Steg 1: Finn alle korteste veier med maks. 3 noder Steg 2: Finn alle korteste veier med maks 4 noder Steg n 2: Alle korteste veier funnet 0 1 2 3 4 5 6 0 0 2 1 1 0 3 10 2 4 0 5 3 2 0 2 8 4 4 0 6 5 0 6 1 0 0 1 2 3 4 5 6 0 0 2 3 1 3 6 5 1 9 0 5 3 5 8 7 2 4 6 0 5 7 5 9 3 6 8 2 0 2 5 4 4 0 7 6 5 0 6 1 0
Floyds algoritme: Effektivitet og implementasjon Programmeres enkelt med tre løkker, på samme måte som Warshall-algoritmen: Ytre løkke går n 2 ganger, i hvert steg finnes alle de korteste veiene med 3, 4, 5, noder To indre løkker som går gjennom hele nabomatrisen og kobler node i og j hvis begge har en vei til node k Floyd er alltid O(n³) for graf lagret i nabomatrise Enkel implementasjon: floyd.java
Single Source Shortest Path Finn lengden av korteste vei fra én bestemt node til alle andre noder i grafen Kan løses med Dijkstras algoritme * Standard algoritme i mange systemer, f.eks. GPS-enheter, Google Maps, flybillettbestilling, ruting av av data på internett... *: Dijkstra, Edsger. W.: "A note on two problems in connexion with graphs", Numerische Mathematik 1, 1959
Dijkstras algoritme Anvendes på en vektet graf med n noder Starter i en node S, finner korteste avstand fra S til alle andre noder Bruker maksimalt n 1 steg, i hvert steg finner vi den korteste avstanden fra S til én ny node i grafen Ligner mye på et bredde-først søk Basert på følgende prinsipp: Den korteste veien fra S til en ny node må gå langs en av de korteste veiene til en av den nye nodens naboer
Dijkstra: Ekstra datastruktur En boolsk array funnet av lengde n: Alle elementer er intitielt lik false Brukes til å merke nodene som vi allerede har funnet korteste vei til En array avstand med n veilengder: Lagrer den hittil korteste veien som vi til nå har sett fra startnoden S til alle andre noder i grafen Alle elementer er lik uendelig til å begynne med, unntatt for startnoden der korteste vei settes lik 0 Løsningen ligger i arrayen avstand når algoritmen er ferdig
s=0 y=1 t=2 x=3 z=4 funnet = { true, true, false, false, false } avstand = { 0, 5, 10,, }
Dijkstras algoritme: Animasjon (finner korteste vei fra a til b)
Dijkstras algoritme: Eksempel
Dijkstra: Algoritme funnet[i] = false, i = 0, 1, 2,..., n 1 avstand[i] =, i = 0, 1, 2,..., n 1 avstand[s] = 0 denne = S antall = 0 For (alle naboer i til denne, der funnet[i] == false) { l = avstand[denne] + kantlengde[denne][i] Hvis (l < avstand[i]) avstand[i] = l funnet[denne] = true antall++ Hvis antall == n: Avslutt denne = (noden som har minst verdi av avstand og der funnet[denne] == false) }
Dijkstras algoritme: Animasjon Kantene i figuren er tegnet like lange som vekten/kantlengden
Dijkstra: Effektivitet og implementasjon Er O(n2 ) i originalutgaven, for en graf med n noder Blir O(n log n) med smartere koding (øvingsoppgave): Bruk en min-heap for å lagre avstandene Søking etter noden med minst avstand blir da O(log n) Er litt fiklete fordi vi må justere heapen hver gang avstander oppdateres i grafen Dijkstra kan også løse all-pairs shortest path: Start algoritmen én gang fra hver node i grafen Enkel O(n 2 ) implementasjon: dijkstra.java
Dijkstra: Lagring av korteste veier Et problem med denne versjonen av Dijkstra er at det bare er lengden på de korteste veiene til hver node som tas vare på Ofte vil vi også ha behov for å vite hvilke noder den korteste veien går innom (se eksempel neste side) Øvingsoppgave: Programmering av en versjon av Dijkstra som både lagrer de korteste avstandene og veiene
Vektet, rettet graf for testing Fil: vgraf_13.txt