Dijkstras algoritme. Her finnes det også (minst) en riktig rekkefølge for Relax, men den må vi oppdage litt etter hvert.

Transkript

1 Her finnes det også (minst) en riktig rekkefølge for Relax, men den må vi oppdage litt etter hvert. Tenk vann som sprer seg i rør: Vi behandler krysningspunktene i den rekkefølgen de fylles. Det må gi oss riktige svar. Altså litt som DAG-SP, men ikke topologisk sortert vi ordner (på magisk vis) etter faktisk avstand. (Hvis vi bare tar med kanter i de korteste stiene så er grafen topologisk sortert ) Dijkstras algoritme 1

2 I stedet for topologisk rekkefølge: Etter stigende avstand fra s Som BFS men prioritetskø (med d[v]) i stedet for FIFO-kø Takler ikke negative kanter! 2

3 For spinkle grafer: Bruker binær haug som prioritetskø Må kunne endre nøkler (dvs. d[v]) underveis Må ha kobling mellom mellom noder og haug-innslag Kan evt. legge inn noder flere ganger i stedet 3

4 Initialiser grafen Så lenge det finnes uferdige noder: Velg u med lavest d[u] For alle kanter (u, v): Relax(u, v) 4

5 Hvis nodene besøkes etter stigende avstand: Kantene i korteste veier bli relaxet i riktig rekkefølge Topologisk sortering av kantene som «teller» Men Hvordan vet vi at lavest d[v] faktisk er nærmest? 5

6 Bokas variant av korrekthetsbeviset. Merk: Det er snakk om nok et bevis ved kontradiksjon. Vi antar at d[u] ikke er korrekt i det en node u legges til, og viser at vi får en selvmotsigelse. Den neste er kanskje forelesningens vanskeligste slide. 6

7 Anta at u er den første som ikke har riktig d- verdi når den legges til. Da må x ha hatt riktig d- verdi, og siden (x, y) er relaxet, så må y også ha riktig d-verdi i det u legges til. d[y] = δ(s, y) δ(s, u) d[u] 2 ). H Vi vet her at y forekommer før u på den korteste stien (Merk at x og y godt kan sammenfalle med s her.) Husk også at d er et overestimat av. = Dette virker bare hvis vi ikke har negative kanter; ellers kan vi ta «snarveier» og vi vet ikke lenger hvilken node som er nærmest. 7 <. I Men Siden u ble valgt før y så vet vi at d[u] d[y]. d[u] d[y] % d[y] = δ(s, y) = δ(s, u) = d[u] Sandwitch!

8 Underliggende antagelse: u er den første med galt men minimalt avstandsestimat (blant de hittil ubesøkte). Vi har y med korrekt d d[y] = δ(s, y) Dette viste vi ved å se at det må finnes en y med en forgjenger x rett innenfor og som altså har fått kjørt relax på sin forgjengerkant i den korteste stien, og dermed har korrekt d. u ligger senere på korteste vei δ(s, y) δ(s, u) d[u] men besøkes likevel (feilaktig) Det er denne ulikheten som ikke gjelder hvis vi har negative kanter. Da kan en node tidligere på den korteste stien likevel ligge lenger unna startnoden. d[u] d[y] 8 Vi får altså både d[y] d[u] og d[u] d[y], dvs. d[y] = d[u], med de faktiske avstandene klemt imellom. Med andre ord: Begge avstandene er korrekte likevel og vi har en selvmotsigelse.

9 (Min egen variant av korrekthetsbeviset litt enklere (IMO) enn det i boka.) Hypotetisk: Vi ordner noder etter faktisk avstand. Vi har positive kanter, så bakoverkantene vil være irrelevante (selv om vi jo ikke vet hvilke de er). Med andre ord har vi en (skjult, ukjent) DAG. Vi ønsker å besøke nodene i avstandsrekkefølge *uten å kjenne til* denne rekkefølgen (eller DAG-en). Induksjon to the rescue 0 3 7??? Vi har besøkt de k 1 første nodene, og relaxet kantene ut. Disse nodene har nå riktig avstandsestimat og det har også den neste i rekka (selv om vi ikke vet hvilken det er ennå). Det er akkurat som i DAG-shortest-path. 9 Betrakt den neste i sortert rekkefølge. Den har korrekt estimat. Alle de gjenværende har større avstand, og minst like store estimater. Dermed må den med lavest estimat være den neste, og vi har løst problemet for k.

10 Kjøretid avhengig av prioritetskøen. Hver Relax (det vil si, hver kant) kan måtte bruke Decrease-Key som koster O(lg V). Hver Extract-Min (dvs. for hver node) koster også O(lg V). Vi har altså: O(E lg V) + O(V lg V). Hvis alle kan nås fra starten vil E dominere, og vi får O((E+V) lg V) = O(E lg V). Kjøretid: O(E lg V) * * Hvis alle noder kan nås fra s 10

11 _ Z - ^ [ \ a B ` ] ` A s x y z

12 Korteste vei Én til alle Ingen neg. kanter Besøk nærmeste Relax til alle naboer Effektiv Spes. på spinkle G Kravstor O(E lg V) Dette er jo en gjenganger. Jo sterkere krav vi stiller, jo mer effektive er algoritmene. Dijkstras algoritme 12

13 Bellman-Ford BFS/DFS Binære søketrær Binærsøk Bubblesort Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp Floyd- Warshall Hashing Heapsort Huffmankoding Insertion sort Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Selection sort Sterke komponenter Topologisk sortering 13

14 Bellman-Ford BFS/DFS Binære søketrær Binærsøk Bubblesort Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp Floyd- Warshall Hashing Heapsort Huffmankoding Insertion sort Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Selection sort Sterke komponenter Topologisk sortering 14

15 Dijkstra recap Noder «plottet» etter avstandsestimat. Nærmeste er alltid den med lavest estimat. Hvor langt kan nodene komme etter Relax? d x Relax y z d y z A. Relax fra nyeste korrekte B. Gjenta med nærmeste Start-noden er korrekt fra starten av. 15 Den med nærmest estimat vil være korrekt (se neste slide )

16 s og x er alt ferdigbehandlede. Relax(x,y) er kjørt. d =! u antatt gal s x y u u velges nå vi antar den er den første som velges med *gal* d-verdi. Antar u valgt før y: d[u] d[y] Kan bare garanteres uten negative vekter. y kommer før u på stien: δ(s, y) δ(s, u) d[y] riktig og d overest.: d[y] d[u] Med andre ord: d[y] = δ(s, y) = δ(s, u) = d[u] Vi har nå vist at u får *riktig* d-verdi, 16 som er en selvmotsigelse. Selvmotsigelse!

17 Enkel alle-til-allealgoritme: Kjør Dijkstra (eller eller Bellman-Ford, eller BFS, alt ettersom) fra alle noder. Kan fungere for spinkle grafer blir dyrt ellers. Alle mot alle Åttende forelesning 17

18 Bellman-Ford BFS/DFS Binære søketrær Binærsøk Bubblesort Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp Floyd- Warshall Hashing Heapsort Huffmankoding Insertion sort Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Selection sort Sterke komponenter Topologisk sortering 18

19 Bellman-Ford BFS/DFS Binære søketrær Binærsøk Bubblesort Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp Floyd- Warshall Hashing Heapsort Huffmankoding Insertion sort Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Selection sort Sterke komponenter Topologisk sortering 19

20 DP kort oppsummert: Løsningsmetode der vi bygger løsninger fra optimale delløsninger. Utregningene av disse overlapper, så vi mellomlagrer delløsninger for å unngå eksponensiell kjøretid. Mer om dette siden. Litt DP 20

21 21

22 22

23 1. Karakteriser strukturen til en optimal løsning. Og egentlig 2. Definér verdien til en optimal løsning rekursivt. 4. Beregne løsningen som ga den optimale verdien. 3. Beregn den optimale verdien «bottom-up», og ta vare på del-løsninger. struktur Mer om dette siden. definisjon beregning Eksempel: Lengste stigende subsekvens med maks-sprang k. 23

24 DAG-SP igjen Strukturen til en optimal løsning: Gitt av trekantulikheten Rekursiv definisjon av optimal verdi: Rekursivt definert vha. forgjengere «Bottom-up»-beregning: Relax fra alle forgjengere, f.v. t.h. 24

25 Vi må av og til «lage» en struktur/ dekomponering og det er tilfellet for dagens algoritmer. Hoved-ideene bak algoritmene er nettopp disse dekomponeringene i «kunstige delproblemer». Vi kunne ha tenkt: 1. Finn korteste vei fra A til B, 2. fra A til C, etc. I stedet tenker vi: Finn alle korteste veier *av en begrenset type*, og så slakker vi gradvis begrensningen, til vi har et svar. Dekomponering 25

26 ! 26

27 Dekomponering Delproblem med parameter m: Finn alle korteste veier som maksimalt kan inneholde m kanter. Ved å øke m til n finner vi til slutt det endelige resultatet. Nøkkelen blir å få til dette trinn for trinn og for å få til det snur vi det etter hvert på hodet (med en rekursiv definisjon). Maks m kanter 27

28 Dekomponering Kanskje hakket mindre naturlig: Delproblem med parameter k: Finn alle korteste stier som kun har lov til å gå *via* nodene v1 vk. Ved å øke k til n finner vi det endelige svaret. Også her må vi til med en rekursiv definisjon for å kunne bygge oss opp, trinn for trinn. Kun via v1 vk 28

29 Én rekursiv dekomponering gir oss en algoritme som ligner på algoritmen for matriseprodukt. Korteste vei og matriseprodukt 29

30 [ n 2 ] ( x i 2 [ i,i+1 ] i+3 3 ) i=1

31 Dette er dekomponeringen vi brukte i DAG-SP og Dijkstra også, egentlig. p = i p k j δ(i, j) = δ(i, k) + w kj Hvis p inneholder maks m kanter, så vil p inneholde maks m 1 kanter 31

32 Optimal lengde l (m) ij fra i til j med maks m kanter. 32

33 (0) lij =! 0 33 if i = j, if i = " j.

34 Merk at vi kan ha k=j (og dermed w_kj = 0), som tilsvarer l_ij^(m) = l_ij^(m-1). (m) lij =! " (m 1) min lik + wkj 1 k n Ligner veldig på oppbygningen i DAG-SP og Dijkstra. 34

35 δ(i, j) = (n 1) lij = (n) lij 35 = (n+1) lij =

36 W = (w ij ) ( ) L (m) = l (m) ij 36

37 Extend-Shortest-Path(L, W) L (l ij) for i 1 to n for j 1 to n l ij Strukturen til algoritmen er akkurat som for den «vanlige» metoden for matrisemultiplikasjon. for k 1 to n return L l ij min(l ij, lik + wkj) 37

38 Vi trenger i praksis ikke bruke n 1 ulike matriser, selvfølgelig. Slow-All-Pairs-Shortest-Paths(W) L (1) W for m 2 to n 1 L (m) Extend-Shortest-Path(L (m 1), W) return L (n 1) Fungerer som «matrise-potens». Vi kan forbedre kjøretiden ved å bruke «dobling», og gå fra en kjøretid på n^4 til en på (n^3)*log(n). 38

39 m = Obs: Egentlig skulle vi ha brukt vektmatrisen for siste kant her. Se neste algoritme for forklaring på hvorfor dette blir riktig :-)

40 m =

41 m =

42 m =

43 m =

44 m =

45 m =

46 m =

47 m =

48 m =

49 m = «Og sådan er det bo!e"er» 49

50 I hvert steg: Finn en vei til en forgjenger vha. m 1 kanter Bruk opprinnelig vektmatrise til siste kant 50

51 Faster-All-Pairs-Shortest-Paths(W) L (1) W m 1 while m < n 1 L (2m) Extend(L (m), L (m) ) m 2m return L (m) Det skader ikke å gå «for langt» med m her. 51

52 Floyd-Warshall 52

53 k er muligens med Delproblem med parameter k: Kan kun gå via de k første nodene. En slik sti kan deles i to mindre delproblemer (med lavere parameter) : Alle mellomliggende noder i {1 k 1} 53

54 7 9 : (117#%')*+),#(')7-)*'#2)$7#%783/74/7555/7993:!"#$%&'(" )*%+$,-.'*/! w7 : #" 9 = ;, (9) " (9 3) (9 3) ;7 : = (9 3) # #" ;9: +#% ;7 :, ;79 <=(-) (;) ;7 : C(%' < (=) = w7 : >)2(?$) 2(%@' 0(-) #%')*+),#(') -)*'#2)$ " (=) # = ;7 : / $#%2) (11 -)*'#2)$ %?+>)*), =5 0*+1$." 2*..*+3$1 54

55 Kubisk kjøretid, naturligvis FGHIJKCLMN=LGG(>, =) < (;) > )*% 9 3.* = 4* )*% 7 3.* = 4* )*% : 3.* = 4* ; (9) 7: +#% ( ; (9 3) 7:, ; (9 3) 79 + ; (9 3) ) 9: %".$%/ < (=) 55 Transitiv closure: Egentlig akkurat det samme men sjekker om det *finnes* en sti, i stedet for å beregne hvor *lang* den er. (Bruker logiske i stedet for aritmetiske operasjoner.)

56 k =

57 k =

58 k =

59 k =

60 Bellman-Ford BFS/DFS Binære søketrær Binærsøk Bubblesort Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp Floyd- Warshall Hashing Heapsort Huffmankoding Insertion sort Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Selection sort Sterke komponenter Topologisk sortering 60

61 Bellman-Ford BFS/DFS Binære søketrær Binærsøk Bubblesort Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp Floyd- Warshall Hashing Heapsort Huffmankoding Insertion sort Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Selection sort Sterke komponenter Topologisk sortering 61