Algoritmen voor routeplanning

Transcriptie

1 Faculteit Wetenschappen Vakgroep Toegepaste Wiskunde en Informatica Algoritmen voor routeplanning Katrien De Vos Promotoren : Prof. dr. V. Fack S. Vanhove Masterproef ingediend tot het behalen van de academische graad van Master in de Wiskundige Informatica Academiejaar

2 Voorwoord Allereerst wil ik mijn beide promotoren bedanken voor de steun en begeleiding. In het bijzonder Stéphanie Vanhove, voor het nalezen van enkele eerste versies en haar vele nuttige opmerkingen en suggesties die deze thesis ongetwijfeld een heel stuk verbeterd hebben. Daarnaast ook mijn familie en vrienden voor de steun en/of het nalezen op spelfouten. Zoals de titel al aangeeft, gaat deze thesis over algoritmen voor routeplanning. Dat deze algoritmen in de praktijk hun toepassing vinden, is wel duidelijk: naast allerhande GPS-toestellen, heeft ook Google zijn eigen routeplanner binnen Google Maps. Wanneer we een route willen plannen van punt A naar punt B, kunnen we dit op verschillende manieren realiseren. Zo kunnen we enkel rekening houden met de lengte van alle wegen die we kunnen nemen, of enkel de tijd die het gemiddeld kost om deze weg af te leggen. Dit is een bekend probleem uit de grafentheorie, namelijk het kortstepadprobleem, dat verder wordt besproken in hoofdstuk 2. Een andere mogelijkheid is dat we, naast afstand of tijdsduur, een aantal extra voorwaarden hebben, die moeilijker of niet te modelleren zijn. Een aantal voorbeelden zijn statements als minst drukke route, optimale route rond deze tijd van de dag, meest veilige route voor een fietser. Dit soort vragen worden doorgaans opgelost door niet één kortste pad, maar meerdere zeer korte paden te genereren en dan uit alle alternatieven de oplossing te kiezen die het best voldoet aan alle constraints. Dit probleem wordt ook wel het k-kortstepadenprobleem genoemd, waarbij k het aantal alternatieve paden is dat we genereren. Hoofdstuk 3 wijdt verder uit over dit probleem en de bestaande algoritmen om het op te lossen. i

3 In hoofdstukken 4 tot 7, worden vervolgens vier bestaande k-kortstepadalgoritmen, die voor deze thesis werden geïmplementeerd, in detail besproken. In hoofdstuk 8 worden deze algoritmen dan met elkaar vergeleken. Tenslotte, in hoofdstuk 9, herhalen we nog eens welk van de algoritmen het beste was, en om welke redenen. De auteur geeft de toelating om deze scriptie voor consultatie beschikbaar te stellen en delen van de scriptie te kopiëren voor persoonlijk gebruik. Elk ander gebruik valt onder de beperkingen van het auteursrecht, in het bijzonder met betrekking tot de verplichting de bron uitdrukkelijk te vermelden bij het aanhalen van resultaten uit deze scriptie. Katrien De Vos Gent, mei 2010

4 Inhoudsopgave 1 Inleiding Definities en gebruikte notaties Algemene details i.v.m. implementatie en testen Implementatie Testdata Testmethodiek Kortstepadprobleem Situering Algoritmen Algoritme van Dijkstra Implementatie en complexiteit k-kortstepadenprobleem Situering Algoritmen k-kortste wandelingen k-kortste paden Algoritme van Yen Algoritme Complexiteit Implementatie Testresultaten Algoritme van Hershberger, Maxel en Suri Het algoritme k-kortstepadenalgoritme iii

5 Inhoudsopgave iv Replacement Paths (Hershberger, Maxel en Suri) Correctheid Replacement Paths Complexiteit Implementatie Testresultaten Ideale Threshold Vergelijking algoritme met verschillende thresholds Algoritme van Roddity Algoritme k-kortste pad algoritme benaderend tweede kortste pad algoritme benaderend tweede kortste pad algoritme Parallelle Dijkstra algoritme Complexiteit Implementatie Testresultaten Tijdscomplexiteit in de praktijk Optimale threshold Correctheid van de k berekende paden Algoritme van Bernstein Algoritme Complexiteit Implementatie Testresultaten Thresholds Correctheid van de k berekende paden Vergelijking algoritmen Yen vs. Hershberger Yen vs. Roddity Yen vs. Bernstein Hershberger vs. Roddity vs. Bernstein Conclusies en Verder Werk 82

6 Hoofdstuk 1 Inleiding 1.1 Definities en gebruikte notaties Een gerichte gewogen graaf G = (V, E) is een koppel van verzamelingen, waarbij V de verzameling is van de toppen en E V V de verzameling van de bogen (koppels van toppen). Daarnaast bestaat er een afbeelding w : E R : e w(e) die aan alle bogen uit E een gewicht toekent. In deze thesis wordt de kardinaliteit van de toppenverzameling, V, korter weergegeven door n, en m staat voor de de kardinaliteit van de bogenverzameling, E. Een wandeling P = v 1... v i... v n in een graaf G is een opeenvolging van toppen v i V waarvoor geldt dat e i = (v i, v i+1 ) E voor alle 1 i < n. Een pad is een wandeling waarin elke top v i P juist één keer voorkomt. Een pad van v 1 naar v n wordt ook wel aangeduid met P (v 1, v n ), waarbij we v 1 de starttop noemen, en v n de doeltop. In deze thesis heten de start- en doeltop, tenzij anders vermeld, resp. s (voor start) en t (voor target). Het concateneren van twee paden wordt geschreven als ofwel P (s, v) + P (v, t), waarbij top v in het resulterende pad natuurlijk niet dubbel voorkomt, ofwel P (s, u) + P (v, t), wanneer er een boog bestaat van u naar v. 1

7 Hoofdstuk 1. Inleiding 2 Het kortste pad P 1 (s, t) van top s naar top t is het pad dat onder alle mogelijke paden van s naar t het kleinst mogelijke gewicht heeft. Hierbij wordt het gewicht van een pad P (v 1, v n ) gedefinieerd als weight(p ) = n 1 i=1 w(e i) (waarbij e i = (v i, v i+1 )). Analoog definiëren we het j-de kortste pad P j (s, t) van s naar t als het pad van s naar t dat, wanneer we alle paden van s naar t rangschikken in oplopende volgorde van hun gewicht, het j-de pad in de lijst is. 1.2 Algemene details i.v.m. implementatie en testen Implementatie Voor deze thesis werden vier k-kortstepadenalgoritmen geïmplementeerd in java. Dit gebeurde binnenin een bestaand framework voor kortstepadenalgoritmen, geschreven door S. Vanhove 1. De implementaties voor alle andere algoritmen, zoals Dijkstra, zijn deze uit het framework Testdata Als testdata werd de Karlsruhe data genomen. Deze data bestaat uit grafen die wegennetwerken in 17 Europese landen voorstellen als gerichte gewogen grafen, waarbij de gewichten op de bogen de reisafstanden zijn Testmethodiek De in deze thesis geïmplementeerde algoritmen werden getest door, voor elke test, het algoritme 4 keer na elkaar uit te voeren. Voor elk van deze 4 uitvoeringen werd gemeten hoe lang ze duurde, met behulp van java s System.currentTimeMillis(). Het eerste (vaak onbetrouwbare) resultaat werd genegeerd, en van de overblijvende resultaten werd de mediaan genomen. 1 Stéphanie Vanhove, Combinatorische algoritmen en algoritmische grafentheorie, Vakgroep Toegepaste Wiskunde en Informatica, Universiteit Gent

8 Hoofdstuk 2 Kortstepadprobleem 2.1 Situering Er bestaan verschillende varianten op het kortstepadprobleem (Engels: shortest path problem). Een aantal mogelijkheden: Gegeven een gerichte gewogen graaf G = (V, E) en twee toppen s V en t V, bepaal het kortste pad tussen deze twee punten. Gegeven een gerichte gewogen graaf G = (V, E) en een top s V, bepaal het kortste pad tussen s en elke andere top v V. Gegeven een gerichte gewogen graaf G = (V, E), bereken de kortste paden van elke top u V tot elke andere top v V (ook wel bekend als het all-pairs shortest path problem). Één van de eerste drie definities, met als bijkomende voorwaarde dat de gewichten op de bogen allemaal positief zijn. Één van de eerste drie definities, met als bijkomende voorwaarde dat de gewichten op de bogen ook negatief kunnen zijn. Het aantal verschillende definities voor dit probleem is een gevolg van het grote aantal toepassingsgebieden waarvoor het kan worden gebruikt. Enkele voorbeelden zijn grafenalgoritmen, computationele meetkunde, robotica, geografische informatiesystemen (GIS), netwerken en telecommunicatie, architectuur,... 3

9 Hoofdstuk 2. Kortstepadprobleem 4 In deze thesis houden we ons bezig met het berekenen van de k-kortste paden van top s naar top t in een graaf voor routeplanning. In grafen die routenetwerken voorstellen, kunnen we veronderstellen dat alle gewichten op de bogen positief zijn. We werken dus verder met volgende definities (welke van de twee wordt duidelijk uit de context): Definitie (Kortstepadprobleem). Gegeven een gerichte gewogen graaf G = (V, E) en ofwel twee toppen s V en t V, bepaal het kortste pad tussen deze twee punten. een top s V, bepaal het kortste pad tussen s en elke andere top v V. Waarbij geldt dat w(e) 0, e E. 2.2 Algoritmen Het aantal gekende algoritmen voor het kortstepadprobleem is zelfs nog groter dan het aantal definities. Zo zijn er het algoritme van Bellman- Ford (Bellman (1958); Ford & Fulkerson (1962)), geschikt voor grafen die ook negatieve gewichten kunnen hebben op de bogen en de algoritmen van Floyd-Warshall (Floyd (1962); Warshall (1962)) en Johnson (1977), die het all-pairs shortest path problem aanpakken. Voor grafen met uitsluitend positieve gewichten op de bogen, waarover we het hier hebben, zijn er ook heel wat algoritmen gekend. In Dreyfus (1969) worden een aantal algoritmen vergeleken, het meest efficiënte blijkt het algoritme van Dijkstra (1959). Het is op dit basisalgoritme dat de efficiëntste kortstepadalgoritmen zijn gebaseerd. Velen daaronder, zoals het A*-algoritme, zijn uitbreidingen van Dijkstra die heuristieken gebruiken om sneller tot een oplossing te komen Algoritme van Dijkstra In deze thesis wordt een implementatie van het algoritme van Dijkstra gebruikt, telkens wanneer een kortstepadalgoritme nodig is (zie algoritme 1 voor de pseudocode).

10 Hoofdstuk 2. Kortstepadprobleem 5 Algorithm 1 Algoritme van Dijkstra Input: graaf G(V, E), starttop s V, doeltop t V Output: Het kortste pad P in G van s naar t. 1: Q lege priority queue. 2: for all toppen v V \ {s} do 3: label(v) 4: Voeg v toe aan Q met key label(v) 5: end for 6: label(s) 0 7: parent(s) null 8: Voeg s toe aan Q met key label(s) 9: v s 10: while v t en Q do 11: for all bogen (v, n) E do 12: x label(v) + w(v, n) 13: if x < label(n) then 14: label(n) x 15: Wijzig de key van n in Q naar het nieuwe label(n) 16: parent(n) v 17: end if 18: end for 19: v verwijder element met laagste key uit Q. 20: end while 21: return De reeks van toppen die het kortste pad vormen van s tot t.

11 Hoofdstuk 2. Kortstepadprobleem 6 Het algoritme van Dijkstra kan geïmplementeerd worden voor beide mogelijkheden van de definitie. Bij de eerste mogelijkheid, met een gegeven starten doeltop, gaat het algoritme door totdat in stap 19 van algoritme 1 de doeltop verwijderd wordt (dus v = t). Wanneer enkel een starttop als input gegeven wordt, gaat het algoritme door tot alle toppen aan bod zijn gekomen, dus tot Q =. Definitie (kortstepadenboom). Tijdens zijn uitvoering bouwt het algoritme van Dijkstra een kortstepadenboom op. Dit is een deelgraaf van de inputgraaf G = (V, E), die de vorm heeft van een boom met wortel s. Binnen de kortstepadenboom T geldt voor alle toppen v T dat de afstand tussen s en v minimaal is. In algoritme 1 wordt de kortstepadenboom volledig bepaald door de functies label(v) en parent(v). Zie figuur 2.1 voor een voorbeeld. Figuur 2.1: Een voorbeeld van een kortstepadboom. In deze graaf zijn de takken van de kortstepadboom in kleur weergegeven Implementatie en complexiteit Stappen 2-5 in het algoritme worden doorgaans niet expliciet uitgevoerd. De labels van alle toppen worden pas geïnitialiseerd op wanneer deze top door het algoritme wordt bezocht (als buur n in de lus op lijn 11). De complexiteit van dit algoritme (algoritme 1) hangt af van de gebruikte datastructuur. Alle stappen kunnen gebeuren in constante tijd, behalve stap

12 Hoofdstuk 2. Kortstepadprobleem 7 4 en 15. Stap 4 ligt binnen een lus die n keer wordt uitgevoerd, dit geeft een complexiteit van O(n toevoegoperatie). Stap 15 wordt hoogstens m keer uitgevoerd, elke top v V zit hoogstens één keer in de queue en wordt dus ook hoogstens één keer gebruikt in de lus op lijn 11. Geen enkele boog (v, n) E zal in die lus dus meer dan een keer voorkomen. De complexiteit van de lus van lijn is dus O(m wijzig-keyoperatie). Indien we een gewone prioriteitswachtlijn gebruiken (zoals de klasse PriorityQueue in het java Collections framework), is de complexiteit O((m + n) log(n)). Deze heeft geen operatie om de key te wijzigen, dus moet hiervoor een gewone toevoegoperatie met de nieuwe key gebruikt worden, terwijl apart wordt bijgehouden welke toppen al bezocht zijn. Zowel de wijzig-keyoperatie als de toevoegoperatie hebben dus complexiteit O(log(n)). De snelste gekende datastructuur voor het algoritme is een Fibonacci Heap, die complexiteit O(log(n)) heeft voor een toevoegoperatie, maar een geamortiseerde O(1)-complexiteit voor de wijzig-key-operatie. Hierdoor kan het algoritme uitgevoerd worden met een tijdscomplexiteit van O(m + n log(n)). De implementatie die hier voor de testen gebruikt wordt, is een java-implementatie die gebruik maakt van de standaard java PriorityQueue klasse. Omdat de implementatie met Fibonacci Heap sneller is, wordt deze ook steeds vermeld. In de meeste algoritmen voor het berekenen van de k- kortste paden vormt de complexiteit van het kortstepadalgoritme trouwens een aparte factor, zodat de complexiteit met Priority Queue gemakkelijk te verkrijgen is uit die met Fibonacci Heap door de factor m + n log(n) te vervangen door (m + n) log(n).

13 Hoofdstuk 3 k-kortstepadenprobleem 3.1 Situering Het k-kortstepadenprobleem, waarover we het in deze thesis verder gaan hebben, kan als volgt gedefinieerd worden: Definitie (k-kortstepadenprobleem). Gegeven een gerichte gewogen graaf G = (V, E) en twee toppen s V en t V, bereken een lijst van k paden van s naar t. Zij P k het pad met het grootste gewicht in deze lijst, dan moet gelden dat er geen paden bestaan van s naar t met een gewicht strikt kleiner dan het gewicht van P k. Er bestaan verschillende redenen om dit probleem te bestuderen, waarvan de vier belangrijkste worden opgesomd in Eppstein (1998): Bijkomende constraints: Hierbij hebben we een kortstepadprobleem gegeven, waaraan een aantal constraints verbonden zijn die moeilijk te modelleren zijn. Een manier om dit probleem op te lossen, is om een gegeven aantal (k) alternatieve korte paden te genereren en dan daaruit verder te selecteren welk pad het beste voldoet aan de bijkomende constraints en toch nog kort genoeg is. Voorbeelden van dit probleem zijn hieronder terug te vinden. Evaluatie van modellen: We hebben een bepaald probleem gegeven, waarvoor een exacte oplossing gekend is, en dat we willen modelleren met behulp van paden. We 8

14 Hoofdstuk 3. k-kortstepadenprobleem 9 gaan dan na hoe goed het model presteert, door kortste paden op te sommen totdat we de exacte oplossing tegenkomen. Het getal k (het aantal gegenereerde kortste paden) kan dan gezien worden als een maat voor de juistheid van ons model. In het voorbeeld van Eppstein (1998) worden de mogelijke oplossingen van een automatisch vertaalprogramma gemodelleerd als paden. Een menselijke expert kan hier de juiste oplossing bepalen, waarna we met behulp van een k-kortstepadenalgoritme kunnen nagaan hoe goed ons model de oplossing benadert, of we kunnen deze informatie gebruiken om de parameters van het model aan te passen. Sensitivity analysis: Bij sommige problemen willen we niet alleen weten wat de beste oplossing (hier: het kortste pad) is, maar ook hoe sterk deze oplossing wijzigt wanneer een van de parameters in het probleem wijzigt. We berekenen dus niet één juiste oplossing, maar meerdere goede oplossingen en analyseren dan welk effect welke parameter van het probleem heeft. Het voorbeeld gegeven in Eppstein (1998) komt uit de biologie, namelijk het aligneren van twee DNA-sequenties. Daarbij wil men graag meerdere goede alignementen, zodat men kan bepalen welke delen van het alignment essentieel zijn. Generatie van alternatieven: Voor bepaalde problemen kan het nuttig zijn om en grotere klasse van oplossingen te genereren, om zodoende een beter beeld te krijgen van de structuur van het probleem. Eppstein (1998) vermeldt hier het voorbeeld van een automaat met een eindig aantal toestanden, waarvoor we niet enkel willen weten welke opeenvolging van toestanden leidt tot een fouttoestand, maar alle opeenvolgingen van toestanden met een kans, groter dan een bepaalde drempel, op een fouttoestand. Wanneer we ons bezighouden met routeplanning ligt de motivatie natuurlijk vooral bij de eerste reden. Zo kan iemand verkiezen om van plaats A naar plaats B te reizen via de minst drukke route, of zelfs subjectievere omschrijvingen zoals de mooiste route, of de meest toeristische. Dit levert ons, naast kortheid, nog een andere, mogelijks conflicterende parameter om te

15 Hoofdstuk 3. k-kortstepadenprobleem 10 optimaliseren. We krijgen dus geen unieke oplossing, maar een Pareto-front van (objectief gezien) gelijkwaardige oplossingen. Omdat de parameters van dit probleem moeilijk uniform te optimaliseren zijn (hoeveel belang hechten we aan de lengte van een route versus de drukte / schoonheid / toeristische factor?) is het eveneens belangrijk om meerdere gelijkwaardige alternatieven te kunnen opsommen. We kunnen immers theoretisch wel een pad berekenen dat zowel kort als mooi is, maar toch niet optimaal - zoals bijvoorbeeld een pad dat grotendeels door twee heel mooie natuurgebieden loopt, maar toch ook door het industriegebied daartussen. 3.2 Algoritmen Er bestaan twee varianten van dit probleem, die in de literatuur vaak met dezelfde naam benoemd worden: de versie van dit probleem waarbij het algoritme paden mag genereren die cykels bevatten (ook wel wandelingen genoemd), en de versie waarbij we garanderen dat elk van de gegenereerde paden geen cykels bevat (Engels: k shortest simple paths) k-kortste wandelingen De allereerste pogingen om het probleem van de k-kortste wandelingen op te lossen kwamen van (onder andere) Bock et al. (1957), Hoffman & Pavley (1959), Bellman & Kalaba (1960) en Sakarovitch (1966). De complexiteit van deze vroege algoritmen (als ze al werd vermeld), was meestal exponentieel. Als voorbeeld geven we het algoritme van Hoffman en Pavley (zie algoritme 2). Een deviation van een kortste pad P = s... b... t wordt daar gedefinieerd als een pad Q = s... a b... t, waarbij Q(s, a) en Q(b, t) kortste paden zijn van resp. s naar a en b naar t. Het algoritme berekent eerst het kortste pad P 1. Daarna berekent het voor elk volgende pad P j telkens een lijst met alle mogelijke deviations, dus voor alle paden P i met i < j, alle toppen b P i \ {s} en alle toppen a waarvoor (a, b) E berekenen we P (s, a) + P i (b, t), met P (s, a) het kortste pad van s naar a. Uit deze lijst wordt dan het pad gehaald met het kleinste gewicht, dit is P j.

16 Hoofdstuk 3. k-kortstepadenprobleem 11 Algorithm 2 N BEST PATHS (Hoffman en Pavley) Input: Graaf G, starttop s, doeltop t. Output: De k-kortste paden van s naar t in G. 1: P 1 het kortste pad van s naar t. 2: for all j van 1 tot k do 3: LIJST lege lijst. 4: for all i van 1 tot j do 5: for all toppen b P i do 6: for all bogen (a, b) E, met a V do 7: P kortste pad van s naar a. 8: P i,a,b P + P i (b, t) 9: Voeg P i,a,b toe aan LIJST. 10: end for 11: end for 12: end for 13: P j pad met kleinste gewicht in LIJST. 14: end for In 1975 ontwikkelde Fox (1975) een algoritme met complexiteit O(n 2 + kn log(n)). Een artikel van Eppstein (1998) geeft een algoritme met tijdscomplexiteit O(m+n log(n)+k), dat in 2003 verbeterd wordt door de lazy versie van Jiménez & Marzal (2003), die dezelfde worst-case complexiteit heeft, maar in de praktijk beter presteert k-kortste paden Wat het k-kortstepadenprobleem betreft, kwamen de eerste algoritmen van Pollack (1961), Clarke et al. (1963) en Sakarovitch (1966). Het algoritme met de tot nu toe beste tijdscomplexiteit werd ontwikkeld door Yen (1971). In hoofdstuk 4 wordt dit algoritme in detail besproken. Lawler (1972) veralgemeende dit algoritme tot een framework om de k beste oplossingen van een discreet optimalisatieprobleem te vinden. Daarna werden vooral algoritmen ontwikkeld met een bestaande worst-case complexiteit, die het in de praktijk veel beter doen. Voor dezelfde complexiteit als Yen hebben we zo de algoritmen van Brander & Sinclair (1995), Hadjiconstantinou & Christofides (1999), Martins & Pascoal (2003) en Her-

17 Hoofdstuk 3. k-kortstepadenprobleem 12 shberger et al. (2007). In hoofdstuk 5 wordt het algoritme van Hershberger, Maxel en Suri in meer detail besproken. Ook bestaan er een aantal exponentiële algoritmen die in de praktijk goed presteren, zoals de algoritmen van Perko (1986) en Martins et al. (1997). De tijdscomplexiteit van het algoritme van Yen is voor praktische problemen eigenlijk vrij slecht. Daarnaast kunnen we stellen dat voor de belangrijkste reden om de k kortste paden te berekenen, zoals hierboven beschreven, het niet echt nodig is om exact te weten wat de k kortste paden zijn, een lijst van k zeer korte paden volstaat. De algoritmen van Roddity (2007) en Bernstein (2010) zijn algoritmen met een betere tijdscomplexiteit dan Yen, die benaderingen berekenen voor het k-kortstepadenprobleem. Ze worden in meer detail besproken in hoofdstukken 6 en 7.

18 Hoofdstuk 4 Algoritme van Yen 4.1 Algoritme Het algoritme van Yen (1971) vertrekt van het feit dat het j-de kortste pad steeds in een top s v < t moet afsplitsen van een l-de kortste pad, l < j. Beschouwen we dus de verzameling van alle kortste paden die van P l afsplitsen in v, voor elk l-de pad P l (l < j) en voor elke top v op dat pad, dan moet het pad P j in deze verzameling zitten. Een voorbeeld (zie figuur 4.1). We zien dat P 2 afsplitst van P 1 in top s P 1. Het pad P 2 zit dus in de verzameling van alle kortste paden die van P 1 afsplitsen in een top v (hier: v = s). P 3 splitst af van P 1 in top a en van P 2 in top s. Het pad P 3 zit in de verzameling van alle kortste paden die van P 1 of P 2 afsplitsen in een top v (hier: v = a resp. v = s). Concreet gezien berekent het algoritme van Yen eerst het kortste pad P 1 met een kortstepadalgoritme, zoals Dijkstra. Elk volgende kortste pad wordt dan berekend door in elke stap j (1 < j k) voor het gevonden j-de kortste pad alle kortste paden te berekenen die van dat pad afsplitsen en deze bij te houden in een queue B. Dit wordt beschreven in algoritme 3. Het j + 1-ste pad zal dan in deze queue zitten. Om het kortste pad te berekenen dat van een pad P j afsplitst in een top v i (1 i < P j ) verbieden we alle toppen die voor v i op het pad P j liggen. Daarnaast moeten we, voor alle paden P l (l j) die we al gevonden hadden en die het gedeelte van de starttop tot v i met P j gemeen hebben, de boog (v i, v i+1 ) verbieden die in P l op v i volgt. Dit om te vermijden dat het 13

19 Hoofdstuk 4. Algoritme van Yen 14 Figuur 4.1: Een graaf met drie paden van s naar t. Het kortste pad P 1 is aangeduid in blauw, het tweede kortste pad P 2 in groen, het derde kortste pad P 3 met stippellijnen. algoritme opnieuw het pad P l genereert. Op deze manier vinden we, als het bestaat, een pad van v i naar de doeltop t. Het deel van de starttop s naar v i in het nieuwe pad is natuurlijk gewoon gelijk aan ditzelfde deel in P j, en we kunnen beide delen concateneren. In het voorbeeld in figuur 4.1 gaat dit als volgt, voor P j = P 1 en v i = a. Alle toppen voor v i worden verboden, dit is hier enkel top s, evenals de boog (a, b) P 1. Nu is het kortste pad van a naar t gelijk aan P 3 (a, t) = a d t. We concateneren dit met P 1 (s, a) en krijgen P 3, het kortste pad dat van P 1 afsplitst in a. Beschouwen we nu, voor een j-de kortste pad P j, de grootst mogelijke index q van een top in P j waarvoor er een korter pad P l bestaat dat de eerste q toppen met P j gemeenschappelijk heeft. Dan kunnen we aantonen dat voor alle toppen v i op P j met indices i strikt kleiner dan q, het kortste pad dat in v i afsplitst van P j reeds in de queue B zit. Stelling. Gegeven de j kortste paden P 1,..., P j van s naar t. Zij q de grootst mogelijke index van een top in P j waarvoor er een korter pad P l bestaat dat de eerste q toppen met P j gemeenschappelijk heeft. Dan geldt voor de q 1 eerste bogen (lus lijn 5) van pad P j, dat dezelfde berekening reeds voor een pad P m met m < j werd uitgevoerd (lus lijn 3). Bewijs. We bewijzen uit het ongerijmde, dat voor elke iteratie i < q van de binnenste lus (lijn 5) geldt, dat er een iteratie van de buitenste lus (lijn 3) m < j bestaat, waarvoor geldt dat in de i-de iteratie V ij = V im en

20 Hoofdstuk 4. Algoritme van Yen 15 Algorithm 3 Algoritme van Yen Input: starttop s, eindtop t, aantal paden k. Output: de k kortste paden van s naar t. 1: P 1 het kortste pad van s naar t 2: B lege queue. 3: for all j van 1 tot en met k 1 do 4: V 1j V 5: for all i van 1 tot en met P j 1 do 6: E ij E 7: for all l van 1 tot en met j do 8: if P l (v 1, v i ) = P j (v 1, v i ) then 9: E ij E ij \ {(v i, v i+1 )}, v i+1 P l 10: end if 11: end for 12: P het kortste pad van v i naar t in G(V ij, E ij ) 13: P P j (s, v i ) + P 14: Voeg P toe aan queue B 15: V i+1,j V ij \ {v i } 16: end for 17: P j+1 haal het kortste pad uit queue B. 18: end for E ij = E im op lijn 12. Hieruit volgt onmiddellijk dat voor de i-de iteratie van de binnenste lus, op lijn 12 dezelfde berekening wordt uitgevoerd in iteratie m als in iteratie j, en dit voor alle bogen (v i, v i+1 ) met i < q. We gaan dus uit van de veronderstelling dat er geen iteratie m (buitenste lus) bestaat met m < j waarvoor geldt dat in de i-de iteraties van de binnenste lus V ij = V im en E ij = E im (*). Het is duidelijk dat V ij = V im als en slechts als P j (s, v i ) = P m (s, v i ) (lijn 15). We weten dat voor het pad P l geldt dat P j (s, v q ) = P l (s, v q ), en omdat i < q geldt dus ook dat P j (s, v i ) = P l (s, v i ). De verzameling {m < j P m (s, v i ) = P j (s, v i )} is dus niet leeg. Neem m het grootste element in deze verzameling, dus m = max{m < j P m (s, v i ) = P j (s, v i }. Lijn 8-10 van het algoritme geeft dat E ij enkel die bogen (v i, b) E bevat

21 Hoofdstuk 4. Algoritme van Yen 16 die niet in een eerder pad l op top v i volgden, terwijl P l (s, v i ) = P j (s, v i ): (v i, b) / E ij l j : (v i, b) P l P l (s, v i ) = P j (s, v i ) Omdat V ij = V im en vanwege (*) moet nu gelden dat E ij E im (**). Anders gezegd mag niet gelden, voor alle (v i, b) E: (v i, b) E ij (v i, b) E im Nu geldt wel dat: (v i, b) / E im l m : (v i, b) P l P l (s, v i ) = P m (s, v i ) l j : (v i, b) P l P l (s, v i ) = P j (s, v i ) (v i, b) / E ij En dus (v i, b) E ij (v i, b) E im, m.a.w. E ij E im Gecombineerd met (**) weten we dus dat E im minstens één boog (v i, b) moet bevatten die niet in E ij zit, dus: (v i, b) E : (v i, b) / E ij (v i, b) E im (v i, b) E : l j : (v i, b) P l P l (s, v i ) = P j (s, v i ) ( l m : (v i, b) P l P l (s, v i ) = P m (s, v i )) Met andere woorden, een dergelijk rangnummer l of l moet kleiner zijn dan of gelijk aan j, maar mag niet kleiner dan of gelijk aan m zijn. De enige mogelijkheid die dus overblijft, is dat het rangnummer l van het pad P l dat deze boog (v i, b) bevat tussen m en j zou liggen: (v i, b) E : m < l j : (v i, b) P l P l (s, v i ) = P j (s, v i ) Dit is tegenstrijdig met de aanname dat m de grootst mogelijke stap l is waarin P l (s, v i ) = P j (s, v i ). We kunnen dus concluderen dat er een stap m < j bestaat waarvoor V m = V j en E m = E j.

22 Hoofdstuk 4. Algoritme van Yen 17 Als gevolg van deze stelling kunnen we dus het algoritme van Yen licht verbeteren. Gegeven de grootste index q waarvoor P j (s, v q ) = P l (s, v q ), l < j, moeten we enkel deze paden zoeken die afsplitsen in een top v i P j met i q. Het aangepaste algoritme wordt gegeven in algoritme 4. Algorithm 4 Algoritme van Yen (aangepast) Input: starttop s, eindtop t, aantal paden k. Output: de k kortste paden van s naar t. 1: P 1 het kortste pad van s naar t 2: B lege queue. 3: q 1, E j E 4: for all j van 1 tot k do 5: V j V \ {v v P j (s, v q )} 6: for all i van q tot en met P j 1 do 7: E i E j \ {(v i, v i+1 )} 8: P het kortste pad van v i naar t in G(V j, E i ) 9: P P j (s, v i ) + P 10: Voeg P toe aan queue B 11: V j V j \ {v i } 12: end for 13: P j+1 haal het kortste pad uit heap H. 14: q grootst mogelijke index van een top waarin P j+1 afsplitst van een korter pad P l. 15: P l pad waarvan P j+1 afsplitst (dus P j (s, v q ) = P l (s, v q )) 16: E j+1 verzameling E q uit stap l 17: end for 4.2 Complexiteit We bekijken de tijdscomplexiteit van algoritme 4. Binnenin de lus van lijn 6 tot 12 heeft lijn 8 de grootste complexiteit. Een uitvoering van het algoritme van Dijkstra kost O(m + n log(n)) operaties (zie subsectie 2.2.2). Lijn 9 is lineair in n, lijn 10 heeft, afhankelijk van de gebruikte datastructuur voor de queue B, complexiteit O(1) of O(log(n)). Zowel lijn 7 als lijn 11 kunnen in constante tijd verwezenlijkt worden. In

23 Hoofdstuk 4. Algoritme van Yen 18 totaal geeft dat voor deze lus een complexiteit van O(n(m + n log(n))) Het is mogelijk om de stappen in lijn 5, 14, 15 en 16 in constante tijd uit te voeren. Stap 13 is weer afhankelijk van de gebruikte datastructuur van de queue B, maar is hoogstens lineair in n. De complexiteit van de buitenste lus van lijn 4 tot 17 wordt dus vooral bepaald door die van de binnenste lus, wat een totale complexiteit van O(kn(m + n log(n))) oplevert. Omdat lijn 1 complexiteit O(m + n log(n)) heeft, en lijn 2 en 3 complexiteit O(1), is dit meteen de totale complexiteit van het algoritme van Yen (1971). 4.3 Implementatie In de implementatie van het algoritme van Yen werd de queue B geïmplementeerd als een PriorityQueue. In plaats van de paden te concateneren in stap 9, werd voor elk dergelijk pad P gewoon een verwijzing bijgehouden naar het pad P j waarvan het afsplitst, samen met de index van de laatste top die de paden gemeenschappelijk hebben. Een eerste opvraging van het i-de kortste pad duurt hierdoor langer (hoogstens lineair in de lengte van het pad), omdat het pad nog moet worden samengesteld. De achterste delen van de paden werden bijgehouden in een lijst, met het i-de pad op plaats i 1 in de lijst. Naast een verwijzing naar het vorige pad wordt aan een nieuw pad P in stap i van de lus in lijn 6-12 ook de verzameling E i, van de bogen die vanuit v i verboden zijn, en de verzameling V j, van alle toppen die op P j voor i liggen, doorgegeven. wordt aangemaakt. Lijn 5, 7 en 16 worden dus uitgevoerd wanneer het pad P 4.4 Testresultaten Voor de kleinste zes grafen uit deze reeks (Tsjechië, Luxemburg, Ierland, Portugal, Finland en België) werd telkens voor een random start- en doeltop de 250 kortste paden gegenereerd met behulp van het algoritme van Yen. De resultaten van de tijdsmetingen, samen met tijdsmetingen voor één uitvoering van het algoritme van Dijkstra, zijn te zien in tabellen 4.1 en 4.2. De tijdsmetingen voor Dijkstra werden bekomen door het algoritme 100 keer

24 Hoofdstuk 4. Algoritme van Yen 19 na elkaar uit te voeren en de resulterende tijd te delen door 100 (dit voor dezelfde start- en doeltoppen als bij de testen voor het algoritme van Yen). Wanneer we de tijdsmetingen voor de k kortste paden vergelijken met die voor één uitvoering van Dijkstra, zien we dat, zelfs voor deze relatief kleine grafen, het verschil al snel oploopt. Het algoritme van Yen voor k = 250 is keer (kleinste 2 grafen) tot keer (grootste graaf) trager dan een uitvoering van Dijkstra (zie ook figuur 4.2). Figuur 4.2: Resultaat van de tijdsmetingen voor het algoritme van Yen, voor de grafen Luxemburg en Finland. In de grafiek (figuur 4.2) en tabellen (tabellen 4.1 en 4.2) kunnen we ook zien dat de uitvoeringstijd inderdaad lineair is in k. Lineariteit in n is moeilijker te zien, doordat de factor n in de tijdscomplexiteit staat voor de slechtst mogelijke situatie. In de praktijk zal het immers niet voorkomen

25 Hoofdstuk 4. Algoritme van Yen 20 dat elk nieuw pad P j (j < k) n toppen bevat (en er dus n uitvoeringen van Dijkstra nodig zijn). Hoe veel sneller het algoritme gaat, hangt sterk af van de structuur van de graaf en is dus voor elke graaf en elke start- en doeltop verschillend.

26 Hoofdstuk 4. Algoritme van Yen 21 Tabel 4.1: Resultaten van de tijdsmetingen (in seconden) voor het algoritme van Yen (deel 1). Graaf k Yen Dijkstra Tsjechië 1 0,904 0, toppen 5 2, bogen 10 3, , , , , ,038 Luxemburg 1 1,092 0, toppen 5 1, bogen 10 3, , , , , ,316 Ierland 1 1,341 0, toppen 5 3, bogen 10 7, , , , , ,63

27 Hoofdstuk 4. Algoritme van Yen 22 Tabel 4.2: Resultaten van de tijdsmetingen (in seconden) voor het algoritme van Yen (deel 2). Graaf k Yen Dijkstra Portugal 1 2,745 0, toppen 5 5, bogen 10 10, , , , , ,024 Finland 1 35,24 0, toppen 5 54, bogen 10 87, , , , , ,482 België 1 172,224 0, toppen 5 547, bogen , , , , , ,418

28 Hoofdstuk 5 Algoritme van Hershberger, Maxel en Suri 5.1 Het algoritme k-kortstepadenalgoritme Ook in het artikel van Hershberger et al. (2007) wordt opgemerkt dat de k kortste paden stukken pad gemeenschappelijk hebben. Elke twee paden P i en P j (0 < i, j < k) volgen hetzelfde pad tot in een zekere top c, waarna ze zich van elkaar afsplitsen. De paden kunnen dus worden voorgesteld in een boomstructuur, waarbij in de boom een pad voorkomt van starttop s tot top c, dat de bundel kortste paden voorstelt die hetzelfde pad in de graaf volgen van s tot c als P i en P j. Daarnaast zijn er twee paden van top c tot t i en tot t j, die het deelpad van c tot de doeltop t in P i resp. P j voorstellen. De takken van deze boomstructuur stellen bundels van gemeenschappelijke deelpaden in de graaf voor. De toppen van de boom zijn de toppen in de graaf waar de bundels kortste paden zich opsplitsen. Deze boomstructuur wordt in het artikel Path Branching Structure (PBS) genoemd. Een voorbeeld is te zien in figuur 5.1. Merk op dat een top meerdere keren kan voorkomen in de boomstructuur, de doeltop t komt zelfs k keer voor. De takken in de Path Branching Structure stellen paden voor in de graaf (de tak (b, t P2 ) stelt bijvoorbeeld het pad b d f t voor). 23

29 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 24 Figuur 5.1: Links: een graaf met vier kortste paden P 1 = s a b e f t, P 2 = s a b d f t, P 3 = s a c e f t en P 4 = s a c d f t. Rechts staat de Path Branching Structure van deze graaf. De notaties naast de takken geven aan welke paden die tak volgen. Een pad dat nog niet vertegenwoordigd is in de Path Branching Structure zal van één of meerdere kortste paden afsplitsen in een top u van de graaf. Er zijn twee mogelijkheden: ofwel is u een top in de PBS, ofwel ligt u op een deelpad dat correspondeert met een tak in de PBS (voor een voorbeeld, zie figuur 5.2). Dit leidt tot twee soorten equivalentieklassen van paden. Definitie. Een equivalentieklasse C(a) van een top a uit de PBS bevat alle paden die in de graaf het pad van de starttop naar a volgen, maar daarna de boog vertrekkend uit top a niet meer gemeenschappelijk hebben met paden die overeenkomen met uitgaande takken van top a. Definitie. Een equivalentieklasse C(a, b) van een tak (a, b) in de PBS bevat alle paden die in de graaf het pad van de starttop naar a volgen, en dan op het pad van a naar b, corresponderend met tak (a, b), afsplitsen van de bundel kortste paden die het pad van de starttop tot b volgen.

30 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 25 Figuur 5.2: Links: een graaf met als kortste pad P 1 = a b c d. Rechts staat de Path Branching Structure van deze graaf, met twee toppen a en d 1 en een tak (a, d 1 ) die het kortste pad voorstelt. Er zijn twee andere paden in de graaf. Pad a e f d splitst af van P 1 in top a, een top in de PBS. Pad a b c f d splitst af in top c, die op het deelpad b c ligt dat overeenkomt met tak (a, d 1 ) in de PBS. Alle mogelijke paden die nog niet in de Path Branching Structure zitten, zitten dus in juist één equivalentieklasse. Om, gegeven een Path Branching Structure van de k kortste paden, het k+1-ste kortste pad te berekenen, moeten we dus voor elke mogelijke equivalentieklasse gerelateerd aan de PBS het kortste pad berekenen. Het k+1-ste kortste pad is dan het kortste van al die kortste paden (zie algoritme 5). Voor een equivalentieklasse van een top C(u) is het kortste pad eenvoudig te berekenen als de concatenatie van het pad van de starttop tot u, zoals gegeven door de Path Branching Structure, en het kortste pad van u naar de doeltop t. In dit kortste pad van u naar t zijn de toppen op het pad van de starttop tot u verboden, alsook de startbogen (u, x) van paden corresponderend met de takken (u, v) die in de PBS uit top u vertrekken. Dit kortste pad is eenvoudig te berekenen met het algoritme van Dijkstra, waarbij enkele bogen verboden worden. Het kortste pad in de equivalentieklasse van een tak C(u, v) is iets moeilijker te berekenen. Een naïeve methode is om voor elke top w op het pad van u naar v in de graaf het kortste pad te berekenen dat daar afsplitst. Als er l toppen liggen tussen u en v, komt dit overeen met l keer het kortste pad berekenen voor een klasse C(w j ), 0 < j l. Een minder voor de hand

31 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 26 Algorithm 5 K SHORTEST PATHS (Hershberger, Maxel en Suri) Input: Graaf G, starttop s, doeltop t. Output: De k-kortste paden van s naar t in G. 1: Initialiseer de Path Branching Structure zodat ze enkel de starttop s bevat, voeg path(s, t) toe aan de heap. 2: for all i van 1 tot k do 3: Haal het kortste pad P van de heap. 4: if P hoort bij een equivalentieklasse C(u) voor een top u then 5: Voeg nieuwe tak (u, t P ) toe aan de PBS, die het deelpad van P voorstelt van u naar t. 6: Creëer een nieuwe klasse C(u, t P ) van alle paden die na u tenminste de eerste boog met P gemeen hebben. 7: else (P hoort bij een equivalentieklasse C(u, v) voor een tak (u, v)) 8: Stel w de top waar P afsplitst van het pad voorgesteld door de tak (u, v). 9: Voeg een nieuwe top w toe aan de PBS en splits de tak (u, v) in twee nieuwe takken (u, w) en (w, v). 10: Voeg een nieuwe tak (w, t P ) toe aan de PBS die het deelpad van P voorstelt van w naar t. 11: Herverdeel de paden in C(u, v) in vier nieuwe klassen C(u, w), C(w, v), C(w, t P ) en C(w). 12: end if 13: Bereken de kortste paden voor de 2 of 4 nieuwe equivalentieklassen en voeg ze toe aan de heap. 14: end for

32 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 27 liggende, maar snellere methode is het Replacement Paths algoritme van Hershberger en Suri. In bepaalde gevallen kan dit algoritme falen. Dit falen kan echter gedetecteerd worden, waarna we kunnen overschakelen op het naïeve algoritme om een correct resultaat te bekomen Replacement Paths (Hershberger, Maxel en Suri) In dit algoritme (zie algoritme 6) worden twee kortstepadbomen opgesteld op de graaf H = G \ path(s, u) (met s de starttop), boom X van top x naar alle toppen (waarbij x de opvolger is van u in het pad van u tot v) en boom Y van alle toppen naar doeltop t. Het kortste pad P van u naar v moet in beide bomen voorkomen. Daarna wordt voor elke boog e i op het pad P een boom X i = X \ e i geconstrueerd. Een replacement edge (a, b) voor e i is een boog verschillend van e i die de beide delen van X i terug aan elkaar plakt. Het bijbehorende replacement path is het pad van x tot a in X, gevolgd door het pad van b tot t in Y. Het replacement path met het kleinste gewicht is dan het kortste pad van u naar t dat afsplitst tussen u en v. Algorithm 6 REPLACEMENT PATHS (Hershberger, Maxel en Suri) 1: Stel graaf H = G \ path(s, u), P het kortste pad van x (opvolger van u in het kortste pad van u tot v) tot v. 2: Bereken kortstepadboom X van x tot alle toppen. Het kortste pad van x tot t moet voorkomen in X. 3: Bereken kortstepadboom Y van alle toppen naar doeltop t. 4: for all edges e i = (v i, v i+1 ) P do 5: X i = X \ e i, de boom wordt in twee componenten gesplitst. 6: E i is de verzameling van alle bogen (a, b) in E \ e i waarij a in dezelfde component van X i zit als x, en b in de andere component. 7: for all (a, b) E i do 8: Bereken P athw eight(a, b) = d(x, a)+w(a, b)+d(b, y) (in constante tijd m.b.v. X en Y ). 9: end for 10: De Replacement Distance voor e i is min (a,b) Ei P athw eight(a, b). 11: end for In een bepaald geval kan dit algoritme ook falen. Een voorbeeld wordt gegeven in figuur 5.3. In deze graaf zoeken we het tweede kortste pad van

33 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 28 x naar y. Voor de boog e 1 = (a, b) geldt dat (x, v) een replacement edge is - in de kortstepadboom zonder e 1, X 1 (zie de blauwe bogen in figuur 5.3) vormt deze boog een verbinding tussen beide componenten. Het bijhorende replacement path bestaat uit boog (x, v) en het kortste pad van v naar y. Dit pad bevat echter weer boog (a, b), net de boog die we wilden vervangen. Het juiste resultaat voor het tweede kortste pad dat (a, b) niet bevat is het pad x v y. Figuur 5.3: Een voorbeeldgraaf waarvoor het Replacement Paths algoritme van Hershberger en Suri faalt. We zoeken het tweede kortste pad van x naar y, het kortste pad is met gele toppen aangeduid. De voorwaartse kortstepadboom is met blauwe bogen aangeduid, de achterwaartse kortstepadboom met stippellijnen. Het is de boog (a, b) die we willen verwijderen. Het is mogelijk om, gegeven het resultaat van het algoritme, dit falen te detecteren en dan alsnog over te gaan op de naïeve implementatie voor die bepaalde klasse C(u, v). Gegeven het kortste pad P = u u 1 u 2... u l 2 v van u naar v en het pad BY van b naar t uit het resultaat, bereken de kleinste index i waarvoor u i voorkomt in BY. Het algoritme faalt als en slechts als deze index i kleiner is dan of gelijk aan de index van w in P, met w het punt waar het tweede kortste pad van u naar v van P afsplitst Correctheid Replacement Paths Het bewijs hieronder toont aan dat door het aan elkaar plakken van paden uit de voorwaartse en achterwaartse kortste paden geen cykels kunnen ontstaan. In dit bewijs wordt ook duidelijk dat er, naast de situatie beschreven in het artikel, nog een andere manier is waarop dit algoritme kan falen -

34 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 29 namelijk wanneer er cykels met gewicht 0 in de graaf zitten. Dit komt in de praktijk in wegennetwerken natuurlijk niet voor, en is overigens met een kleine aanpassing in het algoritme te verhelpen (zie tweede stelling). Figuur 5.4: Een kortste pad P 1 = x... v i... v j... y en tweede kortste pad P 2 = x... v i... a b... v j... y. Volle lijnen zijn bogen, de streepjeslijnen geven aan dat de boog een pad voorstelt van 0 of meer bogen, de stippellijnen een pad van 1 of meer bogen. Één van de bogen tussen v i en v j wordt verboden, de boog (a, b) plakt de componenten weer aan elkaar. Stelling. (zie ook figuur 5.4). Gegeven G, een gewogen gerichte graaf, waarvoor alle gewichten op de bogen strikt positief zijn (w(e) > 0, e E). Zij P 1 = x... v i... v j... y het kortste pad in de deelgraaf H van G. Gegeven alle paden P van de vorm P = x... v i... a b... v j... y, voor alle v i, v j P 1 met i < j (dus in P 1 ligt minstens 1 boog tussen v i en v j ). Voor P X = x... v i... a P geldt dat P X X, de kortstepadboom van x naar alle toppen en analoog geldt voor P Y = b... v j... y P dat P Y Y, de kortstepadboom van alle toppen naar y. v i (v j ) is de laatste (eerste) top van P 1 die in P X (P Y ) voorkomt. Zij P 2 het pad met het kleinste gewicht onder alle paden P van deze vorm (dit is het pad bekomen door algoritme 6). Dan geldt dat P 2 geen cykels bevat. Bewijs. We bewijzen de stelling uit het ongerijmde. De paden P X en P Y kunnen geen cykels bevatten (want ze zijn deel van de kortstepadboom). P 2 kan dus enkel een cykel bevatten wanneer de concatenatie P X + P Y van P X en P Y is van de vorm: x... d... a b... d... y

35 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 30 waarbij d de eerste top op P 2 is die een tweede keer op het pad voorkomt. d kan gelijk kan zijn aan alleen a, ofwel aan alleen b, ofwel aan geen van beide. Stel W = weight(d... a b... d). In dit geval zal altijd een boog (a, b ) bestaan die een korter pad P 2 = x... v i... a b... v j... y oplevert (v i resp. v j niet noodzakelijk gelijk aan v i resp. v j ), wat tegenstrijdig is met de aanname dat P 2 het kortste dergelijke pad was. Er zijn 4 verschillende mogelijkheden wanneer P 2 een cykel bevat (zie figuren 5.5(a) tot 5.5(d)). Het is onmiddellijk duidelijk dat de situatie in figuur 5.5(a) niet kan voorkomen. Dit zou immers betekenen dat het kortste pad P 1 een cykel bevatte. Ook de situatie in figuur 5.5(b) is niet geldig. Wanneer we immers de voorwaartse kortstepadboom bekijken (met blauw aangeduid), zien we dat top d daarin twee keer zou moeten voorkomen. Voor figuur 5.5(c) en 5.5(d) beschouwen we het deelpad van de tweede d op P 2 tot v j, P 2 (d, v j ) = d d 1... d l v j (met l 0). Definitie. Een top d i H hangt aan een top v k P 1 a.s.a. v k de laatste top van P 1 is op het pad van x naar d i in de voorwaartse kortstepadboom X. Nu geldt in figuur 5.5(c) dat d aan zichzelf hangt, en in figuur 5.5(d) hangt d aan v i in de voorwaartse kortstepadboom. Om beide situaties te kunnen veralgemenen definiëren we de index i als de index in P 1 van d (in het eerste geval) of van v i (in het tweede geval). We weten dus dat een eindig aantal toppen in P 2 (d, v j ) ook aan v i hangt (minstens d = d 0 ). Stel i de index van de laatste top in P 2 (d, v j ) die nog aan v i hangt. Deze index i is kleiner of gelijk aan l, omdat we weten dat v j aan zichzelf, en dus niet aan v i hangt. Nu zijn er twee mogelijkheden voor d i+1 : Figuur 5.6(a): d i+1 hangt aan een top v l met l > i. Dan is (d i, d i+1 ) een Replacement Edge voor boog e i P 1, en het pad P 2 = x... v i... d i d i+1... v j...y bevat geen cykel meer.

36 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 31 (a) (b) (c) (d) Figuur 5.5: Verschillende mogelijkheden voor de locatie van de cykel in P 2. (Gedeeltelijke) voorwaartse kortstepadbomen zijn in blauw aangeduid. Toppen die hierin niet bereikt worden liggen uiteraard ook in de boom, maar niet via weergegeven bogen. Figuur 5.6(b): d i+1 hangt aan een top v l met l < i. Hier geldt weer dat er een eindig aantal toppen aan v l hangen. Noem d a de laatste dergelijke top. Voor d a+1 hebben we dan dezelfde twee mogelijkheden als voor d i+1 : ofwel komen we terecht in het geval hierboven (met als

37 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 32 resultaat een pad P 2 = x... v l d i+1... d a d a+1... v j...y), ofwel opnieuw in dit geval. Maar hoe vaak we ook in dit geval terechtkomen, uiteindelijk wordt d a = d l en d a+1 = v j en gaan we dus naar geval 5.6(a). (a) d i+1 hangt aan een top v l met l > i (b) d i+1 hangt aan een top v l met l < i Figuur 5.6: Mogelijkheden voor top d i+1 die niet meer aan v i hangt. We weten nu ook dat weight(p 2 ) weight(p 2) W < weight(p 2 ), wat tegenstrijdig is met de veronderstelling dat P 2 het kleinste gewicht had onder alle paden van de vorm P. In het geval W = 0 bestaat er wel een pad P 2 waarin de cykel niet voorkomt (constructie zoals in het bewijs hierboven), maar hier geldt weight(p 2 ) weight(p 2 ) W = weight(p 2 ). Indien weight(p 2 ) < weight(p 2) bestond er een pad van de vorm P met een kleiner gewicht dan P 2 en hebben we dus een tegenstrijdigheid. Wanneer echter weight(p 2 ) = weight(p 2), voldoen zowel

38 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 33 P 2 als P 2 aan het gegeven. Dit vormt een tegenvoorbeeld voor de stelling, in het geval W = 0. Hieruit kunnen we concluderen dat de vereiste dat P 2 het kleinste gewicht moet hebben onder alle paden van die vorm, niet voldoende is wanneer er cykels kunnen onststaan met gewicht 0. Wanneer we de voorwaarde toevoegen dat P 2, naast het kleinste gewicht, ook het kleinste aantal bogen (lengte) van alle paden met dat gewicht moet hebben, kan de stelling wel bewezen worden.. Stelling. Zij P 1 = x... v i... v j... y het kortste pad in de deelgraaf H. Gegeven alle paden P van de vorm P = x... v i... a b... v j... y, voor alle v i, v j P 1 met i < j (dus in P 1 ligt minstens 1 boog tussen v i en v j ). Voor P X = x... v i... a geldt dat P X X, de kortstepadboom van x naar alle toppen en analoog geldt voor P Y = b... v j... y dat P Y Y, de kortstepadboom van alle toppen naar y. v i (v j ) is de laatste (eerste) top van P 1 die in P X (P Y ) voorkomt (zie figuur 5.4). Stel P 2 gelijk aan het pad van die vorm met het kleinste gewicht en de kleinste lengte (kleinste aantal bogen) onder alle paden met hetzelfde gewicht. Dan geldt dat P 2 geen cykels bevat. Bewijs. We bewijzen ook deze stelling uit het ongerijmde. Zij W gedefinieerd zoals in het vorige bewijs, dan hebben we hier twee mogelijkheden: 1. W > 0 Dit is het vorige bewijs. 2. W = 0 Construeer P 2 uit P 2 zoals in het vorige bewijs. Omdat P 2 een cykel bevat worden er minstens 2 bogen verwijderd, waardoor geldt length(p 2 ) length(p 2) 2 < length(p 2 ) en weight(p 2 ) weight(p 2 ). Dit is tegenstrijdig met de voorwaarde dat P 2 de kleinste lengte moet hebben van alle paden met hetzelfde gewicht. 5.2 Complexiteit De complexiteit van algoritme 5 is O(kn(m + n log(n))), met m het aantal bogen en n het aantal toppen in de graaf.

39 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 34 De O(n(m + n log(n))) complexiteit binnen de lus (stap 2 tot 14) komt vooral door stap 13, het berekenen van het kortste pad binnen de equivalentieklassen. Stap 3 neemt O(1) tijd in beslag, stappen 4-6 en 7-11 gebeuren ook in O(1) tijd, omdat het herverdelen van de paden in de equivalentieklassen niet expliciet gebeurt. Het bepalen van top w in stap 8 gebeurt tijdens de berekening van het kortste pad. Het berekenen van het kortste pad in een C(u)-klasse, wat in elke stap van de lus één keer moet gebeuren, vergt een uitvoering van het algoritme van Dijkstra, dus tijdscomplexiteit O((m+n) log(n)) - indien een Fibonacci Heap gebruikt wordt, wordt deze tijdscomplexiteit O(m + n log(n)). Het kortste pad in een C(u, v)-klasse kan met algoritme 6 berekend worden in O(n(m + n log(n))), dit één tot drie keer. Samen geeft dit dus een tijdscomplexiteit van O(n(m + n log(n))) binnen de lus. In algoritme 6 vragen stappen 2 en 3 elk een uitvoering van Dijkstra s algoritme, dus O((m + n) log(n)). In het slechtste geval heeft het pad P in de lus van stap 4-9 n toppen. Binnenin de lus kan stap 6 worden uitgevoerd in O(n log(n) + m) operaties, stap 7 vraagt O(m) operaties. Samen is dit dus O(n(n log(n) + m)). 5.3 Implementatie Bij de implementatie van dit algoritme zijn de belangrijkste details de datastructuren die gebruikt worden om de heap, de equivalentieklassen en de Path Branching Structure voor te stellen. Ook de algoritmen die gebruikt worden bij het berekenen van de kortste paden in de equivalentieklassen zijn belangrijk. De heap is in deze implementatie een PriorityQueue van equivalentieklassen. Opvragen van de klasse met het kortste pad gebeurt dus in constante tijd, toevoegen van een nieuwe klasse heeft tijdscomplexiteit O(log(n)). De Path Branching Structure wordt opgeslagen in een omgekeerde boomstructuur. Elke top-klasse bevat de top die ze voorstelt, het ingaande pad en een link naar de vorige top. Elk van de k kortste paden kan worden voorgesteld door zijn doeltop in de PBS. De klassen die deze k doeltoppen voorstellen worden apart bijgehouden in een lijst, waardoor het i-de pad

40 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 35 eenvoudig kan worden gereconstrueerd door het i-de element uit deze lijst te halen en de deelpaden achterwaarts te overlopen. De datastructuur voor de equivalentieklasse bevat het gewicht van het kortste pad in die klasse en die delen van het kortste pad die nodig zijn om deze klasse in een volgende stap verder op te splitsen. Voor de C(u)-klasse, die een gewoon kortstepadalgoritme vraagt, werd een implementatie van Dijkstra gebruikt. Voor de C(u, v)-klasse werden zowel de naïeve methode als het Replacement Paths algoritme (Hershberger et al. (2007)) geïmplementeerd. De naïeve methode bestaat gewoon uit l keer het Dijkstra algoritme (zoals voor de C(u)-klasse), als l het aantal toppen is op het pad in de graaf van u naar v. De implementatie van het Replacement Paths algoritme gebeurde zoals beschreven in een eerder artikel van Hershberger & Suri (2001). In deze implementatie (zie algoritme 7) wordt rekening gehouden met het feit dat replacement edges voor een boog e i op het kortste pad P, vaak ook replacement edges zijn voor boog e i+1, e i+2,... etc. Met elke boog e in de graaf worden twee getallen geassocieerd, lef t(e) en right(e). Deze getallen zijn de indices op het pad P van de eindpunten van boog e. Voor eindpunten die niet in P voorkomen krijgt elk eindpunt van de boog de index toegewezen van de laatste top op het pad P waarmee hij in de kortstepadboom X nog is verbonden. Verder worden twee arrays L en R van lengte l aangemaakt, waarvan de elementen verzamelingen van bogen zijn. Deze worden opgevuld door te itereren over alle bogen e in de graaf, waarbij een boog wordt toegevoegd aan de verzamelingen in L[lef t(e)] en R[right(e)] wanneer lef t(e) < right(e). De mogelijke replacement edges voor edge e i zijn dan deze bogen die zitten in de verzamelingen L[j] met j i, maar niet in de verzamelingen R[j], j i. In het artikel wordt verder ook opgemerkt dat, wanneer het kortste pad P van u naar v kleiner is dan een bepaalde threshold, het mogelijk kan zijn dat de naïeve manier om het replacement path in een klasse C(u, v) te berekenen sneller is dan het algoritme voorgesteld door Hershberger et al. Ook mijn implementatie voorziet een dergelijke threshold, die kan worden opgegeven als parameter. Indien de threshold 0 is, wordt steeds het Replacement Paths

41 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 36 Algorithm 7 REPLACEMENT PATHS IMPLEMENTATION (Hershberger, Suri) 1: L, R arrays van lengte l = length(path(x, v)) met als elementen (initieel lege) verzamelingen van bogen. 2: Q initieel lege prioriteitswachtlijn van (gewicht,boog)-paren. 3: for all e E \ path(x, v) do 4: if left(e) < right(e) then 5: Voeg e toe aan L[lef t(e)] en R[right(e)] 6: end if 7: end for 8: for all i van 1 tot l do 9: for all e = (a, b) L[i] do 10: w d(x, a) + w(a, b) + d(b, t) 11: Voeg (w, e) toe aan Q 12: end for 13: for all e R[i] do 14: Verwijder (w, e) uit Q. 15: end for 16: Het element (w, e) in Q met het laagste gewicht bevat de Replacement Distance en Replacement Edge. 17: end for

42 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 37 algoritme van Hershberger gebruikt, als de threshold groter is dan de lengte van het langst mogelijke pad van u naar v (bovengrens is n, het aantal toppen in de graaf), dan wordt steeds het naïeve algoritme uitgevoerd. 5.4 Testresultaten Ideale Threshold Allereerst werden een aantal testen uitgevoerd om te bepalen welke threshold de beste resultaten gaf. Voor de kleinste vijf grafen (aantal toppen tussen en ) werd, voor verschillende willekeurig gekozen start- en doeltoppen (3 paren), voor alle waarden van thresholds tussen 0 en 24, berekend hoeveel tijd nodig was om de 10 kortste paden te berekenen. In figuren 5.7 en 5.8 is een plot te zien van de tijden voor elke threshold, relatief t.o.v. de tijd voor de uitvoering zonder threshold. Met andere woorden, de grafiek geeft voor elke threshold het percentage van de threshold-0-tijd die de uitvoering met deze threshold nodig had. Uit dit resultaat blijkt duidelijk dat het effect van de threshold sterk verschilt van graaf tot graaf. In figuur 5.9 wordt de grafiek met het gewogen gemiddelde van alle grafen gegeven. Hieruit kunnen we opmaken dat een threshold van 13 ideaal is, terwijl een threshold van ca. 10 ook goede resultaten geeft. In het artikel bleek dat een threshold van 5 of 6 ideaal is, met 3 een goede waarde. Dit doet vermoeden dat de ideale waarde van de threshold zeer sterk kan verschillen al naargelang de klasse grafen waarmee we werken. Verdere tests op het algoritme van Hershberger werden uitgevoerd voor threshold-waarden van 0 (zonder threshold), 5, 10, 13 en (naïeve implementatie) Vergelijking algoritme met verschillende thresholds Voor deze vijf waarden voor de threshold werden op de kleinste zes grafen de k-kortste paden berekend, voor verschillende waarden van k (1, 5, 10, 50, 100, 200 en 250). Figuren 5.10 en 5.11 tonen de resultaten van de tijdsmetingen. Deze bevestigen in de meeste gevallen de conclusie hierboven: geen threshold gebruiken is in de meeste gevallen een slecht idee, en 10 en 13

43 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 38 Figuur 5.7: Plots voor de verschillende thresholds, kleinste drie grafen Tsjechië, Luxemburg en Ierland.

44 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 39 Figuur 5.8: Plots voor de verschillende thresholds, volgende drie grafen Portugal, Finland en België. zijn de beste waarden voor de threshold. In de enkele gevallen dat threshold

45 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 40 Figuur 5.9: Plot voor de verschillende thresholds, gewogen gemiddelde over alle grafen. 5 beter presteert, is het verschil vrij klein. De naïeve versie presteert voor deze klasse van grafen enorm slecht. Verder kunnen we uit de grafieken opmaken dat de complexiteit inderdaad lineair (of beter) is in k.

46 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 41 Figuur 5.10: Resultaat van de tijdsmetingen voor de kleinste drie grafen, Tsjechië, Luxemburg en Ierland.

47 Hoofdstuk 5. Algoritme van Hershberger, Maxel en Suri 42 Figuur 5.11: Resultaat van de tijdsmetingen voor de volgende drie grafen, Portugal, Finland en België. Bij de laatste twee grafen zijn de tijdsmetingen voor de naïeve implementatie weggelaten.

48 Hoofdstuk 6 Algoritme van Roddity 6.1 Algoritme k-kortste pad algoritme Het artikel On the k-shortest paths problem in weighted directed graphs van Roddity (2007) geeft twee algoritmen om een benadering te berekenen voor het k-kortstepadenprobleem. Hierbij is het gewicht van het i-de pad dat het algoritme als output geeft in het eerste algoritme ten hoogste 2 keer, en in het tweede algoritme hoogstens 1,5 keer het gewicht van het correcte i-de kortste pad. Ook in dit artikel wordt een structuur gedefinieerd om de k-kortste paden efficiënt te kunnen berekenen en op te slaan. De k kortste paden worden hier bijgehouden in een Deviation Tree, waarbij net zoals in Hershbergers Path Branching Structure wordt vertrokken van het idee dat het i-de kortste pad P i een deelpad P i (s, v lj ), l j 0 gemeen heeft met elk van de voorgaande kortste paden P j, j < i (met s de starttop). Definitie (Deviation Tree). Recursief: Voor k = 1 is de Deviation Tree gelijk aan het kortste pad P 1. Voor het i-de kortste pad P i definiëren we twee deelpaden: het pad P i (s, v l ), dat het langst mogelijke deelpad is dat P i gemeenschappelijk heeft met een korter pad P j. Dit deelpad zit al in de Deviation Tree als deel van P j. Het tweede deelpad P i (v l+1, t) (dus P i zonder het eerste deelpad) wordt in de Deviation Tree geconcateneerd met het eerste deelpad door middel van de boog (v l, v l+1 ), die ook wel de Deviation Edge van P i genoemd wordt 43

49 Hoofdstuk 6. Algoritme van Roddity 44 In figuur 6.1 zien we een voorbeeld van een Deviation Tree. Het tweede kortste pad P 2 splitst af van kortste pad P 1 in top a, met als Deviation Edge (a, b). P 3 splitst af van P 1 met Deviation Edge (c, d). Figuur 6.1: Voorbeeld van een Deviation Tree. P 2 splitst af van P 1 in top a, met als Deviation Edge (a, b). P 3 splitst af van P 1 met Deviation Edge (c, d). Het algoritme om de k-kortste paden te berekenen wordt beschreven in algoritme 8. Het i + 1-ste kortste pad P i+1 berekenen uit de i voorgaande paden gebeurt, net zoals in de voorgaande twee algoritmen, door in elke stap het tweede kortste pad te berekenen voor de bekomen delen van P j (1 j i). In het framework voorgesteld door Roddity zijn dit voor een pad P j telkens twee delen: het pad P j (v j, t), waarbij (u j, v j ) de Deviation Edge is van P j, en het pad P l (v l, t), l < j, waarvan P j afsplitst. Voor het eerste pad berekenen we gewoon het tweede kortste pad Pj 2(v j, t) van v j naar t, waarbij we er voor zorgen dat de toppen op P j (s, u j ) niet in Pj 2 voorkomen. Voor het tweede pad berekenen we het tweede kortste

50 Hoofdstuk 6. Algoritme van Roddity 45 pad P 2 l (v l, t) (met (u l, v l ) de Deviation Edge van P l ) waarbij niet alleen de toppen op P l (s, u l ) verboden zijn, maar ook de boog (u j, v j ), om te vermijden dat we hier weer P j uitkomen. De volgende keer dat we op P l een tweede kortste pad berekenen, moet deze boog dus eveneens verboden worden. Hiertoe wordt voor elke eindtop v i van een Deviation Edge (u i, v i ), 1 i k, een verzameling van bogen gedefinieerd, E d (v i ), die bijhoudt welke bogen verboden zijn voor pad P i. In het voorbeeld in figuur 6.1 hebben we voor pad P 1 enkel het hele pad P 1 (s, t). Wanneer we daarvoor het tweede kortste pad berekenen, vinden we P 2, dat in a van P 1 afsplitst. Voor P 2 berekenen we dan de tweede kortste paden voor de delen P 2 (b, t) en P 1 (s, t). Om niet opnieuw P 2 te bekomen, moeten we voor het tweede deel (P 1 (s, t)) de Deviation Edge (a, b) verbieden. Zo krijgen we de tweede kortste paden P 2 2 (b, t) en P 2 1 (s, t) = P 3. Voor P 3 herhalen we dezelfde procedure voor P 3 (d, t) en P 1 (s, t), waarbij nu zowel de boog (a, b) als de boog (c, d) verboden wordt. Één van de paden P 2 2 (b, t), P3 2(d, t) of P 1 2(s, t) zal nu het deel zijn van het vierde kortste pad P 4 vanaf resp. top b, d of s. Net zoals bij Hershberger wordt in beide algoritmen van Roddity het tweede kortste pad berekend, gegeven een bepaald kortste pad P. Het idee is hier om eerst een bovengrens te berekenen, in de vorm van een pad met een bepaald gewicht. Dit pad wordt berekend door de i-de n bogen te verbieden en dan het kortste pad te berekenen van de start- naar de doeltop, voor i gaande van 1 tot P n. Dit resulteert in een pad met een detour van lengte groter dan of gelijk aan n (zie ook algoritme 9). Definitie (detour). Een detour D(u, v) van pad P wordt gedefinieerd als het pad van top u naar top v, waarbij D(u, v) en P enkel toppen u en v gemeenschappelijk hebben, en u ligt op pad P voor v (zie figuur 6.2). Indien deze bovengrens al voldoet aan de voorwaarde dat zijn gewicht kleiner is dan of gelijk aan resp. 2 of 1,5 keer het gewicht van het kortste pad, dan hoeven we niet verder te zoeken - onze benadering zal kleiner zijn dan of gelijk aan 2 of 1,5 keer het correcte tweede kortste pad. Wanneer niet aan de voorwaarde is voldaan, moeten we een beter pad zoeken. In het artikel wordt aangetoond dat zo n tweede kortste pad een

51 Hoofdstuk 6. Algoritme van Roddity 46 Algorithm 8 Berekenen van de k kortste paden (Roddity) Output: De k kortste paden in G van top s naar top t. 1: P 1 Dijkstra(G(V, E), s, t) 2: T lege Deviation Tree. 3: E d (s) 4: H heap met element {< P 1, 1 >} 5: for all i van 1 tot k do 6: < P i, j > kleinste element in H. 7: (u i, v i ) Deviation Edge in P i. 8: Hang tak P i (v i, t) aan u i in T 9: E d (v j ) E d (v j ) {(u i, v i )} 10: E d (v i ) 11: V i V \ P i (s, u i ) 12: E i E \ E d (v i ) 13: P 2 i (v i, t) SecondPath(G(V \ P i (s, u i ), E \ E d (v i )), P i (v i, t)) 14: P 2 j (v j, t) SecondPath(G(V \ P j (s, u j ), E \ E d (v j )), P j (v j, t)) 15: Voeg P 2 i (v i, t) toe aan heap H 16: Voeg P 2 j (v j, t) toe aan heap H 17: end for 18: return T Algorithm 9 upperbound (Roddity) Input: graaf G(V, E), kortste pad P G van s naar t. Output: bovengrens ˆP 2 voor het tweede kortste pad van s naar t. 1: W 2: for all i van 1 tot P n do 3: E i {(u j, u j+1 ) (i 1) n + 1 j i n} 4: P i Dijkstra(G(V, E \ E i ), s, t) 5: if weight(p i ) < W then 6: ˆP2 P i 7: W weight(p i ) 8: end if 9: end for 10: return ˆP 2

52 Hoofdstuk 6. Algoritme van Roddity 47 Figuur 6.2: Voorbeeld van een Detour D(u, v) van pad P. detour moet hebben die strikt kleiner is dan 2 n. Om dit pad te vinden worden de toppen van P ingedeeld in 2 n verzamelingen S, waarbij de toppen in één zo n verzameling in P 2 n toppen van elkaar verwijderd zijn. Daarna wordt op elk van de verzamelingen S een speciale, parallele Dijkstra (zie verder) uitgevoerd, die als output S afgeknotte kortstepadbomen geeft. Uit deze verzamelingen bomen kan nu het tweede kortste pad gemakkelijk berekend worden benaderend tweede kortste pad algoritme In het 2-benaderende algoritme (zie algoritmen 10 en 11) gebeurt de afknotting van de kortstepadbomen zo, dat het resulterende pad kleiner is dan W 2, met W het gewicht van de bovengrens. Dan geldt, wanneer het gewicht van het tweede kortste pad, l 2, gelijk is aan W, of < W 2, dat het juiste pad wordt teruggegeven. Als W 2 l 2 < W, dan geeft het algoritme de bovengrens terug, waarvan het gewicht W 2 l benaderend tweede kortste pad algoritme 2 Het 3 2-benaderende algoritme (zie algoritmen 12 en 13) berekent twee reeksen van kortstepadbomen, S voorwaartse en S achterwaartse. Beide worden afgeknot zodat de resulterende paden, resp. van starttop naar een top u en van een top v naar de doeltop, kleiner zijn dan W 3. Wanneer er een boog van u naar v bestaat kunnen we dus een pad construeren van starttop naar doeltop waarvan het gewicht kleiner is dan 2W 3. Op analoge wijze als in het 2-benaderende algoritme geldt dan dat het resulterende pad 3 2 l 2

53 Hoofdstuk 6. Algoritme van Roddity 48 Algorithm 10 2-benadering voor tweede kortste pad (Roddity) Input: graaf G(V, E), kortste pad P G van s naar t. Output: 2-benadering voor tweede kortste pad. 1: ˆP2 upperbound(g(v, E), P ) 2: if weight( ˆP 2 ) 2 P then 3: return ˆP 2 4: end if 5: setparameters(g(v, E), weight( ˆP 2 )) 6: for all j from 1 to 2 n do 7: d ParrallelDijkstra(G(V, E), S j ) 8: for all u p S j do 9: for all i from p + 1 to p + 2 n 1 do 10: if weight( ˆP 2 ) > d[s, u p ] + d[u p, u i ] + d[u i, t] then 11: ˆP2 P (s, u p ) + P (u p, u i ) + P (u i, t) 12: end if 13: end for 14: end for 15: end for 16: return ˆP 2 Algorithm 11 setparameters - 2-benadering (Roddity) Input: graaf G(V, E), kortste pad P G van s(= u 1 ) naar t(= u P ), bovengrens W. Output: verzamelingen S j, afbeeldingen h en p 1: for all i from 1 to P do 2: h(u i ) W 2 d[s, u i] d[u i+2 n, t] 3: if i 2 n then 4: p(u i ) 0 5: else 6: p(u i ) h(u i 2 n ) + p(u i 2 n ) 7: end if 8: S i%2 n {u i } 9: end for

54 Hoofdstuk 6. Algoritme van Roddity 49 Algorithm 12 3/2-benadering voor tweede kortste pad (Roddity) Input: graaf G(V, E), kortste pad P G van s naar t. Output: 3 2-benadering voor tweede kortste pad. 1: ˆP2 upperbound(g(v, E), P ) 2: if weight( ˆP 2 ) 3 2 P then 3: return ˆP 2 4: end if 5: setparameters(g(v, E), weight( ˆP 2 ), 1) 6: for all j from 1 to 2 n do 7: T out ParrallelDijkstra(G(V, E), S j ) 8: end for 9: setparameters(g(v, E), weight( ˆP 2 ), 0) 10: for all j from 1 to 2 n do 11: T in BackwardParrallelDijkstra(G(V, E), S j ) 12: end for 13: return BestPath(G(V,E)) Algorithm 13 setparameters - 3/2-benadering (Roddity) Input: graaf G(V, E), kortste pad P G van s(= u 1 ) naar t(= u P ), bovengrens W, richting dr. Output: verzamelingen S j, afbeeldingen h en p 1: for all i from 1 to P do 2: h(u i ) max( W 3 dr d[s, u i] (1 dr) d[u i, t], 0) 3: if i 2 n then 4: p(u i ) 0 5: else 6: p(u i ) h(u i 2 n ) + p(u i 2 n ) 7: end if 8: S i%2 n {u i } 9: end for

55 Hoofdstuk 6. Algoritme van Roddity 50 Om uit de voorwaartse en achterwaartse kortstepadbomen het kortste pad te construeren, werd het algoritme BestPath gedefineerd (zie algoritmen 14 en 15). Hierin is τ(u) de kleinst mogelijke index van een top u i op het kortste pad P, waarvoor geldt dat u T out (u τ(u) ). In het artikel wordt bewezen dat voor elk pad van de vorm P (s, u i ) + D(u i, u) + (u, v) + D(v, u j ) + P (u j, t) met lengte kleiner dan 2W 3 moet gelden dat i < τ(u) + 2 n. Algorithm 14 BestPath (Roddity) Input: graaf G(V, E), kortste pad P G van s(= u 1 ) naar t(= u P ), kortstepadbomen T out en T in. Output: het tweede kortste pad van s naar t indien dit < 2W 3. 1: for all u V do 2: Init(u) 3: end for 4: for all (u, v) E \ P do 5: for all i van τ(u) + 1 tot τ(u) + 2 n 1 do 6: if w( ˆP 2 ) > w(min(h in (u))) + w(u, v) + w(min(h out (v))) then 7: ˆP2 min(h in (u)) + w(u, v) + min(h out (v)) 8: end if 9: Verwijder u i uit H out (v) 10: Voeg P (s, u i ) + P (u i, u) toe aan H in (u) met als key u i 11: end for 12: Init(u), Init(v) 13: end for 14: return ˆP 2 Algorithm 15 BestPath (Roddity) Input: top u, kortstepadenbomen T out en T in, index τ(u) Output: heaps H in (u) en H out (u) 1: H in (u), H out (u) 2: Voeg P (s, u τ(u) ) + P (u τ(u), u) toe aan H in (u) met als key u τ(u). 3: for all i van τ(u) + 1 tot τ(u) + 2 n 1 do 4: Voeg P (u, u i ) + P (u i, t) toe aan H out (u) met als key u i. 5: end for Dit algoritme geeft echter niet het gewenste resultaat - niet alle paden kleiner

56 Hoofdstuk 6. Algoritme van Roddity 51 dan 2W 3 worden gevonden. De fout is terug te vinden in Theorem 3.1 in Roddity (2007). Daarin wordt gesteld dat uit u T out (u i ) en v T in (u j ) volgt dat er voor de boog (u, v) een stadium bestaat (in de lus op lijn 5 in algoritme 14) waarin u i H in (u) en u j H out (v). De inhoud van de heap H out (v) (gerelateerd aan de achterwaartse kortstepadbomen T in ) hangt echter af van τ(v), dat berekend wordt a.h.v. de voorwaartse kortstepadbomen T in. Wanneer dus voor een bepaalde top v de index τ(v) P zal dus H out (v) leeg zijn, terwijl het heel goed mogelijk is dat er wel degelijk een achterwaartse kortstepadboom T in (u j ) (met j > τ(u)) te vinden is waarin v voorkomt. De paden van de vorm P (s, u i ) + P (u i, u) + (u, v) + P (v, u j ) + P (u j, t), met τ(u) i < j, zullen dus niet gevonden worden. In algoritme 16 wordt een versie van het BestPath-algoritme gegeven die wel werkt. Hierin hangt de initialisatie van H out (v) af van τ(u) i.p.v. τ(v). Verder moet voor elke u i in de lus op lijn 8 enkel die u j beschouwd worden waarvoor i < j < i + 2 n, omdat in een pad ˆP 2 = P (s, u i ) + P (u i, u) + (u, v)+p (v, u j )+P (u j, t) met gewicht kleiner dan 2W 3 geldt dat j i < 2 n (volgens Corollary 2.1. in Roddity (2007)). In deze nieuwe versie van het algoritme geldt dus wel degelijk dat voor alle mogelijke toppen u i horend bij u (dus met τ(u) i < τ(u) + 2 n - Lemma 3.3. in Roddity (2007)), alle mogelijke toppen u j horend bij v (met i < j < i + 2 n) beschouwd worden. Voor elk mogelijk pad ˆP 2 zal er dus een stadium zijn waarin u i H in (u) en u j H out (v) Parallelle Dijkstra algoritme Tenslotte is er nog het Parallelle Dijkstra-algoritme (algoritmen 17 en 18). In plaats van één starttop heeft deze versie van het algoritme van Dijkstra een verzameling S van starttoppen, waarbij de toppen in S op het kortste pad P telkens 2 n toppen van elkaar verwijderd liggen. Elk van deze starttoppen s S wordt met sleutel (gewicht) 0 aan de interne priority queue of heap toegevoegd. Voor elke bezochte top v wordt bovendien niet alleen het gewicht d[v] bijgehouden, maar ook de starttop src(v) waarlangs we aan dit gewicht kwamen. Ook de voorwaarde in de Relax-procedure voor een boog (u, v) verschilt

57 Hoofdstuk 6. Algoritme van Roddity 52 Algorithm 16 BestPath - correcte versie Input: graaf G(V, E), kortste pad P G van s(= u 1 ) naar t(= u P ), kortstepadbomen T out en T in. Output: het tweede kortste pad van s naar t indien dit < 2W 3. 1: for all (u, v) E \ P do 2: H in (u) 3: H out (u) 4: Voeg P (s, u τ(u) ) + P (u τ(u), u) toe aan H in (u) met als key u τ(u). 5: for all j van τ(u) + 1 tot τ(u) + 2 n 1 do 6: Voeg P (v, u j ) + P (u j, t) toe aan H out (v) met als key u j. 7: end for 8: for all i van τ(u) + 1 tot τ(u) + 2 n 1 do 9: if w( ˆP 2 ) > w(min(h in (u))) + w(u, v) + w(min(h out (v))) then 10: ˆP2 min(h in (u)) + w(u, v) + min(h out (v)) 11: end if 12: Verwijder u i uit H out (v) 13: Voeg P (s, u i ) + P (u i, u) toe aan H in (u) met als key u i 14: Voeg P (v, u i+2 n ) + P (u i+2 n, t) toe aan H out (v) met als key u i+2 n. 15: end for 16: end for 17: return ˆP 2

58 Hoofdstuk 6. Algoritme van Roddity 53 van het origineel. De mogelijke nieuwe afstand tot top v wordt, zoals in het originele algoritme van Dijkstra, berekend als x = d[u] + w(u, v). De afstand tot v, d[v] wordt echter niet noodzakelijk aangepast wanneer d[u] + w(u, v) < d[v]. Allereerst wordt nagegaan of de pas berekende afstand x wel voldoet aan het hoogte-constraint h(src(u)). Daarna moeten we kijken of x < d[v], maar omdat we werken met meerdere starttoppen moeten we ook rekening houden met de afstanden in het kortste pad P. Hiervoor zorgt het prioriteitsconstraint p. Algorithm 17 Parallel Dijkstra (Roddity) Input: graaf G(V, E), verzameling S van starttoppen, kortste pad P. 1: H lege Fibonacci Heap. 2: for all v V \ S do 3: Voeg v toe aan H met label. 4: end for 5: for all (s, v) (S V ) E do 6: Relax((s, v), s) 7: end for 8: while H do 9: u element met kleinste label in H. 10: for all (u, v) E \ P do 11: if v H then 12: Relax((u, v), src(u)) 13: end if 14: end for 15: end while Algorithm 18 Parallel Dijkstra - Relax procedure (Roddity) Input: boog (u, v), starttop s, hoogteconstraint h, prioriteitsconstraint p. 1: x d(s, u) + w(u, v) 2: if x < h(s) (x + p(s) d(src(v), v) + p(src(v)) then 3: src(v) s 4: Verlaag de sleutel van v in H tot d(s, v) + p(s). 5: end if

59 Hoofdstuk 6. Algoritme van Roddity Complexiteit Het Parallelle Dijkstra-algoritme (algoritmen 17 en 18) heeft duidelijk dezelfde complexiteit als een gewone uitvoering van Dijkstra, dus O(m + n log(n)) wanneer een Fibonacci Heap gebruikt wordt. Het algoritme om de bovengrens te berekenen (algoritme 9) voert hoogstens n keer het Algoritme van Dijkstra uit, dus heeft complexiteit O( n(m + n log(n))). De routine setparameters heeft voor beide benaderende algoritmen (resp. algoritme 11 en 13) een complexiteit van O(n) - elke stap binnen de lus kan berekend in O(1) tijd en de lus wordt in het slechtste geval n keer uitgevoerd. In het 2-benaderende algoritme (algoritme 10) heeft lijn 1 complexiteit O( n(m + n log(n))), lijn 2-4 complexiteit O(1) en lijn 5 complexiteit O(n). Lijn 7 heeft complexiteit O(m + n log(n)) en de dubbele lus van lijn 8-14 O(n). Omdat de lus van lijn 6-15 maximaal 2 n keer wordt uitgevoerd, is de totale complexiteit van deze lus ook O( n(m + n log(n))). De totale complexiteit van het algoritme is dus O( n(m + n log(n))). Bij de BestPath-routine (algoritme 16) wordt de buitenste lus hoogstens m keer uitgevoerd, de binnenste lussen hoogstens 2 n keer. Lijn 12 binnen de binnenste lus (indien de heaps Fibonacci Heaps zijn - bij een Priority Queue ook lijn 6, 13 en 14) heeft complexiteit O(log( n)), n omdat zowel H in als H out op elk moment hoogstens 2 n elementen bevat. De totale complexiteit van BestPath is dus O(m n log( n)). In het 3 2-benaderende algoritme (algoritme 12) is de complexiteit van lijn 1 en de lussen op lijn 6-8 en eveneens O( n(m + n log(n))), lijn 5 en 9 hebben complexiteit O(n) en lijn 2-4 vergt O(1) operaties. Gecombineerd met de complexiteit van de BestPath-routine is de totale complexiteit dus O( n(m log( n)+n log(n))) - en niet, zoals in het artikel (Roddity (2007)) gesuggereerd wordt, O( n(m + n log(n))). Wanneer in het algoritme van Dijkstra een Priority Queue gebruikt wordt, in plaats van een Fibonacci Heap, geldt wel dat beide benaderende algoritmen dezelfde complexiteit, nl. O( n((m + n) log(n))), hebben. We kunnen dus concluderen dat het 2-benaderende k-kortstepadenalgoritme complexiteit O(k n(m+n log(n))) heeft, het 3 2 -benaderende k-kortstepadenalgoritme O(k n(m log( n) + n log(n))). Dit geeft een theoretische verbe-

60 Hoofdstuk 6. Algoritme van Roddity 55 tering tegenover de algoritmen van Yen en Hershberger, die beide complexiteit O(kn(m + n log(n))) hebben. 6.3 Implementatie In het k-kortstepadenalgoritme zijn de belangrijkste details de implementatie van de Deviation Tree, de verzamelingen van verboden Deviation Edges en de heap die de gevonden paden bijhoudt. De Deviation Tree wordt net zoals de Path Branching Structure in Hershberger s algoritme achterwaarts bijgehouden. Elk achterste deelpad D wijst naar het pad waarvan het afsplitst en houdt bovendien zijn Deviation Edge bij en de lengte van het pad dat voor D komt. Alle achterste deelpaden worden bovendien in een lijst bijgehouden. Deze structuur laat toe om de paden in lineaire tijd (in de lengte van het pad) op te vragen. De nodige opslagruimte is lineair in de som van het aantal toppen op elk van de deelpaden. De verboden Deviation Edges worden bijgehouden in een (hash)map van een getal i op de verzameling van Deviation Edges, waarbij i staat voor het i-de pad. Het opvragen van de verboden bogen kan dus in constante tijd gebeuren. Net zoals in de andere algoritmen is de heap ook hier een PriorityQueue. In zowel de 2- als de 3 2-benaderende algoritmen voor het tweede kortste pad werden de functies h (hoogte-constraint) en p (prioriteitsconstraint) bijgehouden als een map van de top op het pad naar de bijbehorende waarde. De verzamelingen S van de toppen op het pad die 2 n uit elkaar liggen werden bijgehouden in een lijst, en ook de verzamelingen zelf werden bijgehouden als lijsten. Het Parallelle Dijkstra-algoritme werd geïmplementeerd door een gegeven implementatie van Dijkstra te wijzigen zodat het de hoogte- en prioriteitsconstraints gebruikt en meerdere kortstepadbomen kan teruggeven. Omdat deze kortstepadbomen geen toppen gemeenschappelijk kunnen hebben, volstaat het om gewoon toe te laten dat er meerdere wortels in de boomstructuur kunnen zitten (om snelheidsredenen kreeg ook elke top in de boom een extra verwijzing naar zijn wortel) en dat de interne queue van het algoritme

61 Hoofdstuk 6. Algoritme van Roddity 56 geïnitialiseerd wordt met meerdere starttoppen. 6.4 Testresultaten Tijdscomplexiteit in de praktijk De factor n in de complexiteit van de beide exacte algoritmen staat voor de lengte van (een deel van) een korter pad, waarvoor we het tweede kortste pad willen berekenen. Deze factor is duidelijk voor heel wat paden veel te groot geschat. In het bijzonder geldt, wanneer de lengte van alle deelpaden waarvoor een tweede kortste pad berekend wordt, groter is dan of gelijk aan n, dat de complexiteit van het naïeve of van het Hershberger tweede-kortste pad algoritme gelijk is aan de complexiteit van het tweedekortstepadalgoritme van Roddity, op een constante factor na. En dit terwijl Roddity enkel een benadering garandeert. Hieruit kunnen we opmaken dat het voor het algoritme van Roddity nuttig kan zijn om een threshold te gebruiken. Deze threshold is optimaal wanneer ze gelijk is aan de complexiteit van het algoritme van Roddity, gedeeld door k keer de complexiteit van Dijkstra. Dit komt neer op C n, met C een constante. Welke waarde voor C optimaal is, kunnen we weer testen door voor verschillende grafen het algoritme met verschillende thresholds uit te voeren. Er werd gekozen om dit te beperken tot gehele getallen. Hierbij is een belangrijke vereiste dat de k kortste (deel-)paden lang genoeg zijn, anders wordt telkens het alternatieve algoritme uitgevoerd. Voor kleinere grafen is dit helaas een probleem. Hoe kleiner n, hoe minder paden een lengte groter dan n hebben. Een oplossing hiervoor is om telkens te beginnen met het langst mogelijke kortste pad in de graaf. Het algoritme van Roddity wordt dan ten minste uitgevoerd bij de berekening van het tweede kortste pad (in de praktijk natuurlijk meer dan één keer). Tabel 6.1 geeft voor elk langste kortste pad in elke graaf de lengte van het pad en de waarden van de geteste thresholds voor die graaf weer. Wanneer we er van uit gaan dat, als het kortste pad lengte l heeft, de k kortste deelpaden waarop het tweede kortste pad berekend wordt niet veel langer zullen zijn dan l (voor routenetwerken waarbij de gewichten op de bogen afstanden zijn, lijkt dit zeker een redelijke aanname), dan blijkt uit

62 Hoofdstuk 6. Algoritme van Roddity 57 Tabel 6.1: Waarden van de geteste thresholds voor de kleinste vier Karlsruhegrafen. Graaf # toppen lengte pad n 2 n 3 n 4 n Tsjechië Luxemburg Ierland Portugal de tabel dat voor de eerste graaf vanaf threshold 2 n enkel het alternatieve algoritme zal gebruikt worden, voor de Luxemburg- en Ierland-grafen vanaf 3 n en voor de laatste graaf vanaf 4 n. Testen voor hogere waarden van de threshold hebben op deze grafen dus niet veel nut, vermits telkens het alternatieve algoritme zal worden uitgevoerd. Voor het alternatieve algoritme (uitgevoerd wanneer het kortste (deel)pad kleiner is dan de threshold) wordt één van de exacte algoritmen gebruikt, het naïeve tweedekortstepadalgoritme of het Replacement Paths algoritme van Hershberger. Het lijkt hier evident om het snelste algoritme te nemen, namelijk het hybride Hershberger algoritme (met threshold 10). Dit geeft echter problemen wanneer het deelpad van v tot t waarvoor het replacement path berekend wordt, niet één van de kortste paden was van v tot t. In dit geval zal het Hershberger-algoritme een Exception opgooien die dit aangeeft, waarna gewoon met Dijkstra het echte kortste pad tussen v en t wordt berekend Optimale threshold De resultaten van de testen met verschillende thresholds zijn te zien in figuur 6.4 voor het 2-benaderende algoritme. Telkens werden enkel die thresholds T geplot waarvoor (T 1) n nog kleiner was dan de lengte van het pad. Threshold 0 wordt enkel voor de eerste graaf weergegeven, voor de andere grafen gaf deze eveneens veel slechtere resultaten dan de grotere thresholds. Voor de vierde graaf wordt ook threshold 1 niet meer weergegeven.

63 Hoofdstuk 6. Algoritme van Roddity 58 In deze grafieken kunnen we duidelijk zien dat een threshold van 2 optimaal is voor het 2-benaderend algoritme. Uit de grafiek voor Tsjechië (de eerste grafiek) blijkt dat wanneer we geen threshold gebruiken (T=0), de resultaten veel slechter zijn dan wanneer we telkens het alternatieve algoritme - hier Hershberger - uitvoeren (voor deze graaf T=2). Figuur 6.3: Resultaat van de tijdsmetingen van het algoritme van Roddity, 2- benaderende algoritme, over verschillende thresholds, voor de eerste twee Karlsruhe-grafen. De thresholdtesten voor het 3 2-benaderende algoritme gaven vergelijkbare resultaten als het 2-benaderende algoritme. Ter illustratie, in figuur 6.5 de resultaten voor de graaf Luxemburg. Wanneer we de tijdsmetingen voor beide benaderende algoritmen vergelijken (zie figuur 6.6(a) voor de grafiek van de Luxemburg-graaf), zien we dat deze (zo goed als) samenvallen wanneer thresholds gebruikt worden. Wanneer geen thresholds gebruikt worden (zie figuur 6.6(b) voor de grafiek van de

64 Hoofdstuk 6. Algoritme van Roddity 59 Figuur 6.4: Resultaat van de tijdsmetingen van het algoritme van Roddity, 2- benaderende algoritme, over verschillende thresholds, voor de volgende twee Karlsruhe-grafen. Tsjechië-graaf) is dit verschil heel wat groter. Het 3 2-benaderende algoritme presteert daar duidelijk slechter. We vermoeden dat voor grotere grafen met zeer lange kortste paden, waarbij het alternatieve algoritme veel minder zal worden uitgevoerd dan in de kleine Luxemburg-graaf, het verschil tussen beide algoritmen wel zichtbaar zal worden Correctheid van de k berekende paden Voor een benaderend algoritme moeten we, naast de snelheid, ook rekening houden met hoe goed de benadering is. En hoe groot is het verschil tussen de resultaten van het 2-benaderend en het 3 2-benaderend algoritme? Om dit na te gaan, werd voor de kleinste graaf een aantal keer de 100 kortste paden berekend van een random top naar een andere random top, met behulp van beide algoritmen. Daarna werd voor elk van deze uitvoeringen

65 Hoofdstuk 6. Algoritme van Roddity 60 Figuur 6.5: Resultaat van de tijdsmetingen van het algoritme van Roddity, benaderende algoritme, over verschillende thresholds, voor de Luxemburg-graaf. geteld, voor 1 i 100, hoeveel van de i eerste paden die het algoritme gaf, ook tot de exacte i-kortste paden behoorden (waarbij paden natuurlijk enkel vergeleken werden op basis van hun gewicht). Daarna werd het gemiddelde genomen, per algoritme, over alle uitvoeringen en gedeeld door i, zodat we het percentage correcte paden verkrijgen voor elke waarde van k tussen 1 en 100. Het resultaat van deze metingen, waarbij de lengtes van de kortste paden tussen de random gegenereerde toppen lag tussen 31 en 178, was dat de benaderende algoritmen van Roddity allebei de exacte oplossing teruggaven voor k 100.

66 Hoofdstuk 6. Algoritme van Roddity 61 (a) Luxemburg-graaf, resultaten met thresholds. (b) Tsjechië-graaf, resultaten zonder thresholds. Figuur 6.6: Resultaat van de tijdsmetingen van het algoritme van Roddity, vergelijking van beide benaderende algoritmen, voor de Luxemburg en Tsjechië-grafen.

67 Hoofdstuk 7 Algoritme van Bernstein 7.1 Algoritme Het algoritme voorgesteld door Bernstein (2010) is een (1 + ɛ)-benaderend algoritme (ɛ > 0). Het gewicht van het i-de kortste pad dat het algoritme output is dus hoogstens i + ɛ keer groter dan het gewicht van het correcte i-de kortste pad. Het algoritme bouwt verder op de eerste stap in het algoritme van Roddity, namelijk de manier waarop de bovengrens wordt berekend. Het artikel van Bernstein stelt niet expliciet een manier voor om de k kortste paden te berekenen, enkel de berekening van het tweede kortste pad, gegeven een kortste pad van s naar t, wordt voorgesteld. Omdat het algoritme verderbouwt op dat van Roddity werd gekozen om hiervoor algoritme 8 te gebruiken. Het algoritme van Bernstein werkt in fasen. Zij q de lengte van het kortste pad P. In fase 1 wordt een pad van starttop s naar doeltop t berekend met een detourspan in het interval [q/2, q],..., in fase i een pad met detourspan in [q/2 i, q/2 i 1 ],... enz. tot fase log(q). Definitie (detourspan). Een detourspan is het aantal toppen op een detour van een pad (Het begrip detour werd reeds gedefinieerd in sectie 6.1). Het berekenen van een pad met een detourspan in een interval [q/2 i, q/2 i 1 ] (zie ook algoritme 19) gebeurt door eerst het kortste pad op te delen in 2 i intervals I k van grootte q/2 i. Dan definiëren we vier subfasen. In subfase j worden intervals I j, I j+4,... etc. gelabeld als startintervallen, alle andere 62

68 Hoofdstuk 7. Algoritme van Bernstein 63 intervallen worden gelabeld als stopinterval. Voor elk van de startintervallen in elk van de subfasen wordt dan het kortste pad berekend met een detour die begint in een top u in een startinterval en eindigt in een top v in een stopinterval, waarbij v op het kortste pad P na u ligt. Zie figuur 7.1 voor een voorbeeld van een labeling in start- en stopintervallen, met q = 16, fase i = 3, subfase j = 2. Figuur 7.1: Voorbeeld van een labeling in start- en stopintervallen, met q = 16, fase i = 3, subfase j = 2. De 2 i = 8 intervallen worden door verticale lijnen gescheiden. De groene pijlen zijn voorbeelden van detours die tijdens deze subfase kunnen worden gegenereerd, de rode streepjeslijnen zijn detours die verboden zijn. De twee rode detours die boven het pad lopen zijn enkel verboden tijdens deze subfase, maar waren geldig in de subfase j = 1, i = 3. De rode detour onderaan is altijd verboden. Om dit kortste pad in een subfase te berekenen wordt een speciale routine gebruikt, die Progressive Dijkstra genoemd wordt (zie algoritmen 20 en 21). Hierbij wordt voor elk startinterval in de subfase het resultaat (de berekende afstanden) gebruikt van de uitvoering van Progressive Dijkstra uit het vorige startinterval. In een uitvoering van Progressive Dijkstra wordt bovendien de afstand tot een top enkel gewijzigd wanneer die een significante verbetering oplevert tegenover een vorige uitvoering. Concreet geldt dat we in de Relax-procedure van Dijkstra het label van een top u enkel wijzigen naar d(s, u ) + w(u, u) wanneer d(s, u ) + w(u, u) < d(s, u)/(1+ɛ ). Hierbij is ɛ = ɛ/(2 log(q)). In het artikel staat in de pseudocode voor de Relax-procedure een kleine fout, de Insert en Decrease-Key operaties (resp. toevoegen van een top en verlagen van een label) staan daar omgewisseld - in de pseudocode in algoritme 21 is dit rechtgezet.

69 Hoofdstuk 7. Algoritme van Bernstein 64 Algorithm 19 Algoritme tweede kortste pad (Bernstein) Input: een kortste pad P van s naar t met lengte q in graaf G, ɛ > 0 Output: benadering ˆP 2 tweede kortste pad P 2 van s naar t, ˆP 2 (1 + ɛ) P 2 1: Verwijder de bogen van P. 2: Verwijder uitgaande bogen van t. 3: bestw eight 4: for all i van 1 tot log q do 5: Verdeel P in intervallen van lengte q/2 i 6: for all j van 1 tot 4 do 7: Label intervallen I j, I j+4, I j+8,... etc als startinterval. 8: Label alle andere intervallen als stopinterval. 9: Verwijder de inkomende bogen van alle tppen v startinterval 10: for all startintervallen I k, k van 1 tot 2 i /4 do 11: c nieuwe afstandsfunctie voor Dijkstra 12: for all toppen v in startinterval I k do 13: Verwijder alle toppen van P gelegen voor startinterval I k 14: c Progressive Dijkstra(G,v,t,c,ɛ) 15: end for 16: end for 17: if c(t) < bestw eight then 18: bestw eight c(t) 19: bestp ath pad horend bij c(t). 20: end if 21: end for 22: end for 23: return bestp ath

70 Hoofdstuk 7. Algoritme van Bernstein 65 Algorithm 20 Progressive Dijkstra (Bernstein) Input: graaf G, starttop v, doeltop t, afstandsfunctie c, ɛ > 0 Output: benadering ˆP (v, t) van het kortste pad P (v, t) van v naar t met ˆP (v, t) (1 + ɛ ) P (v, t). 1: ɛ ɛ/2 log q 2: Heap H empty (Fibonacci) heap 3: Voeg v toe aan H met label d[s, v] 4: Voeg t toe aan H met label c(t) 5: while H do 6: u verwijder top met laagste label in H. 7: if u in stopinterval then 8: Relax(u,t,c,H,ɛ ) 9: else 10: for all edges (u, u ) do 11: Relax(u,u,c,H,ɛ ) 12: end for 13: end if 14: end while 15: return c Algorithm 21 Relax (Bernstein) Input: top u, top u, afstandsfunctie c, heap H, ɛ > 0 1: if u H and c(u ) > c(u) + w(u, u ) then 2: c(u ) c(u) + w(u, u ) 3: Voeg u toe aan H met label c(u ). 4: end if 5: if u / H and c(u ) > (1 + ɛ )(c(u) + w(u, u )) then 6: c(u ) c(u) + w(u, u ) 7: Verlaag het label van u in H tot c(u ). 8: end if

71 Hoofdstuk 7. Algoritme van Bernstein Complexiteit De complexiteit van de 2 i /4 uitvoeringen van algoritme 20 in de lus van lijn 9-15 van algoritme 19 is O(m ɛ 1 log(n)log(nc/c)) met C en c het grootste, resp. kleinste gewicht onder alle bogen in de graaf. Dit komt doordat elke top ten hoogste O(log 1+ɛ (nc/c)) keer wordt bezocht, wat gelijk is aan O(ɛ 1 log(n)log(nc/c)). Van alle stappen binnen de lus van lijn 6 tot lijn 21 in algoritme 19, is deze lus degene met de hoogste complexiteit - lijn 7 en 8 worden impliciet in de lus berekend, lijn wordt in constante tijd uitgevoerd. Deze lus heeft dus in totaal complexiteit O(m ɛ 1 log(n)log(nc/c)). De stap in lijn 5 is lineair in de lengte van het pad P (dus heeft complexiteit O(n)). De lus van lijn 4 tot lijn 22, die log(n) keer wordt uitgevoerd, heeft dus een totale complexiteit van O(log(n) (n+m ɛ 1 log(n) log(nc/c))). Omdat de stappen in lijn 1, 2 en 23 ten hoogste lineair zijn in n en de stap in lijn 3 constante complexiteit heeft, geldt dat de totale complexiteit van algoritme 19 bepaald wordt door de complexiteit van de lus. Als we met behulp van dit algoritme de k-kortste paden berekenen, moeten we enkel nog een factor k aan de complexiteit toevoegen. We kunnen concluderen dat de theoretische complexiteit van het algoritme van Bernstein gelijk is aan O(k log(n) (n + m ɛ 1 log(n) log(nc/c))) 7.3 Implementatie Het indelen in 2 i intervallen (lijn 5 van algoritme 19) gebeurt expliciet door de toppen op het pad P in vier verzamelingen A j (java HashSets) in te delen. Elke verzameling A j bevat de toppen in die intervallen I k waarvoor k j mod 4, zodanig dat in subfase j (lus lijn 6 tot 21) verzameling A j alle startintervallen bevat. De stopintervallen zitten dan in de drie andere verzamelingen. In het originele algoritme werden niet alleen bogen van P, uitgaande bogen van t en toppen op P verwijderd (lijn 1, 2, 9 en 13 in algoritme 19). Binnen de lus op lijn 6 (algoritme 19) werd voor de toppen v in de startintervallen een dummy starttop s toegevoegd en een boog (s, v) met als gewicht de

72 Hoofdstuk 7. Algoritme van Bernstein 67 afstand van s tot v. Progressive Dijkstra werd dan uitgevoerd vanaf deze top s. Maar gezien het feit dat we toch al een alternatieve versie van het algoritme van Dijkstra gebruiken, is het eenvoudiger om Progressive Dijkstra gewoon vanaf v te laten vertrekken, maar v in de interne queue van Dijkstra initieel gewicht d(s, v) te geven i.p.v. 0. Daarnaast werden voor alle toppen u in een eindinterval de uitgaande bogen verwijderd en een boog (u, t) toegevoegd met als gewicht de afstand van u naar t. In plaats hiervan werd aan Progressive Dijkstra meegegeven welke toppen in eindintervallen zaten, en wanneer Dijkstra zo n top tegenkomt (lijn 8-9 in algoritme 20), wordt Relax uitgevoerd op de fictieve boog (u, t) met gewicht d(u, t) in plaats van alle bogen (u, u ) E. Het reconstrueren van het tweede kortste pad (lijn 19) is bij dit algoritme iets minder eenvoudig dan in die van Yen, Hershberger of Roddity. afstandsfunctie c (lijn 11, 14), geïmplementeerd als de kortstepadboom van Progressive Dijkstra, geeft de afstand van top v tot doeltop t. Hierbij zijn echter wel de toppen verwijderd tussen een top w in een stopinterval naar doeltop t. Om het tweede kortste pad te bekomen, moeten we hier dus niet gewoon het deel van s naar v aanplakken, we moeten ook het deel tussen w en t invoegen, indien het bestaat (een top u die niet in een stopinterval ligt, kan ook met t verbonden zijn). Het algoritme om dit pad te reconstrueren wordt beschreven in algoritme 22. Algorithm 22 Reconstrueren van het tweede kortste pad Input: pad P 2 = P (s, v) + P 2 (v, w) + t, pad P (lengte q), graaf G 1: w voorlaatste top in P 2 2: j index van top w in P (s, v q 1 ) 3: if index j niet gevonden then 4: return P 2 5: else 6: return P 2 (s, w) + P (v j, t) 7: end if De

73 Hoofdstuk 7. Algoritme van Bernstein Testresultaten Thresholds Volgens dezelfde redenering als bij het algoritme van Roddity kunnen we ook voor het algoritme van Bernstein stellen dat een threshold nuttig zou kunnen zijn. We testen het verschil in uitvoeringstijd voor een aantal thresholds met waarden T ɛ 1 log(n) 2. Ook hier nemen we, om het aantal testen te beperken, voor T gehele getallen. Omdat de k kortste (deel-)paden lang genoeg moeten zijn, gebruiken we hier dezelfde start- en doeltoppen als voor de tests van het algoritme van Roddity. Tabel 7.1 vergelijkt de lengte van elk langste kortste pad in elke graaf met de waarden van de geteste thresholds. Tabel 7.1: Waarden van de geteste thresholds voor de kleinste vier Karlsruhegrafen. (a) Voor ɛ = 1.0 Graaf #toppen padlengte log(n) 2 2log(n) 2 3log(n) 2 Tsjechië Luxemburg Ierland Portugal (b) Voor ɛ = 0, 5 Graaf padlengte 2log(n) 2 4log(n) 2 6log(n) 2 Tsjechië Luxemburg Ierland Portugal In deze tabel zien we dat voor de kleinste graaf bij ɛ = 1 vanaf T = 2 telkens het alternatieve algoritme zal worden uitgevoerd en bij ɛ = 0, 5 zelfs al vanaf T = 1. Voor de volgende twee grafen is dit resp. bij T = 3 en T = 2, voor

74 Hoofdstuk 7. Algoritme van Bernstein 69 de laatste graaf vanaf T = 4 en T = 3. Voor het alternatieve algoritme werd ook hier het algoritme van Hershberger met threshold 10 gebruikt. De resultaten van de testen voor ɛ = 1 zijn te zien in figuur 7.2. Hierbij werden telkens die thresholds T geplot, waarvoor (T 1) ɛ 1 log(n) 2 lengte kortste pad T ɛ 1 log(n) 2. In de grafiek zien we dat voor dit algoritme, voor twee van de grafen, het gebruik van een threshold het algoritme blijkbaar enkel vertraagt. Zelfs zonder het gebruik van thresholds presteert het algoritme daar dus beter dan het alternatieve, exacte algoritme. Voor de eerste graaf zien we dat het algoritme van Bernstein niet beter is dan het alternatieve algoritme, maar het gebruik van een threshold helpt ook hier helemaal niet of nauwelijks - de grafieken voor de uitvoering zonder threshold en met threshold 1 ɛ 1 log(n) 2 vallen volledig samen. Voor ɛ = 0, 5 krijgen we analoge resultaten. Wanneer we tenslotte de resultaten van de testen voor ɛ = 1 vergelijken met die voor ɛ = 0, 5 (figuur 7.3) zien we dat, zoals we al verwachtten door de factor ɛ 1 in de complexiteit, het algoritme met een kleinere ɛ inderdaad trager is. Verder is ook duidelijk te zien dat hoe groter de graaf, hoe minder deze factor een rol speelt Correctheid van de k berekende paden Ook het algoritme van Bernstein is een benaderend algoritme, en dus zullen we ook hier nagaan hoeveel van de eerste i gegenereerde paden tot de i- kortste paden behoren. De methode die we gebruiken om dit te testen, is dezelfde als bij de algoritmen van Roddity en is terug te vinden in subsectie De resultaten van deze test zijn te zien in figuur 7.4. We zien in deze grafiek dat voor waarden van k kleiner dan 30 de parameter ɛ een beperkte invloed uitoefent - hoe kleiner ɛ, hoe beter het resultaat. Het percentage correcte resultaten daalt initieel zeer sterk, maar vanaf k = 30 blijft de waarde min of meer stabiel op 40 %, en dit voor beide waarden van de parameter ɛ. In figuur 7.5 werd het percentage correcte resultaten voor k = 100 geplot tegen de lengte van de kortste paden tussen de start- en doeltoppen. We zien

75 Hoofdstuk 7. Algoritme van Bernstein 70 Figuur 7.2: Resultaat van de tijdsmetingen van het algoritme van Bernstein, ɛ = 1, over verschillende thresholds, voor de eerste drie Karlsruhe-grafen. In de eerste grafiek vallen T = 0 en T = 1 samen. duidelijk dat, zowel voor ɛ = 1 als ɛ = 0, 5, dit percentage daalt naarmate de afstand tussen de twee toppen toeneemt. Het tweedekortstepadalgoritme berekent dus blijkbaar gemakkelijker het juiste resultaat wanneer het kortste

76 Hoofdstuk 7. Algoritme van Bernstein 71 pad kleiner is.

77 Hoofdstuk 7. Algoritme van Bernstein 72 Figuur 7.3: Vergelijking van de tijdsmetingen van het algoritme van Bernstein voor ɛ = 1 en ɛ = 0, 5, zonder thresholds, voor de eerste drie Karlsruhe-grafen.

78 Hoofdstuk 7. Algoritme van Bernstein 73 Figuur 7.4: Resultaat van de metingen over de correctheid van de output van het algoritme van Bernstein, voor de Tsjechië-graaf. Figuur 7.5: Resultaat van de metingen over de correctheid van de output van het algoritme van Bernstein, voor de Tsjechië en Luxemburg-grafen.

79 Hoofdstuk 8 Vergelijking algoritmen We vergelijken in dit hoofdstuk eerst elk van de algoritmen met het algoritme van Yen (sectie ). Daarna worden de andere algoritmen nog eens onderling vergeleken (sectie 8.4). 8.1 Yen vs. Hershberger Figuur 8.1 toont de resultaten van tijdsmetingen voor drie verschillende queries op twee van de Karlsruhe-grafen, voor de algoritmen van Yen en Hershberger. De eerste twee tijdsmetingen, op de graaf voor Portugal, berekenen de k-kortste paden voor twee paren van toppen waartussen het kortste pad resp. 205 en 413 toppen lang is, dit is ca. 1/6 en 1/3 van het langste kortste pad in deze graaf (1348 toppen lang). De laatste tijdsmeting werd gedaan over de kleinere graaf van Ierland, hier waren de start- en doeltop deze van het langste kortste pad in de graaf. In deze grafieken zien we dat voor het kleinste kortste pad het algoritme van Hershberger, zowel met als zonder threshold, slechter presteert dan Yen. Met threshold is Hershberger hier meer dan 5 keer trager dan Yen. Voor het middenste kortste pad is Yen 2 keer zo snel als Hershberger met threshold. Voor het langste kortste pad in de graaf presteerde Hershberger echter 4 keer zo snel als Yen. Queries op de kleinste zes Karlsruhe-grafen, voor toppen die resp 1/6, 1/3 of 1 keer de lengte van het langste kortste pad uiteenliggen, gaven gelijkaardige resultaten in elk van de drie categorieën. Voor de kleinste kortste paden 74

80 Hoofdstuk 8. Vergelijking algoritmen 75 Figuur 8.1: Resultaten van tijdsmetingen voor drie verschillende queries op de Portugal- en Ierland-grafen. Vergelijking van het algoritme van Yen met dat van Hershberger.

81 Hoofdstuk 8. Vergelijking algoritmen 76 was Hershberger met threshold 13 tussen 2,5 en 5,5 keer trager dan Yen voor de kleinere grafen - voor de grootste graaf, België, was Hershberger iets sneller, wat doet vermoeden dat voor grotere grafen Hershberger ook beter zou kunnen zijn voor kleinere queries. Voor de middenste grafen was Hershberger (threshold 10) tussen 1 en 3 keer trager. Voor de grootste kortste paden, echter, was Hershberger met threshold 10 telkens tussen 2 en 4,5 keer sneller dan Yen - hoe groter de graaf, hoe groter het verschil. 8.2 Yen vs. Roddity Wanneer we de resultaten (zie figuur 8.2) vergelijken zien we dat, zowel voor de queries waarbij s en t 1/3 keer de lengte van het langste kortste pad uiteenlagen, als voor een queries op de start- en doeltop van het langste kortste pad, het algoritme van Roddity veel slechter presteert dan dat van Yen - zelfs wanneer een threshold gebruikt wordt. Enkel het 2-benaderende algoritme wordt hier vergeleken, we weten dat het 3 2-benaderende algoritme telkens even slecht of slechter presteert. In de grafiek voor de Luxemburg graaf zien we echter dat ook Roddity met threshold 3 slechter is dan Yen - maar voor deze query (op start- en doeltoppen die zo ver mogelijk uiteenliggen) is dit gelijk aan het uitvoeren van het alternatieve algoritme, het algoritme van Hershberger met threshold 10. En in de vorige sectie concludeerden we net dat voor deze query het algoritme van Hershberger met threshold 10 beter presteert dan Yen. De enige mogelijke verklaring ligt dus bij het gebruik van het framework van Roddity om de k-kortste paden te berekenen. Wanneer we de snelheid vergelijken van het Roddity-framework tegenover het Hershberger-framework voor het neutrale, naïeve tweedekortstepadalgoritme en het algoritme van Hersberger (voorbeeld in figuur 8.3), zien we dat het Hershberger-framework heel wat efficiënter blijkt te zijn dan dat van Roddity. Voor het naïeve algoritme is dit met een factor 2, voor het Hershberger-algoritme liep dit voor de geteste queries op tot een factor van 7 keer sneller (voornamelijk te wijten aan het feit dat het algoritme door de structuur van het framework tot zelfs 10 keer vaker faalt). Hier kunnen we dus concluderen dat, indien we een beter framework zouden gebruiken voor het Roddity-algoritme, dit algoritme wel beter zou kunnen

82 Hoofdstuk 8. Vergelijking algoritmen 77 Figuur 8.2: Resultaten van tijdsmetingen voor drie verschillende queries op de Tsjechië en Luxemburg-grafen. Vergelijking van het algoritme van Yen met dat van Roddity. In de bovenste grafiek ligt de curve voor Yen bijna tegen de x-as. zijn dan Yen voor queries op langere paden. Voor paden van gemiddelde (en kleine) lengte (zie figuur 8.4) zien we dat het algoritme van Roddity slechter presteert dan Hershberger, en eerder samenvalt met het naïeve algoritme.

83 Hoofdstuk 8. Vergelijking algoritmen 78 Figuur 8.3: Resultaten van tijdsmetingen ter vergelijking van beide frameworks. Figuur 8.4: Vergelijking van de resultaten van tijdsmetingen voor het naiëve, het Hershberger en het Roddity-tweedekortstepadalgoritme. 8.3 Yen vs. Bernstein De resultaten voor de vergelijking tussen Bernstein en Yen zijn te zien in figuur 8.5, opnieuw voor queries op start- en doeltoppen die resp. 1/6, 1/3 en 1 keer de afstand van het langste kortste pad uiteenliggen, hier op drie verschillende grafen. Analoog aan de resultaten voor het algoritme van Hershberger presteert ook Bernstein slechter voor de kleine en gemiddelde queries, maar beter voor top-

84 Hoofdstuk 8. Vergelijking algoritmen 79 Figuur 8.5: Resultaten van tijdsmetingen voor drie verschillende queries op de Portugal-, Luxemburg- en Ierland-grafen. Vergelijking van het algoritme van Yen met dat van Bernstein.