Kortstepad-algoritme

Het kortstepad-algoritme, ook bekend als Dijkstra's algoritme, is een graaf-algoritme beschreven door Edsger Dijkstra in 1959. Gegeven een gewogen graaf $G$ waarin de afstand tussen ieder tweetal verbonden punten van $G$ ten minste 0 bedraagt, rekent het algoritme voor een bepaalde beginknoop $g_{b}\in G$ de kortste afstand uit tot alle punten van $G$. Toepassingen van dit algoritme zijn onder meer bij verkeersmodellen, route-navigatiesystemen en telecommunicatie.

De basis

Het algoritme is gebaseerd op de opmerking dat de afstand (de lengte van het kortste pad) tussen ieder tweetal punten $v$ en $w$ van een gewogen graaf $G$ als volgt berekend kan worden:

Zij $d(x)$ de afstand tussen $v$ en $x$, voor $x$ een punt van $G$.

Zij $N_{w}=\{y\in G\mid y\rightarrow w\}$, de verzameling van punten $y$ die direct verbonden zijn met w (via een tak van $y$ naar $w$).

Zij $gew(y,w)$ het gewicht van de tak tussen twee direct met elkaar verbonden knopen $y$ en $w$.

De afstand van $v$ naar $w$ is $d(w)=\min\{d(y)+gew(y,w)\mid y\in N_{w}\}$, het minimum van de som van de afstand van $v$ naar een punt $y\in N$ plus de directe afstand van dat punt naar $w$. Oftewel - weinig verrassend - als de som van alle directe afstanden in een pad minimaal is, dan is de totale lengte van dat pad (die som dus) minimaal.

Verder definiëren we $M_{v}=\{y\in G\mid v\rightarrow y\}$, de verzameling van punten $y$ die direct verbonden zijn met $v$ (via een tak van $v$ naar $y$).

Het algoritme

Het algoritme is eigenlijk een veralgemening van de basis van hierboven. Het algoritme verdeelt de punten van $G$ in drie verzamelingen:

$A$: de verzameling van punten waarvan de kortste afstand tot $g_{b}$ berekend is

$X$: de verzameling van punten waarnaar er al wel een pad bekend is vanuit $g_{b}$, maar niet het kortste, of dit is nog niet vastgesteld.

$V=G-A-X$: de overige punten van ${\displaystyle }$ (deze verzameling wordt niet bijgehouden in het algoritme)

Hiervoor geldt uiteraard dat $A\cap X=\emptyset$, $A$ en $X$ hebben geen punten gemeen.

Daarnaast bestaat er een array $d(v)$, geïndiceerd met de punten $v$ van $G$. Voor elk punt $g\in G$ wordt dit array door het algoritme dusdanig gevuld dat aan het eind geldt $d(g)=$ de lengte van het kortste pad van $g_{b}$ naar $g$.

Initieel geldt

• $A=\{g_{b}\}$
• $X=M_{g_{b}}$
• $d(g_{b})=0$
• $\forall {g\in X}:d(g)=gew(g_{b},g)$
• $\forall {g\in V(G)-X-A}:d(g)=\infty$

Het algoritme herhaalt nu de volgende stappen totdat $X$ de lege verzameling wordt (op dat moment zijn er geen bereikbare punten meer over), vanuit $g_{b}$:

1. Kies uit $X$ het punt $x$ met de minimale waarde van $d(x)$; dit is de eindwaarde van $d(x)$ voor dat punt. Immers, $d(x)$ heeft de waarde van de lengte van het kortste pad naar $x$ vanuit $g_{b}$ dat we tot nu toe gezien hebben. Ieder ander pad naar $x$ moet over $x$ lopen en is dus langer, omdat alle kanten een positieve lengte hebben.
2. Omdat $d(x)$ definitief is, verplaatsen we $x$ van $X$ naar $A$. Voor alle punten $z$ die bereikbaar zijn vanuit $x$ en die nog niet in $A$ zitten, doen we het volgende:
   1. Zit $z$ nog niet in $X$, dan voegen we het punt aan $X$ toe. Onze eerste schatting voor de afstand tussen $g_{b}$ en $z$ is dan $d(x)+gew(x,z)$ -- deze waarde plaatsen we in $d(z)$
   2. Zit $z$ al wel in $X$, dan passen we de schatting in $d(z)$ aan -- de nieuwe waarde is het minimum van de lengte van het nieuw-gevonden pad naar $z$ ($d(x)+gew(x,z)$) en de lengte van het kortste pad naar $z$ dat we al gevonden hadden.

Zodra dit algoritme afloopt (en dat doet het, want $V(G)$ is eindig en iedere stap verplaatst een element van $X$ naar $A$), dan is $d(v)$ gevuld met de afstanden van $g_{b}$ naar alle punten die vanuit dit beginpunt bereikbaar zijn. Is $d(w)$ oneindig voor een $w\in V(G)$, dan is dat punt $w$ niet bereikbaar vanuit $g_{b}$.

Algoritme in pseudocode

In pseudocode ziet het algoritme er als volgt uit:

 foreach $v\in V(G)$ do $d(v)=\infty$;
 A := $g_{b}$
 d(a) := 0
 X := $\emptyset$
 foreach z : z $\in$ $M_{(g_{b})}$ do 
   X := X $\cup$ {z}
   d(z) := gew($g_{b}$,z); 
   /* X en d zijn nu geïnitialiseerd */
 while not(X = $\emptyset$) do
   /* X is nog niet leeg */
   y : (y $\in$ X) $\land$ (d(y) = MIN {d(y')|y' $\in$ X}
   /* y is dus het element van X met de laagste waarde van d(v) -- dit is de definitieve waarde van d(y) */
   A := A $\cup$ {y}
   X := X$\setminus${y} 
   /* y is nu verplaatst van X naar A */
   foreach z: z $\in$ $M_{(y)}$ $\land$ not (z $\in$ A) do 
     if not (z $\in$ X) then
        X := X $\cup$ {z} 
        d(z) := d(y) + gew(y,z)
     else 
    /* dus z $\in$ X */ 
        d(z) := MIN{d(z), d(y) + gew(y,z)}

Hedendaagse toepassingen

Het algoritme wordt nog altijd veel toegepast in navigatieapparatuur, zoals de TomTom voor autoroutes of NavKid voor bootroutes. Daarbij wordt een wijziging toegepast; de afstand hoeft niet de echte afstand te zijn, maar kan ook worden uitgedrukt in tijd (voor de snelste route), in energieverbruik (de zuinigste route) of in straf/bonuspunten (voor bijvoorbeeld een mooie route, route met weinig afslagen, of een veilige route). Het principe van "afstand" blijft dan, maar er worden andere grootheden gebruikt.

Om het algoritme in de praktijk te kunnen gebruiken, zijn er enkele aanpassingen nodig, omdat niet de hele graaf (kaart) in het geheugen past. Ook kunnen er beperkingen zijn zoals de afmetingen van het voertuig of vaartuig, en bepaalde verkeersinformatie of stremmingen.

Bronnen, noten en/of referenties