In this article, I describe a simple (adds less than 1min of work) way to speed up Dijkstra’s Algorithm for finding the single source shortest path to every node in a graph.

In a previous post I described the simple **O(n ^{2})** implementation of the algorithm. Here, I focus on a method that will

**probably**speed up the algorithm.

#### Why Bother

The previous implementation of the algorithm ran in **O(n ^{2})** time, where

**n**is the number of nodes in the graph. This means that for a graph of, say

*100*nodes, it would do about

*100 * 100 = 100000*calculations. Considering that computers nowadays are said to be able to do about

*100000000*(a hundred million) calculations per second, we’re fine, and the programme will finish in well under a second. But what if we have a graph with

**100000**nodes? This might take

**100 seconds**to run. Now we’re in trouble. We need a faster algorithm.

The two most common ways to speed up Dijkstra’s Algorithm are to implement the finding of the closest node not yet visited as priority queues. Usually heaps or Fibonacci Heaps are used for this purpose (Fibonacci Heaps were actually invented for this).

Heaps are somewhat difficult to implement and Fibonacci Heaps are horror to implement. Incidentally, there’s a very easy of speeding it up.

#### Just Use Queues

The idea is to simply use queues instead of priority queues. This way provides nowhere near the same level of speedup (the algorithm is still **O(n ^{2})**), but

**it makes it run faster, on average, by a factor of**.

*4*Some bad news: a carefully crafted graph could slow this algorithm down to **O(n ^{3})**. As a rule, graphs in real life are

**never**like this, and, as the method isn’t widely known, test sets for contests are not written to catch this optimisation.

Now for the good news: it’s shockingly easy to write. Compare the old **dijkstra1()** with the new **dijkstra2()**.

void dijkstra1(int s) { int i, k, mini; int visited[GRAPHSIZE]; for (i = 1; i <= n; ++i) { d1[i] = INFINITY; visited[i] = 0; /* the i-th element has not yet been visited */ } d1[s] = 0; for (k = 1; k <= n; ++k) { mini = -1; for (i = 1; i <= n; ++i) if (!visited[i] && ((mini == -1) || (d1[i] < d1[mini]))) mini = i; visited[mini] = 1; for (i = 1; i <= n; ++i) if (dist[mini][i]) if (d1[mini] + dist[mini][i] < d1[i]) d1[i] = d1[mini] + dist[mini][i]; } } void dijkstra2(int s) { int queue[GRAPHSIZE]; char inQueue[GRAPHSIZE]; int begq = 0, endq = 0; int i, mini; int visited[GRAPHSIZE]; for (i = 1; i <= n; ++i) { d2[i] = INFINITY; visited[i] = 0; /* the i-th element has not yet been visited */ inQueue[i] = 0; } d2[s] = 0; queue[endq] = s; endq = (endq + 1) % GRAPHSIZE; while (begq != endq) { mini = queue[begq]; begq = (begq + 1) % GRAPHSIZE; inQueue[mini] = 0; visited[mini] = 1; for (i = 1; i <= n; ++i) if (dist[mini][i]) if (d2[mini] + dist[mini][i] < d2[i]) { d2[i] = d2[mini] + dist[mini][i]; if (!inQueue[i]) { queue[endq] = i; endq = (endq + 1) % GRAPHSIZE; inQueue[i] = 1; } } } } [/sourcecode] What's changed? First, we <strong>define several new variables</strong>. These, together, make up the queue: int queue[GRAPHSIZE]; char inQueue[GRAPHSIZE]; int begq = 0, endq = 0;

Next, during the initialisation part of the function, we **mark all nodes as not being in the queue**.

for (i = 1; i <= n; ++i) { /* OTHER INITIALISATIONS (look at the programme) */ inQueue[i] = 0; } [/sourcecode] Now, add the source node to the queue. [sourcecode language='cpp'] queue[endq] = s; endq = (endq + 1) % GRAPHSIZE; [/sourcecode] What does this do? The first line add <strong>s</strong> to the end of the queue. The second line moves the end of the queue one step to the right (I'll explain a few paragraphs down). The modulo operation here is not really necessary, but I like to be consistent. At this point we'll start looping. When do we stop? The idea here is that a node is in the queue when its neighbours need to be updated (i.e. when a new shortest path might be found leading to them). So, we stop when the queue is empty. Note that this occurs when <strong>begq == endq</strong> and <strong>not</strong> when <strong>!(begq < endq)</strong>. So, <strong>while (begq < endq)</strong> is incorrect because, in one case, <strong>begq</strong> will be greater then <strong>endq</strong>. What was the first thing we did in the loop? We were supposed to find the closest node not yet visited. Now, we merely take the first node from the queue. mini = queue[begq]; begq = (begq + 1) % GRAPHSIZE; inQueue[mini] = 0;

Here, the first element is pop’d out of the queue, the head of the queue is moved one step to the right and the element is marked as not being in the queue. The problem with queues in general, and this one in particular is that the part of them that actually hold the elements tends to move around. Here, every insert moves the tail one step to the right and every pop moves the head one step to the right. Consider the following sequence of operations:

Moves *1* through *8* clearly show that, while the size of the information content of the queue changes erratically, it constantly moves to the right. What happened at *9*? The queue got to the end of available memory and wrapped around to the beginning. This is the purpose of **(begq + 1) % GRAPHSIZE** and **(endq + 1) % GRAPHSIZE**. It turns *7*, *8*, *9*, etc. into *1*, *2*, *3*, etc. But won’t **endq** overrun **begq**? No, the use of **inQueue** guarantees that no element will be inserted in the queue more than once. And as the queue is of size **GRAPHSIZE**, no overrun is possible.

So far, so good. One last modification: when we update the distance to a node, we add it to the queue (if it’s not already in it).

for (i = 1; i <= n; ++i) if (dist[mini][i]) if (d2[mini] + dist[mini][i] < d2[i]) { d2[i] = d2[mini] + dist[mini][i]; if (!inQueue[i]) { queue[endq] = i; endq = (endq + 1) % GRAPHSIZE; inQueue[i] = 1; } } [/sourcecode]

#### Comparing the speed

When I first wrote this, I wanted to be able to check that it outputs correct results and I wanted to see how much faster it is. The following programme does both. The function **cmpd()** checks the output against that given by the simple implementation and the various **clock()** calls littered through the code time the two functions.

Here’s the code in C (dijkstra2.c):

**Note**: Source might be mangled by WordPress, consider downloading the file.

#include

#include

#define GRAPHSIZE 2048

#define INFINITY GRAPHSIZE*GRAPHSIZE

#define MAX(a, b) ((a > b) ? (a) : (b))

int e; /* The number of nonzero edges in the graph */

int n; /* The number of nodes in the graph */

long dist[GRAPHSIZE][GRAPHSIZE]; /* dist[i][j] is the distance between node i and j; or 0 if there is no direct connection */

long d1[GRAPHSIZE], d2[GRAPHSIZE]; /* d[i] is the length of the shortest path between the source (s) and node i */

void dijkstra1(int s) {

int i, k, mini;

int visited[GRAPHSIZE];

for (i = 1; i <= n; ++i) {
d1[i] = INFINITY;
visited[i] = 0; /* the i-th element has not yet been visited */
}
d1[s] = 0;
for (k = 1; k <= n; ++k) {
mini = -1;
for (i = 1; i <= n; ++i)
if (!visited[i] && ((mini == -1) || (d1[i] < d1[mini])))
mini = i;
visited[mini] = 1;
for (i = 1; i <= n; ++i)
if (dist[mini][i])
if (d1[mini] + dist[mini][i] < d1[i])
d1[i] = d1[mini] + dist[mini][i];
}
}
void dijkstra2(int s) {
int queue[GRAPHSIZE];
char inQueue[GRAPHSIZE];
int begq = 0,
endq = 0;
int i, mini;
int visited[GRAPHSIZE];
for (i = 1; i <= n; ++i) {
d2[i] = INFINITY;
visited[i] = 0; /* the i-th element has not yet been visited */
inQueue[i] = 0;
}
d2[s] = 0;
queue[endq] = s;
endq = (endq + 1) % GRAPHSIZE;
while (begq != endq) {
mini = queue[begq];
begq = (begq + 1) % GRAPHSIZE;
inQueue[mini] = 0;
visited[mini] = 1;
for (i = 1; i <= n; ++i)
if (dist[mini][i])
if (d2[mini] + dist[mini][i] < d2[i]) {
d2[i] = d2[mini] + dist[mini][i];
if (!inQueue[i]) {
queue[endq] = i;
endq = (endq + 1) % GRAPHSIZE;
inQueue[i] = 1;
}
}
}
}
int cmpd() {
int i;
for (i = 0; i < n; ++i)
if (d1[i] != d2[i])
return 0;
return 1;
}
int main(int argc, char *argv[]) {
int i, j;
int u, v, w;
long t1 = 0,
t2 = 0;
FILE *fin = fopen("dist2.txt", "r");
fscanf(fin, "%d", &e);
for (i = 0; i < e; ++i)
for (j = 0; j < e; ++j)
dist[i][j] = 0;
n = -1;
for (i = 0; i < e; ++i) {
fscanf(fin, "%d%d%d", &u, &v, &w);
dist[u][v] = w;
n = MAX(u, MAX(v, n));
}
fclose(fin);
for (i = 1; i <= n; ++i) {
long aux = clock();
dijkstra1(i);
t1 += clock() - aux;
aux = clock();
dijkstra2(i);
t2 += clock() - aux;
if (i % 10 == 0) {
printf("%d / %d\n", i, n);
fflush(stdout);
}
if (!cmpd()) {
printf("\nResults for %d do NOT match\n", i);
break;
}
}
printf("\n");
printf("Dijkstra O(N^2):\t\t%ld\n", t1);
printf("Dijkstra unstable:\t\t%ld\n", t2);
printf("Ratio:\t\t\t\t%.2f\n", (float)t1/t2);
/* printD(); */
return 0;
}
[/sourcecode]
And here's a big *1200* node graph: dist2.txt.

Have fun and good luck. Always open to comments.