Presentation laddar. Vänta.

Presentation laddar. Vänta.

Relationer, prioritetsköer, grafer och grafalgoritmer

Liknande presentationer


En presentation över ämnet: "Relationer, prioritetsköer, grafer och grafalgoritmer"— Presentationens avskrift:

1 Relationer, prioritetsköer, grafer och grafalgoritmer
Föreläsning 8-9 Relationer, prioritetsköer, grafer och grafalgoritmer En kvart för lite!! Borde hunnit med graftraverseringar! © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

2 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Innehåll Relationer Snabb genomgång, resten läses på egen hand. Prioritetsköer Modell, organisation, konstruktioner, implementationer Grafer Grafalgoritmer Kapitel 16, och 17 i kursboken © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

3 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Relationer En instans av datatypen Relationer består av alla de relationer (relationsobjekt) som kan bildas ur en domänbas för instansen. ”Kurstillfällen” är en relation över domänmängden (Kurskoder, År, Termin, Del av termin) med element som (TDBA36, 03, VT, 1) och (TDBA47, 03, VT, 2) ”Läsperioder” är en annan relation över samma mängd med element som (03, VT, 1), (98, HT, 3) etc. En relationsdatatyp kan alltså ha relationsobjekt med olika aritet. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

4 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Modell av Relation Ofta beskriver man en relation med hjälp av en tabell över de element som ingår i relationen. Relationen Kursansvar: Anders Broberg TDBA36 Johan Eliasson TDBA63 Lena Kallin Westin TDBA47 Helena Lindgren TDBD06 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

5 Tillämpningar av Relation
Relationsdatabaser Vilka lärare undervisar på våren? Kurskod År Termin Period TDBA36 03 VT 1 TDBA63 TDBA47 2 TDBD06 02 HT 3 Lärare Kurskod Anders Broberg TDBA36 Johan Eliasson TDBA63 Lena Kallin Westin TDBA47 Helena Lindgren TDBD06 En mängd tabeller där fakta helst bara ska finnas i en tabell. Man ställer frågor i ett speciellt frågespråk som bygger på relationell algebra.. Kurs i databasteknik på C-nivå © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

6 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Prioritetskö Modell: Patienterna på en akutmottagning, man kommer in i en viss tidsordning men behandlas utifrån en annan ordning. Organisation: En mängd vars grundmängd är linjärt ordnad av en prioritetsordning. Avläsningar och borttagningar görs endast på de element som har högst prioritet. Andra mängdoperationer är inte aktuella © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

7 Specifikation av prioritetskö
Gränsytan Pqueue(val, R): Empty ()  Pqueue(val, R) Insert (v:val, p:Pqueue(val, R))  Pqueue(val, R) Isempty (p:Pqueue(val, R))  Bool Inspect-first (p:Pqueue(val, R))  val Delete-first (p:Pqueue(val, R))  Pqueue(val, R) R är relationen för prioritetsordningen. Ibland slås de två sista metoderna ihop. Ytan ovan förutsätter statisk prioritet. Vill man ha dynamisk prioritet måste en update- metod finnas. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

8 Specifikation av prioritetskö
Man kan också tänka sig att prioritetskön tar element (val) som består av ett värde och en prioritet. Förra fallet antog man att värde = prioritet Gränsytan kan varieras på flera sätt update har vi redan nämnt Vi kan också vilja finna det högsta/minsta prioritetsvärdet i kön © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

9 Stack och kö är specialfall av prioritetskön!
Se axiomen på s 294! Om R är den totala relationen, dvs gäller för alla par av värden blir prioritetskön en stack. Om R är den tomma relationen, dvs inte gäller för några par av värden, blir det en kö. Dessutom: Om R är en strikt partiell ordning, som ”>”, kommer lika element behandlas som en kö. Om R är icke-strikt, som ”≥” behandlas lika element som en stack. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

10 Konstruktioner av Prioritetskö
Man utgår ofta från konstruktioner av Mängd eller Lexikon Men de har vi inte stött på än… Lista, ej sorterad Insert O(1), Delete-first O(n) Lista, sorterad Insert O(n), Delete-first O(1) Rita och visa! © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

11 Konstruktioner av Prioritetskö
Heap/Hög – ett partiellt sorterat binärt träd Etiketterna är sorterade efter en relation R så att a är förälder till b endast om a är före b i ordningen som ges av R. Insättningar och borttagningar görs så att trädet hålls komplett. Insert O(log n), Delete-first O(log n) Se figur 14.10 och s 296! © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

12 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Tillämpningar Operativsystem som fördelar jobb mellan olika processer Enkelt sätt att sortera något. Stoppa in allt i en prioritetskö och plocka ut det igen. Hjälpmedel vid traversering av graf Jmfr att stack och kö används vid traversering av träd. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

13 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Graf Se figur 17.1 s 337 och 17.3 s 340! Modell: Vägkarta med enkelriktade gator utritade. Tillämpningar Signaturdiagrammen Elektroniska kretsar Nätverk (gator, flygrutter, kommunikation) Neurala nätverk © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

14 Mängorienterad specifikation (vanlig inom matematiken)
En graf G = (V, E) består av V : en mängd av noder (vertices) E : en mängd av bågar (edges) som binder samman noderna i V. En båge e = (u, v) är ett par av noder. V = {a, b, c, d, e} E = {(a,b), (a,c), a,d), (b,e), (c,d), (c,e), (d,e)} a b c d e © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

15 Navigeringsorienterad specifikation
En graf är en mängd med noder där man till varje nod associerar en grannskapsmängd av noder som kallas grannar. Alla noder tillhör samma typ Alla ordnade par av en godtycklig nod och en av noderna i dess grannskapsmängd utgör en båge. Denna specifikation passar ofta bättre i algoritmer eftersom de förutsätter effektiva navigeringsoperationer. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

16 Riktade/oriktade grafer
b c d e Oriktade grafer Bågen är en mängd av två noder. Noderna är grannar till varandra. Gradtalet = Antalet bågar till grannar (eller sig själv) Riktade grafer Bågen är ordnade par av noder. Gradtalet indelas i Ingradtalet = antalet bågar som går till noden Utgradtalet = antalet bågar som startar i noden och går till en annan nod. a b c d e © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

17 Bokens informella specifikation:
Empty – konstruerar en tom graf utan noder och bågar Insert-node(v, g) – sätter in noden v i grafen g Insert-edge(e, g) – sätter in en båge e i grafen g. Det förutsätts att noderna finns i grafen Isempty(g) – testar om grafen g är tom, dvs utan noder Has-no-edges(g) – testar om grafen g saknar bågar Choose-node(g) – väljer ut en nod ur grafen g Neighbours(v, g) – mängden av alla grannar till v i grafen g Delete-node(v, g) – tar bort noden v ur grafen g, förutsatt att v inte ingår i någon båge Delete-edge(e, g) – tar bort bågen e ur grafen g Visa OH-bilderna från Goodrich! © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

18 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
c d e Terminologi Väg/stig (path): En sekvens av noder v1, v2, …, vn så att vi och vi+1 är grannar. I figuren ovan, a, b, e, c Enkel väg (simple path): Inga noder förekommer två gånger i vägen. Cykel (cycle): En enkel väg där den sista noden i sekvensen är densamma som den första. Oriktad graf utan cykler =träd! © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

19 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
c d e a b Terminologi c d e Sammanhängande (connected) graf Varje nod har en väg till varje annan nod. Delgraf (subgraf) en delmängd av noderna och kanterna som formar en graf. Sammanhängande komponenter En sammanhängande subgraf Grafen uppe till höger har två sammanhängande komponenter. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

20 Connectivity (nåbarhet)
m=6, n =4 a Connectivity (nåbarhet) b d c Låt n = antalet noder och m = antalet bågar. En komplett graf (complete graph) får man när alla noder är grannar till alla andra. I en komplett oriktad graf är m = n(n-1)/2 För ett träd gäller m = n-1 Om m < n-1 så är grafen inte sammanhängande m=5, n =6 Alla noder har n-1 kanter dvs n*(n-1) men då räknar vi kanterna dubbelt så därför / 2 a b c m=3, n =5 d e © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

21 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Digraph och DAGs a b DiGraph = Directed graph dvs riktad graf kan vara sammanhängande (dvs vägar finns från alla till alla noder) kan ha sammanhängande komponenter DAG = Directed Acyclic Graf dvs, en riktad graf utan cykler c d e a b c d e Bilder på starkt kopplade riktade grafer…. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

22 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Mer grafer… Viktad graf En graf där bågarna har vikter Multigraf Tillåtet med flera bågar mellan två noder. Dessa bågar har då olika egenskaper som måste lagras. Ordnad graf har inbördes ordning mellan grannarna till en nod. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

23 Konstruktion av grafer
b c d e Förbindelsematris Bågarna representeras av ettor i en matris. Rad 1 visar vilka bågar man kan nå från a. Kolumn 3 visar från vilka noder det kommer bågar till c. + Enkel att implementera och passar när man har siffror på noder och bågar. Matrisen kan bli stor och gles och kräva specialtrick. 1 2 3 4 5 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

24 Konstruktion av grafer
c a b Graf som fält av lista. Listan är grannskapslistan. Man utgår att det finns minst en båge från varje nod (Fält) men inte att går en båge från varje nod till varje annan nod (därför Lista). + Inte lika utrymmeskrävande som en gles matris. Utrymmet = O(n+m) - Fixt antal noder d e a b c d e c d e c e Kan ju också göra det som en lista av listor b c © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

25 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Grafalgoritmer Traversering Bredden-först och djupet-först Konstruera ett (minsta) uppspännande träd Finna vägarna från en nod till alla andra noder Kortaste vägen mellan två noder Finna maximala flödet Finna det maximala flödet mellan två noder © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

26 Djupet-först-traversering
Man besöker utgångsnoden och sedan dess grannar djupet-först rekursivt. Undersöka en labyrint genom att markera de vägar man gått med färg. Om grafen innehåller cykler finns det risk för oändlig traversering Löses genom att hålla reda på om noden är besökt eller ej. Om noden redan besökt görs ingen rekursivt anrop. Endast de noder man kan nå från utgångsnoden kommer att besökas. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

27 Djupet-först-algoritm:
Algoritm depthFirst(Node n, Graph g) input: A node n in a graph g to be traversed visited(n, g) // Marks the node as visited neighbourSet  neighbours(n, g); for each neighbour in neighbourSet do if not isVisited(neighbour) depthFirst(neighbour, g) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

28 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) A B C E F G I J K * Markera noden som besökt. Grannar = {E, F, B} E ej besökt, rekursivt anrop. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

29 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) A B C E F G I J K Markera noden som besökt. Grannar = {I, F, A} I ej besökt, rekursivt anrop. * © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

30 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) A B C E F G I J K Markera noden som besökt. Grannar = {J, F, E} J ej besökt, rekursivt anrop. * © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

31 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) depthFirst(J) A B C E F G I J K Markera noden som besökt. Grannar = {G, I} G ej besökt, rekursivt anrop. * © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

32 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) depthFirst(J) A B C E F G I J K depthFirst(G) Markera noden som besökt. Grannar = {C, K} C ej besökt, rekursivt anrop. * © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

33 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) depthFirst(J) A B C E F G I J K * depthFirst(G) Markera noden som besökt. Grannar = {B, G} B ej besökt, rekursivt anrop. depthFirst(C) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

34 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) depthFirst(J) A B C E F G I J K * depthFirst(G) Markera noden som besökt. Grannar = {A, F, C} A redan besökt F ej besökt, rekursivt anrop. depthFirst(C) depthFirst(B) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

35 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) depthFirst(J) A B C E F G I J K depthFirst(G) Markera noden som besökt. Grannar = {B, A, E, I} Alla redan besökta. depthFirst(C) * depthFirst(B) depthFirst(F) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

36 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) depthFirst(J) A B C E F G I J K * depthFirst(G) Nod B: Grannar = {A, F, C} Alla redan besökta depthFirst(C) depthFirst(B) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

37 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) depthFirst(J) A B C E F G I J K * depthFirst(G) Nod C: Grannar = {B, G} Alla redan besökta depthFirst(C) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

38 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) depthFirst(J) A B C E F G I J K depthFirst(G) Nod G: Grannar = {C, K} K ej besökt, rekursivt anrop. * © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

39 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) depthFirst(J) A B C E F G I J K depthFirst(G) Markera noden som besökt. Grannar = {G} G redan besökt. depthFirst(K) * © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

40 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) depthFirst(J) A B C E F G I J K depthFirst(G) * © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

41 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) depthFirst(J) A B C E F G I J K * © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

42 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) depthFirst(I) A B C E F G I J K * © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

43 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) depthFirst(E) A B C E F G I J K * © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

44 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
depthFirst(A) A B C E F G I J K * © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

45 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F A B C E G I J K Klart! Notera att vi fick ett uppspännande träd på samma gång. A B C E F G I J K © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

46 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
c d e a b c d e a b c d e a b c d e Markera noden som besökt. Grannarna = {c, e, d} Rekursivt anrop c. Markera noden som besökt. Inga grannar. Återgå till 1, nytt anrop e. Markera noden som besökt. Grannarna = {b, c} Rekursivt anrop b. Markera noden som besökt. Grannarna = {c} c redan besökt, åter till 3 c redan besökt. Åter till 1 nytt anrop d Markera noden som besökt. Grannarna ={e}. Redan besökt. Åter 1. a b c d e © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

47 Bredden-först-algoritm
Man undersöker först noden, sedan dess grannar, grannarnas grannar osv. Finns risk för oändlig körning här med om man inte använder en markör för att noden besökts. Endast noder till vilka det finns en väg från utgångsnoden kommer att besökas. En kö hjälper oss hålla reda på grannarna. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

48 Bredden-först-algoritm:
Algoritm breadthFirst(Node n, Graph g) input: A node n in a graph g to be traversed Queue q  empty(); visited(n, g) // Marks the node as visited q  enqueue(n, q); while not isempty(q) do newNode  front(q) q  dequeue(q); neighbourSet  neighbours(newNode, g); for each neighbour in neighbourSet do if not isVisited(neighbour) visited(neighbour, g); q  enqueue(neighbour, q); © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

49 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Markera noden som besökt och lägg in den i kön. q = (A) Ta fram första elementet (A), q = ( ) Ta sedan fram grannmängden till A S = {B, F, E} A B C E F G I J K © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

50 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
För var och en av grannarna: B är inte besökt, besök B och lägg in B i kön q = (B) A B C E F G I J K © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

51 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
C E F G I J K F är inte besökt, besök F och lägg in F i kön q = (B, F) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

52 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
J K A B C E F G E är inte besökt, besök E och lägg in E i kön q = (B, F, E) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

53 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
q = (B, F, E), ta fram första elementet (B) q = (F, E) Ta sedan fram grannmängden till B S = {A, F, C} A B C E F G I J K För var och en av grannarna: A och F är besökta C är inte besökt, besök C och lägg in C i kön q = (F, E, C) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

54 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
q = (F, E, C), ta fram första elementet (F) q = (E, C) Ta sedan fram grannmängden till F S = {B, A, E, I} A B C E F G I J K B, A, och E är besökta I är inte besökt, besök I och lägg in I i kön q = (E, C, I) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

55 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
q = (E, C, I), ta fram första elementet (E) q = (C, I) Ta sedan fram grannmängden till E S = {A, F, I} För var och en av grannarna: Alla är besökta A B C E F G I J K © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

56 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
q = (C, I), ta fram första elementet (C) q = (I) Ta sedan fram grannmängden till C S = {B, G} För var och en av grannarna: B är besökt G är är inte besökt, besök G och lägg in G i kön q = (I, G) A B C E F G I J K © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

57 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
q = (I, G), ta fram första elementet (I) q = (G) Ta sedan fram grannmängden till I S = {E, F, J} E och F är besökta J är inte besökt, besök J och lägg in J i kön q = (G, J) A B C E F G I J K © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

58 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
q = (G, J), ta fram första elementet (G) q = (J) Ta sedan fram grannmängden till G S = {C, J, K} C och J är besökta K är inte besökt, besök K och lägg in K i kön q = (J, K) A B C E F G I J K © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

59 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
q =(J, K), ta fram första elementet (J) q = (K) Ta sedan fram grannmängden till J S = {I, G} Båda är besökta q = (K), ta fram första elementet (K) q = () Ta sedan fram grannmängden till K S = {G} Den är besökt. Nu är kön tom och algoritmen klar. A B C E F G I J K © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

60 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
c d e a b c d e a b c d e a b c d e Markera noden som besökt. q = (a), ta fram första elem ur q. Leta reda på grannarna = {c, e, d} Markera c som besökt. Stoppa in i kön q = (c) Markera e som besökt. Stoppa in i kön q = (c, e) Markera d som besökt. Stoppa in i kön q = (c, e, d) Ta första ur kön (= c) q = (e, d), c har inga grannar. Ta första ur kön (=e) q = (d). e har grannarna = {b} Markera b som besökt. Stoppa in i kön q = (d, b) Ta första ur kön (=d) q = (b). Grannarna redan besökta. Ta första ur kön (=b) q = (). Grannarna redan besökta. Kön tom. Klart! a b c d e Algoritm breadthFirst(Node n, Graph g) input: A node n in a graph g to be traversed Queue q; visited(n, g) // Marks the node as visited q  enqueue(n, q); while not isempty(q) do newNode  front(q) q  dequeue(q); neighbourSet  neighbours(newNode, g); for each neighbour in neighbourSet do if not isVisited(neighbour) visited(neighbour, g); q  enqueue(neighbour, q); © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

61 Kortaste-vägen-algoritm vid lika vikt
Om vi har en graf med lika vikter på alla bågar kan man använda en variant av bredden-först traversering för att beräkna kortaste vägen från en nod till de andra. Algoritm breadthFirst(Node n, Graph g) input: A node n in a graph g to be traversed Queue q  empty(); visited(n, g) // Marks the node as visited setDist(n, 0) q  enqueue(n, q); while not isempty(q) do newNode  front(q) q  dequeue(q); neighbourSet  neighbours(newNode, g); for each neighbour in neighbourSet do if not isVisited(neighbour) visited(neighbour, g); setDist(neighbour, getDist(newNode)+1) q  enqueue(neighbour, q); © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

62 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
1 2 A B C E F G I J K E F B I C 1 1 3 J G K 2 3 4 Om alla bågar har vikt 1 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

63 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Tidskomplexitet För både bredden-först och djupet-först gäller: Varje nod besöks exakt en gång O(n) För varje nod följer man bågarna ut från noden för att hitta grannarna. Detta bör vara effektivt O(grad(v)), värsta fallet är O(n). I bokens navigeringsorienterade spec. har vi O(grad(v)) Mängdorienterad spec. ger O(m) där m=antalet bågar i noden Eftersom grannmängden behöver evalueras en gång för varje nod blir komplexiteten O( grad(v)) =O(m) Totalt O(n) + O(m) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

64 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Uppspännande träd Både bredden-först och djupet-först-traverseringarna gav oss uppspännande träd. Om vi sparat undan informationen vill säga… Måste utöka grafspecifikationen med operationer som stöder detta. Är det minimalt? Den totala längden i trädet ska vara minimalt. Om varje kant har samma vikt är trädet minimalt uppspännande för bredden-först traversering. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

65 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Uppspännande träd A B C Skapat med djupet-först Ej minimalt E F G A B C I J K E F G Skapat med bredden-först Minimalt I J K © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

66 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Uppspännande träd A R B F C D E G 4 6 8 5 3 Hur hanterar man grafer med vikter? Man söker ett uppspännande träd med minsta möjliga totala längd. Det är alltså inte en kortaste-vägen algoritm För mängdorienterad specifikation finns Kruskals algoritm För navigeringsorienterad specifikation finns Prims algoritm © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

67 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Prims algoritm Går ut på att bygga upp ett allt större träd som till slut spänner upp grafen eller en sammanhängande komponent av den. Man väljer i varje steg en båge med minimal vikt. Lika vikter måste behandlas konsekvent. Regeln styr hur det färdiga trädet ser ut. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

68 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Prims algoritm: Välj en nod vilken som helst och markera den som öppen. Låt den bli rot. Markera den som stängd. För var och en av (de icke-stängda) grannarna: Markera den som öppen (om den inte är det). Stoppa in den aktuella noden, grannen och vikten i en prioritetskö. Är vikterna lika ska det nya elementet läggas in först i kön. (Dvs relationen är ) Ta fram ett element ur prioritetskön och bilda ett nytt delträd genom att lägga in den båge som finns i elementet i trädet. OBS! Lägg endast in bågen om slutnoden inte är stängd! Låt ändnoden bli den nya aktuella noden, stäng den och gå till 3. (n, neighbour, w) borde skrivas som en egen typ men slarvar!! © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

69 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 Välj en nod vilken som helst och markera den som öppen. Låt den bli rot. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

70 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 Markera den som stängd. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

71 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ( (C, A, 8) ) För var och en av (de icke-stängda) grannarna: Markera den som öppen (om den inte är det). Stoppa in den aktuella noden, grannen och vikten i en prioritetskö. Är vikterna lika ska det nya elementet läggas in först i kön. (Dvs relationen är ) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

72 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ( (C, F, 3), (C, A, 8)) För var och en av (de icke-stängda) grannarna: Markera den som öppen (om den inte är det). Stoppa in den aktuella noden, grannen och vikten i en prioritetskö. Är vikterna lika ska det nya elementet läggas in först i kön. (Dvs relationen är ) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

73 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ( (C, F, 3), (C, G, 4), (C, A, 8)) För var och en av (de icke-stängda) grannarna: Markera den som öppen (om den inte är det). Stoppa in den aktuella noden, grannen och vikten i en prioritetskö. Är vikterna lika ska det nya elementet läggas in först i kön. (Dvs relationen är ) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

74 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ( (C, F, 3), (C, G, 4), (C, D, 5), (C, A, 8)) För var och en av (de icke-stängda) grannarna: Markera den som öppen (om den inte är det). Stoppa in den aktuella noden, grannen och vikten i en prioritetskö. Är vikterna lika ska det nya elementet läggas in först i kön. (Dvs relationen är ) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

75 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((C, G, 4), (C, D, 5), (C, A, 8)) Ta fram ett element ur prioritetskön och bilda ett nytt delträd genom att lägga in den båge som finns i elementet i trädet. OBS! Lägg endast in bågen om slutnoden inte är stängd! Låt ändnoden bli den nya aktuella noden, stäng den och gå till 3. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

76 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((F, A, 4), (C, G, 4), (C, D, 5), (C, A, 8)) P = ((C, G, 4), (C, D, 5), (C, A, 8)) För var och en av (de icke-stängda) grannarna: Markera den som öppen (om den inte är det). Stoppa in den aktuella noden, grannen och vikten i en prioritetskö. Är vikterna lika ska det nya elementet läggas in först i kön. (Dvs relationen är ) Ta fram ett element ur prioritetskön och bilda ett nytt delträd genom att lägga in den båge som finns i elementet i trädet. OBS! Lägg endast in bågen om slutnoden inte är stängd! Låt ändnoden bli den nya aktuella noden, stäng den och gå till 3. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

77 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((A, R, 4), (C, G, 4), (C, D, 5), (C, A, 8)) För var och en av (de icke-stängda) grannarna: Markera den som öppen (om den inte är det). Stoppa in den aktuella noden, grannen och vikten i en prioritetskö. Är vikterna lika ska det nya elementet läggas in först i kön. (Dvs relationen är ) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

78 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((A, R, 4), (C, G, 4), (C, D, 5), (A, E, 6), (C, A, 8)) För var och en av (de icke-stängda) grannarna: Markera den som öppen (om den inte är det). Stoppa in den aktuella noden, grannen och vikten i en prioritetskö. Är vikterna lika ska det nya elementet läggas in först i kön. (Dvs relationen är ) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

79 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((C, G, 4), (C, D, 5),(A, E, 6), (C, A, 8)) Ta fram ett element ur prioritetskön och bilda ett nytt delträd genom att lägga in den båge som finns i elementet i trädet. OBS! Lägg endast in bågen om slutnoden inte är stängd! Låt ändnoden bli den nya aktuella noden, stäng den och gå till 3. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

80 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((C, G, 4), (C, D, 5), (R, B, 6), (A, E, 6), (C, A, 8)) För var och en av (de icke-stängda) grannarna: Markera den som öppen (om den inte är det). Stoppa in den aktuella noden, grannen och vikten i en prioritetskö. Är vikterna lika ska det nya elementet läggas in först i kön. (Dvs relationen är ) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

81 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((C, D, 5), (R, B, 6), (A, E, 6), (C, A, 8)) P = ((C, D, 5), (G, E, 6), (R, B, 6), (A, E, 6), (C, A, 8)) Ta fram ett element ur prioritetskön och bilda ett nytt delträd genom att lägga in den båge som finns i elementet i trädet. OBS! Lägg endast in bågen om slutnoden inte är stängd! Låt ändnoden bli den nya aktuella noden, stäng den och gå till 3. För var och en av (de icke-stängda) grannarna: Markera den som öppen (om den inte är det). Stoppa in den aktuella noden, grannen och vikten i en prioritetskö. Är vikterna lika ska det nya elementet läggas in först i kön. (Dvs relationen är ) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

82 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((G, E, 6), (R, B, 6), (A, E, 6), (C, A, 8)) P = ((D, B, 3), (G, E, 6), (R, B, 6), (A, E, 6), (C, A, 8)) Ta fram ett element ur prioritetskön och bilda ett nytt delträd genom att lägga in den båge som finns i elementet i trädet. OBS! Lägg endast in bågen om slutnoden inte är stängd! Låt ändnoden bli den nya aktuella noden, stäng den och gå till 3. För var och en av (de icke-stängda) grannarna: Markera den som öppen (om den inte är det). Stoppa in den aktuella noden, grannen och vikten i en prioritetskö. Är vikterna lika ska det nya elementet läggas in först i kön. (Dvs relationen är ) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

83 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((G, E, 6), (R, B, 6), (A, E, 6), (C, A, 8)) Ta fram ett element ur prioritetskön och bilda ett nytt delträd genom att lägga in den båge som finns i elementet i trädet. OBS! Lägg endast in bågen om slutnoden inte är stängd! Låt ändnoden bli den nya aktuella noden, stäng den och gå till 3. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

84 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((R, B, 6), (A, E, 6), (C, A, 8)) P = ((A, E, 6), (C, A, 8)) P = ((C, A, 8)) P = () Klart! Ta fram ett element ur prioritetskön och bilda ett nytt delträd genom att lägga in den båge som finns i elementet i trädet. OBS! Lägg endast in bågen om slutnoden inte är stängd! Låt ändnoden bli den nya aktuella noden, stäng den och gå till 3. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

85 Resultat av Prims algoritm:
B F C D E G 4 6 8 5 3 A R B F C D E G 4 6 8 5 3 A R B F C D E G 4 6 8 5 3 Start Slut med  Slut med < © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

86 Prims algoritm - komplexitet
Man gör en traversering av grafen, dvs O(m) + O(n). Sen tillkommer köoperationer För varje båge sätter man in ett element i kön, inspekterar det och tar ut det. Detta blir O(m) Om man använder Heap (partiellt sorterat binärt träd) får vi O(log m). Totalt: O(n) + O(m2) eller O(n) + O(m log m) beroende på implementation av prioritetskön. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

87 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Kruskals algoritm Här väljer man också bågar allt eftersom men man bryr sig inte om att forma delträd under konstruktionen. Man gör ingen traversering utan arbetar på ett annat sätt med bågarna. Man färglägger bågarna för att hålla reda på vilken delgraf de tillhör. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

88 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Kruskals algoritm Skapa en prioritetskö av alla bågarna utifrån vikterna på dessa. Den första bågen plockas fram och bildar den första delgrafen. Noderna färgläggs. Upprepa tills kön är tom: Ta fram en ny båge. Om ingen av noderna är färgade Färglägg med ny färg och bilda ny delgraf. Om endast en nod är färgad Ingen risk för cykel utöka grafen och färglägg. Om båda noderna är färgade med olika färg Välj en av färgerna och färga om den nya gemensamma grafen. Om båda noderna har samma färg Ignorera bågen, den skapar en cykel © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

89 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((C,F,3), (B,D,3), (C,G,4),(A,F,4), (A,R,4), (C,D,5), (E,G,6), (B,R,6), (A,E,6), (A,C,8) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

90 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((B,D,3), (C,G,4),(A,F,4), (A,R,4), (C,D,5), (E,G,6), (B,R,6), (A,E,6), (A,C,8) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

91 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((C,G,4),(A,F,4), (A,R,4), (C,D,5), (E,G,6), (B,R,6), (A,E,6), (A,C,8) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

92 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((A,F,4), (A,R,4), (C,D,5), (E,G,6), (B,R,6), (A,E,6), (A,C,8) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

93 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((A,R,4), (C,D,5),(E,G,6), (B,R,6), (A,E,6), (A,C,8) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

94 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((C,D,5),(E,G,6), (B,R,6),(A,E,6), (A,C,8) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

95 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((E,G,6),(B,R,6),(A,E,6), (A,C,8)) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

96 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 P = ((B,R,6),(A,E,6), (A,C,8)) P = ((A,E,6), (A,C,8)) P = ((A,C,8)) P = () © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

97 Kruskals algoritm - komplexitet
Första steget i algoritmen bygger en prioritetskö utifrån en bågmängd. Komplexitet beror på implementationen av bågmängden och prioritetskön… Varje båge traverseras en gång. Resten kan delas in i fyra fall: Tre fall med komplexitet O(1) där bågen kan läggas till utan problem. Ett fall där en delgraf måste färgas om. Komplexitet O(n). © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

98 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Finna vägen till en nod Bredden-först traversering ger oss vägarna från en nod till alla andra. Om vi sparar undan vägen… Är det den kortaste? Ja, om alla vikter lika! Annars då? Vi kommer titta på två algoritmer: Floyds shortest path O(N3) Dijkstras shortest path © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

99 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Floyds shortest path Bygger på att man representerar grafen med hjälp av en matris. (Eller skapar en matrisrepresentation) A B C D E F G R 8 6 4 3 5 A R B F C D E G 4 6 8 5 3 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

100 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Floyds shortest path Algoritm floyd(Graph g) input: A graph g to find shortest path in // Get matrix representation A(:,:,0)  getMatrix(g) N  getNoOfNodes(g) for k=0 to N-1 for i=0 to N-1 for j=0 to N-1 A(i,j,k+1) = min(A(i,j,k), A(i,k,k)+ A(k,j,k)) A(:,:,N) innehåller kortaste avstånden men hur få tag på vägen? Spara på samma gång en föregångar- matris. Det kommer också kosta O(N3) så den ökar inte komplexiteten. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

101 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Uppdaterad Floyd Algoritm floyd(Graph g) input: A graph g to find shortest path in // Get matrix representation A(:,:,0)  getMatrix(g) N  getNoOfNodes(g) for i = 0 to N-1 for j = 0 to N-1 if (i==j or A(i,j,0)==inf) Path(i,j,0) = -1 else Path(i,j,0) = i for k=0 to N-1 for i=0 to N-1 for j=0 to N-1 A(i,j,k+1) = min(A(i,j,k), A(i,k,k)+A(k,j,k)) if (A(i,j,k) A(i,k,k)+A(k,j,k)) Path(i,j,k+1) = Path(i,j,k) else Path(i,j,k+1) = Path(k,j,k) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

102 Vi har hittat en kortare väg mellan A och C. Vilken är den?
B F C D E G 4 6 8 5 3 k0 A B C D E F G R 8 6 4 3 5 k7 A B C D E F G R 10 7 12 6 4 11 8 3 16 5 15 9 Vi har hittat en kortare väg mellan A och C. Vilken är den? Vilken är vägen mellan R och G?

103 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
C D E F G R - Låt oss leta i vår föregångarmatris. (För enkelhetens skull har jag kodat om siffrorna till motsvarande noder på OH-bilden.) R 6 4 B 8 C 5 A 3 D 4 3 6 4 F E G 6 Man måste leta ”baklänges”. Om vi vill hitta vägen mellan A och C gör man så här: Titta på raden för A. Leta reda på kolumnen för C. Där ser vi F. Sedan tittar vi i kolumnen för F där ser vi A. Vägen är alltså A-F-C. På samma sätt ser vi att kortaste vägen mellan R och G är R-A-F-C-G (med kostnad 15). © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

104 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Dijkstras algoritm Söker kortaste vägen från en nod n till alla andra noder. Fungerar enbart på grafer med positiva vikter. Låt varje nod ha följande attribut Visited – som blir sann när vi hittat en väg till den Distance – värdet på den kortaste vägen fram till noden Parent – Referens till föregångaren på vägen Ett exempel på "giriga (greedy) algoritmer": i varje steg plocka ut den "bästa" noden. Det leder i detta problem också till den globalt bästa vägen. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

105 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Algoritm dijkstra(Node n, Graph g) input: A graph g to find shortest path starting from node n n.visited  true; n.distance  0; n.parent  null; Pqueue q  empty(); q  insert(n,q); while not isempty(q) v  inspect-first(q); q  delete-first(q); d  v.distance; neighbourSet  neighbours(v, g); for each w in neighbourSet do newDist  d + getWeight(v,w); if not isVisited(w) w.visitedtrue; w.distancenewDist; w.parentv; q  insert(w,q); else if newDist < w.distance w.parentv; qupdate(w,q) Dijkstras algoritm Påminn om att man kan lägga in i tabell… © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

106 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Vi startar i R. Sätter värden i noden. Skapar Kö och stoppar in R q = (R(true,0,Null)). A R B F C D E G 4 6 8 5 3 true, 0, null Tar fram v ur kön v = R(true,0,Null) och q = (). d = 0 Leta sedan fram grannarna = {A, B} För granne A: newDist = 0+4 = 4. Ej besökt. q = (A(true,4,R)) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

107 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 true, 0, null true, 4, R För granne B: newDist = 0+6 = 6. Ej besökt. q = (A(true,4,R), B(true,6,R)) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

108 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 true, 0, null true, 4, R true, 6, R Tar fram v ur kön v = A(true,4,R) och q = (B(true,6,R)). d = 4 Leta sedan fram grannarna = {E,F,C,R} För granne E: newDist = 4+6 = 10. Ej besökt. q = (B(true,6,R), E(true,10,A)) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

109 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 true, 0, null true, 4, R true, 10, A true, 6, R För granne F: newDist = 4+4 = 8. Ej besökt. q = (B(true,6,R), F(true,8,A), E(true,10,A)) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

110 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
F C D E G 4 6 8 5 3 true, 0, null true, 4, R true, 6, R true, 10, A true, 8, A För granne C: newDist = 4+8 = 12. Ej besökt. q = (B(true,6,R), F(true,8,A), E(true,10,A) C(true,12,A)) © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

111 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
För granne R: newDist = 4+4 = 8. Besökt. 8>0 gör inget. Tar fram v ur kön v = B(true,6,R) och q = (F(true,8,A), E(true,10,A), C(true,12,A)) d = 6 Leta sedan fram grannarna = {R, D} För granne R: newDist = 6+6 = 12. Besökt. 12>0 gör inget. För granne D: newDist = 6+3 = 9. Ej besökt. q = (F(true,8,A), D(true,9,B), E(true,10,A), C(true,12,A)) A R B F C D E G 4 6 8 5 3 true, 0, null true, 4, R true, 6, R true, 10, A true, 8, A true, 12, A © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

112 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Tar fram v ur kön v = F(true,8,A) och q = (D(true,9,B), E(true,10,A),C(true,12,A)) d = 8 Leta sedan fram grannarna = {A, C} För granne A: newDist = 8+4 = 12. Besökt. 12>4 gör inget. För granne C: newDist = 8+3 = 11. Besökt. 11<12 !! C.distance=11 C.parent = F q = (D(true,9,B), E(true,10,A),C(true,11,F)) A R B F C D E G 4 6 8 5 3 true, 0, null true, 4, R true, 6, R true, 10, A true, 8, A true, 12, A true, 9, B © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

113 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Tar fram v ur kön v = D(true,9,B) och q = (E(true,10,A),C(true,11,F)) d = 9 Leta sedan fram grannarna = {B, C} För granne B: newDist = 9+3 = 12. Besökt. 12>6 gör inget. För granne C: newDist = 9+5 = 14. Besökt. 14>11 gör inget Tar fram v ur kön v = E(true,10,A) och q = (C(true,11,F)) d = 10 Leta sedan fram grannarna = {A, G} För granne A: newDist = 10+6 = 16. Besökt. 16>4 gör inget. För granne G: newDist = 10+6 = 16. Ej besökt. q = (C(true,11,F), G(true, 16,E)) A R B F C D E G 4 6 8 5 3 true, 0, null true, 4, R true, 6, R true, 10, A true, 8, A true, 11, F true, 9, B © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

114 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Tar fram v ur kön v = C(true,11,F) och q = (G(true, 16,E)) d = 11 Leta sedan fram grannarna = {A, F, G, D} För granne A: newDist = 11+8 = 19. Besökt. 19>4 gör inget. För granne F: newDist = 11+3 = 14. Besökt. 14>8 gör inget För granne G: newDist = 11+4 = 15. Besökt. 15<16!! G.distance=15 G.parent = C q = (G(true, 15,C)) A R B F C D E G 4 6 8 5 3 true, 0, null true, 4, R true, 6, R true, 10, A true, 8, A true, 11, F true, 9, B true, 16, E © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

115 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
För granne D: newDist = 11+5 = 16. Besökt. 16>9 gör inget. Tar fram v ur kön v = G(true, 15,C) och q = () d = 15 Leta sedan fram grannarna = {E, C} För granne E: newDist = 15+6 = 21. Besökt. 21>10 gör inget. För granne C: newDist = 15+4 = 19. Besökt. 19>11 gör inget Stanna algoritmen klar. A R B F C D E G 4 6 8 5 3 true, 0, null true, 4, R true, 6, R true, 10, A true, 8, A true, 11, F true, 9, B true, 15, C © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

116 Dijkstras algoritm - komplexitet
Vi sätter in varje nod i kön en gång. Totalt n*O(insert) Vi tar ut varje nod ur kön en gång. Totalt n*O(delete-first) Vi kan behöva uppdatera element i kön. Maximalt m gånger, m*O(update) Osorterad lista n*O(1)+n*O(n) + m*O(1) = O(n2) +O(m) Heap n*O(log n)+n*O(log n) + m*O(log n) = O((n+m)log n) Om smart implementation… © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

117 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Floyd vs. Dijkstra Floyd O(n3) hittar den kortaste vägen mellan alla noder. Dijkstra O((n+m) log n) med heap, hittar kortaste vägen mellan en nod och alla andra. Måste köras N gånger för att få samma resultat som Floyd. Dvs O(n(n+m) log n). Är bättre på stora glesa grafer. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003

118 © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003
Flödet i en graf Riktad graf med vikter cv,w, som anger flödeskapacitet över bågen (v,w). Kapaciteten kan t.ex. vara mängden vätska som kan flöda genom ett rör, maximala mängden trafik på en väg eller kommunikationskapaciteten i ett datornät. Grafen har två noder s (source) och t (sink) och uppgiften är att beräkna det maximala flödet mellan s och t. Genom varje båge (u,v) kan vi maximalt ha ett flöde på cu,v enheter. För varje node v gäller att det totala inkommande flödet måste vara lika med det utgående flödet. © Anders Broberg, Ulrika Hägglund, Lena Kallin Westin, 2003


Ladda ner ppt "Relationer, prioritetsköer, grafer och grafalgoritmer"

Liknande presentationer


Google-annonser