Kortste Paden Algoritmiek

2 Vandaag Kortste Paden probleem All pairs / Single Source / Single Target versies DP algoritme voor All Pairs probleem (Floyd’s algoritme) Dijkstra’s algoritme voor Single Source Negatieve cycles Meeste algoritmen: Dynamisch programmeren in vermomming

Algoritmiek3 Kortste paden Gerichte Graaf G=(N,A), en een lengte L(v,w) voor elke kant (v,w) in A. Knopen x, y in N. Pad van x naar y. Lengte van pad Probleem: gegeven G, L, x, y, wat is de afstand van het kortste pad van x naar y. Wat is het kortste pad? x d y a b c 3 1 1

Algoritmiek4 Toepassingen Routeplanning –Voor navigatiesystemen –In logistieke toepassingen –Voor gesimuleerde situaties (games, etc.) Productie Graafmodel van ander probleem met vertaling naar kortste paden probleem

Algoritmiek5 Notatie d G (x,y) = afstand van x naar y: lengte van het kortste pad in G van x naar y. Vaak schrijven we d(x,y) in plaats van d G (x,y).

Algoritmiek6 Versies All pairs shortest paths –Bereken voor alle paren knopen v, w de afstand d(v,w) van v naar w Single source shortest paths –Gegeven knoop v, bereken voor elke knoop w de afstand d(v,w) van v naar w Single target shortest paths –Gegeven knoop w, bereken voor elke knoop v de afstand d(v,w) van v naar w Single pair shortest path –Gegeven knopen v en w, bereken de afstand d(v,w) van v naar w.

Algoritmiek7 Nog meer versies Ongerichte grafen –Vervang elke kant door twee pijlen en los probleem op gerichte graaf op Negatieve lengtes van pijlen –In sommige toepassingen nuttig. Dijkstra werkt alleen als alle lengtes niet-negatief zijn –Bij negatieve lengtes kunnen er negatieve cycles zijn: kortste pad hoeft niet goed gedefinieerd te zijn dan…

Algoritmiek8 All pairs shortest paths ARU A012 R904 U560 A U R van naar

Twee algoritmen voor all pairs 1e idee: dynamisch programmeren met aantal stappen 2e idee (Floyd-Warshall algoritme): dynamisch programmeren met welke knopen je gebruikt Algoritmiek9

Deelproblemen Schrijf: S q (i,j) als het kortste pad van knoop i naar knoop j dat hooguit q stappen gebruikt Basisgeval: –S 1 (i,j) = 0 als i=j L(i,j) als er een pijl (i,j) bestaat  anders Recurrente betrekking: voor alle p en q: –S p+q (i,j) = min {S p (i,k) + S q (k,j) | knopen k} –Waarom eigenlijk? Algoritmiek10

Berekenen van S 2p uit S p Knopen genummerd 1 … n For i = 1 to n do –For j = 1 to n do { Bereken S 2p (i,j): } z =  For k = 1 to n do –z = min { z, S p (i,k) + S p (k,j)} S 2p (i,j) = z Algoritmiek11 O(n3)O(n3) O(n3)O(n3)

O(n 3 log n) algoritme voor all-pairs shortest paths Maak S 1 While p < n do –Bereken S 2p uit S p –p = 2p Return S 2p Algoritmiek12

Kan het sneller? Ja, op twee manieren Vorige algoritme, met soort van snelle matrix- vermenigvuldiging (divide-and-conquer) Ander algoritme: Iedere keer een knoop meer bekijken die “tussenin” kan gebruikt worden … Algoritmiek13

Algoritmiek14 Dynamisch programmeer algoritme voor all pairs kortste paden probleem Deelproblemen Nummer de knopen 1, 2, …, n. Schrijf D k (i,j) = minimum lengte van een pad van i naar j, waarbij het pad alleen knopen i, j, 1, 2, …, k mag gebruiken Merk op: d(i,j) = D n (i,j) D 1 (1,5) =  D 2 (1,5) = 20 D 3 (1,5) = 9 D 4 (1,5) = D 5 (1,5) = 7 D 2 (3,5) = 4

Algoritmiek15 Recurrente betrekkingen Als (i,j) geen pijl in A, dan: D 0 (i,j) = . Als (i,j) in A, dan D 0 (i,j) = L(i,j): lengte pijl Als k>0, dan D k (i,j) = min ( D k-1 (i,j), D k-1 (i,k) + D k-1 (k,j) ) ji k D k-1(i,k) D k-1(k,j) D k-1(i,j)

Algoritmiek16 Notatie Schrijf L(i,j) = , als (i,j) geen pijl in A. Nu: voor alle i, j: L(i,j) = D 0 (i,j)

Algoritmiek17 1e versie algoritme Maak 3 dimensionaal array D(0…n, 1…n, 1…n) –( D(k,i,j) geeft D k (i,j) weer ) For i=1 to n do For j=1 to n do D(0,i,j) = L(i,j); For k=1 to n do For i=1 to n do For j=1 to n do D(k,i,j) = min (D(k-1,i,j), D(k-1,i,k)+D(k-1,k,j) ) Antwoorden staan in D(n,*,*)

Algoritmiek18 2e versie algoritme: geheugenbesparing Maak 2 dimensionaal arrays D(1…n, 1…n), C(1…n,1…n) D = L For k=1 to n do For i=1 to n do For j=1 to n do C(i,j) = min (D(i,j), D(i,k)+D(k,j) ) For i=1 to n do For j=1 to n do D(i,j) = C(i,j) Antwoorden staan in D Standaard techniek voor geheugenbesparing Standaard techniek voor geheugenbesparing For i=1 to n do For j=1 to n do D(i,j) = L(i,j) For i=1 to n do For j=1 to n do D(i,j) = L(i,j)

Algoritmiek   0   014  01    0   014  01    0  10  014  01    0   014  01    0   012  01    0  10  012  01  0 5

Algoritmiek20 Eigenschappen Waardes op matrixposities stijgen niet –C(i,j) = min (D(i,j), D(i,k)+D(k,j) ) Informatie nodig in ronde k verandert niet in ronde k. –Alleen elementen van vorm D(*,k) en D(k,*). –Bijv.: C(i,k) == min (D(i,k),D(i,k)+D(k,k)) –D(k,k) blijft 0. Dus: in plaats van 2 kunnen we met 1 matrix werken. k k

Algoritmiek21 3e versie: geen 2e matrix Maak 2 dimensionaal array D(1…n, 1…n) D = L; For k=1 to n do For i=1 to n do For j=1 to n do D(i,j) = min (D(i,j), D(i,k)+D(k,j) ) Antwoorden staan in D Kost O(n 3 ) tijd

Algoritmiek22 Constructief Extra matrix P –P(v,w) geeft een knoop die ligt tussen v en w op het kortste pad van v naar w –Tijdens algoritme: P(v,w) geeft zo’n knoop van een pad van v naar w met lengte de huidige waarde D(v,w)

Algoritmiek23 4e versie: constructief Maak 2 dimensionaal arrays D(1…n, 1…n) en P(1…n,1…n) D = L; For i=1 to n do For j=1 to n do P(i,j) = “#” For k=1 to n do For i=1 to n do For j=1 to n do If (D(i,j) > D(i,k)+D(k,j) ) Then D(i,j) = D(i,k) + D(k,j); P(i,j) = k

Algoritmiek24 Construeer pad van i naar j Pathconstruct (P, D, i, j) If D(i,j) = , then return “Er is geen pad” If P(i,j) = “#”, then return pad met 1 pijl: (i,j). k = P(i,j); Pad1 = Pathconstruct(P,D,i,k); Pad2 = Pathconstruct(P,D,k,j); Plak paden Pad1 en Pad2 achterelkaar, en return dat pad.

Single source algoritmen Kan je zien als (menging van): –Greedy aanpak –Dynamisch programmeren Algoritmiek25

Algemeen principe: relaxatie Term relaxatie is ongelukkig en historisch Startknoop noemen we s Idee: elke knoop heeft een waarde d[v]: een schatting van de afstand d(s,v): –Initieel: d[s]= 0; voor alle andere v: d[v] =  Invariant van het algoritme: d[v] >= d(s,v) Relaxatiestap kijkt of we de schattingen kunnen verlagen terwijl we wel de invariant in stand houden Algoritmiek26

Relaxatie Relax (v,w) –{ (v,w) is een pijl in G} –If d[w] > d[v] + L(v,w) –Then d[w] = d[v]+ L(v,w) Behoud invariant Algoritmiek27 s v w

Greedy algoritme Initialiseer While Relax-stap mogelijk, doe er eentje Geeft in elk geval bovengrenzen op afstanden Geeft ook juiste waarden! Algoritmiek28

Stelling Stel er is geen cycle met negatieve lengte en er is geen Relax- stap mogelijk. Dan geldt voor elke knoop v: d(s,v)=d[v] Bewijs: Met inductie naar het aantal stappen op het kortste pad van s naar v: –0 stappen: s = v, d(s,s)=0=d(s), dus klopt –i+1 stappen: laat w de knoop voor v zijn op het kortste pad van s naar v –IH: d[w] = d(s,w) en d(s,v) = d(s,w)+L(w,v); geen relaxatie dus d[v] = d(s,v) dus d[v] = d[s,v] Algoritmiek29

Bellman-Ford Herhaal n-1 keer: –Voor alle pijlen (v,w): Relax(v,w) Voor alle pijlen (v,w) –If d[v]+L(v,w) > d[w] then return: negatieve cycle bereikbaar uit s Tijd: O(na) Algoritmiek30

Correctheid Bellman-Ford Stelling: Als er een pad van s naar v is met k kanten met lengte x, dan is na k iteraties van de hoofdloop van het algoritme d[v] <= x. Bewijs: met inductie naar k …(op bord) Uit stelling volgt correctheid: –Negatieve cycle bereikbaar uit s: relaxaties blijven altijd mogelijk –Geen negatieve cycle: elk kortste pad heeft hooguit n-1 pijlen Algoritmiek31

Algoritmiek32 Dijkstra’s algoritme Single source probleem: –Een startknoop s: wat is de afstand van s naar v, voor elke andere knoop v? –Nu: alle lengtes niet-negatief (veel toepassingen) Algoritme werkt niet correct zonder deze aanname. –Dijkstra’s algoritme gebruikt greedy aanpak

Algoritmiek33 Aanpak Relaxatie-techniek: –Knopen hebben waarde D(v): geeft bovengrens op d(s,v). –Algoritme werkt naar situatie dat voor alle v: D(v) = d(s,v) Knopen worden in twee verzamelingen verdeeld: –S: knopen waarvan we al weten dat D(v) = d(s,v) –C: knopen waarvoor we dit nog niet weten s S C

Algoritmiek34 Invarianten van algoritme 1.Voor elke knoop v: D(v)  d(s,v) 2.S, C deelverzamelingen van V met S = V – C. 3.Voor elke knoop v in S: D(v) = d(s,v). 4.Voor elke knoop w in C: D[w] is de lengte van het kortste pad van s naar w dat alleen s, w, en knopen in S gebruikt.

Algoritmiek35 Houdt invarianten in stand Initialisatie D[s] = 0; For alle pijlen (s,v) do D[v] = L(s,v); For all other vertices w do D[w] =  S = {s}; C = V – {s};

Algoritmiek36 Greedy Loop While C niet leeg do Kies een element v uit C waarvoor D[v] minimaal is t.o.v. de andere elementen uit C Haal v uit C en stop v in S For alle pijlen (v,w) do If D[w] > D[v] + L(v,w) then D[w] = D[v] + L(v,w) We gaan bewijzen dat voor deze v D[v] = d(s,v) We gaan bewijzen dat voor deze v D[v] = d(s,v) Relax(v,w)

Algoritmiek37 Lemma Invarianten blijven gelden. Bewijs (inductief) Gelden bij initialisatie 1: Er is een pad met die lengte 2: Triviaal 3: … 1.Voor elke knoop v: D(v)  d(s,v) 2.S, C deelverzamelingen van V met S = V – C. 3.Voor elke knoop v in S: D(v) = d(s,v). 4.Voor elke knoop w in C: D[w] is de lengte van het kortste pad van s naar w dat alleen s, w, en knopen in S gebruikt Dit noemen we voortaan een speciaal pad

Algoritmiek38 3. Voor elke knoop v in S: D(v) = d(s,v). Te bewijzen: de knoop v uit C met minimale waarde D[v] heeft D[v] = d(s,v). –IH: D[v] is lengte kortste pad met knopen s,v, en knopen in S. –Argument: elk pad naar v met andere knopen in C is minstens zo lang! w v S C Stel w eerste knoop in C op ander pad naar v: lengte pad is minstens D[w] + …  D[v] s Stukje pad is speciaal. I.H.

Algoritmiek39 4. Voor elke knoop w in C: D[w] is de lengte van het kortste speciale pad van s naar w Initieel OK. Kijk naar stap waar v in S komt, kijk naar w in C. 2 gevallen –Lengte kortste speciale pad van s naar w verandert niet: OK –Lengte kortste speciale pad van s naar w verandert wel. Moet via v gaan. Na v geen andere knopen meer uit S: anders langer. Speciale pad s … v w kan met lengte D[s]+L(v,w): deze waarde krijgt D[w].

Algoritmiek40 Stelling Dijkstra’s algoritme berekent voor elke v de afstand van s naar v. –Algoritme is klaar als alle v in S, dus voor alle v: D[v] = d(s,v).

Algoritmiek41 Implementatie S is niet nodig C: `priority queue datastructuur’: ADT met operaties: –Verkrijg element met minimum key waarde Gebeurt 1 keer per knoop: n keer –Verander (verlaag) key waarde van element Gebeurt hooguit 1 keer per kant:  a keer

Algoritmiek42 Verschillende priority queues Array –Minimum zoeken: lineaire scan: O(n) per keer –Update: O(1) per keer –O(n 2 ) tijd totaal Heap of binaire zoekboom –Minimum zoeken en update: O(log n) per keer –O((n+a) log n) tijd totaal

Hoe in ‘t echt? Kijk eens naar routebepaling op wegennetwerk Europa O(n+a) is al te veel… Technieken: –Bidirectional search –A* of goal-oriented search –Gebruik van hierarchie en preprocessing Algoritmiek43

Gebruik van hierarchie Highway node routing –Univ. Karlsruhe –Gelaagde structuur van netwerken: optimale route gebruikt lagen 1, 2, 3, … r-1, r, r-1, … 3, 2, 1 Partitioning using natural cuts –Microsoft research –Gebruikt dat er natuurlijke snedes in een wegenwerk zijn en partitioneert netwerk daarmee –Snedes worden met stromingstechnieken gevonden Algoritmiek44

Algoritmiek45 Negatieve lengtes Lengte kan `kosten’ zijn: soms negatief Wat gebeurt er als een cycle negatieve lengte heeft: –d(s,x) = -  Dijkstra’s algoritme werkt niet als er negatieve lengtes zijn. -3 s a b c x -2 2

Algoritmiek46 All pairs met negatieve lengte Algoritme werkt correct als er geen negatieve cycle is. Als er wel een negatieve cycle: er komt een v met D(v,v) <   0   01     0   01     0   01     1   0   01  -2 D(4,3)+D(3,4) = – = – 1

Algoritmiek47 Samenvatting All pairs –O(n 3 ) algoritme met dynamisch programmeren –Kan ook negatieve lengtes aan; detecteert negatieve cycles Single source –Dijkstra’s algoritme –O((n+a) log n) of O(n 2 ) implementaties; er bestaan asympotisch snellere –Alleen niet-negatieve lengtes Single pair: veel toepassingen, maar er zijn in O-notatie geen snellere algoritmen bekend –Wel in de praktijk (o.a. bidirectioneel zoeken, werken met schattingen, …)