Dijkstra's algorithm C++ - 2 implementations

Hello,

I've a question regarding dijkstra's algorithm in C++. I've always used the following implementation:

Code:

`struct edge //needed only for std::set, see below {`

int vertex;

unsigned long weight;

edge(int v, unsigned long wt) : vertex(v), weight(wt) { }

bool operator<(const edge& e2) const

{

return weight < e2.weight;

}

};

void dijkstra_algorithm()

{

for(int i = 0 ; i < G.V() ; ++i)

{

wt[i] = ULONG_MAX; //length of the shortest path from start vertex to "i"

spt[i] = 0; //last edge on the way from start vertex to "i"

}

int v = start_vertex;

wt[v] = 0;

std::set<edge> vertex_queue;

vertex_queue.insert(edge(v, wt[v]));

while(!vertex_queue.empty())

{

v = vertex_queue.begin()->vertex;

vertex_queue.erase(vertex_queue.begin());

DenseWeightedGRAPH::adjIterator A(G, v);

for(Weighted_edge* e = A.beg() ; !A.end() ; e = A.nxt()) //examining every neighbour of "v" vertex as Weighted_edge

{

unsigned long P = wt[v] + e->wt(); //wt() returns the edge weight

int w = e->other(v); //the function returns the opposite vertex to "v" in the edge "e"

if(P < wt[w])

{

vertex_queue.erase(edge(w, wt[w]));

wt[w] = P;

spt[w] = e;

vertex_queue.insert(edge(w, wt[w]));

}

}

}

}

But when I was writing a program for some online judge, it was keeping on failing on the largest input test and I discovered that the above algorithm was the problem. I've found another implementation of Dijkstra and modified it towards my graph representation classes and everything's fine now:

Code:

`void dijkstra_algorithm() {`

for(int i = 0 ; i < G.V() ; ++i)

{

wt[i] = ULONG_MAX;

spt[i] = 0;

}

int v = start_vertex;

wt[v] = 0;

bool visit[MAX_VERTICES] = { false };

queue<int> q;

q.push(v);

while (!q.empty())

{

v = q.front();

q.pop();

visit[v] = false;

DenseWeightedGRAPH::adjIterator A(G, v);

for(Weighted_edge* e = A.beg() ; !A.end() ; e = A.nxt())

{

unsigned long P = wt[v] + e->wt();

int w = e->other(v);

if(P < wt[w])

{

wt[w] = P;

spt[w] = e;

if(!visit[w])

{

visit[w] = true;

q.push(w);

}

}

}

}

}

As you can see, here we got a visited table and an ordinary queue instead of priority one under std::set.

Like I said, it's working now, but what's wrong with the first algorithm? The second one seems to be even simpler but according to definitions, Dijkstra requires some kind of a priority queue - not a normal queue that stores only vertex numbers and doesn't take weights into account itself...

Re: Dijkstra's algorithm C++ - 2 implementations

Quote:

Originally Posted by

**Quentin026**
Like I said, it's working now, but what's wrong with the first algorithm?

Isn't it a little bit pompous to think that people would jump on the chance to figure out what you did wrong?

I mean Dijkstra got it right and that enough to satisfy most people. :)

I'll eat my hat if Quent026 comes back here. No one ever does. Regardless of how fine a reply you've posted.

And furthermore there are increasing evidence moderator corruption. When the dumb gets the upper hand it's time to leave for greener pastures. So good bye good people. This is my last post. Good luck.

Re: Dijkstra's algorithm C++ - 2 implementations

Quote:

Originally Posted by

**Quentin026**
Like I said, it's working now, but what's wrong with the first algorithm? The second one seems to be even simpler but according to definitions, Dijkstra requires some kind of a priority queue - not a normal queue that stores only vertex numbers and doesn't take weights into account itself...

I'm sure you can come up with a test case that fails the second algorithm.

As to why the first one may be too slow: a std::set keeps all its elements sorted. Dijkstra's algorithm only needs to access the lowest element, so the order of the other elements does not matter. A binary heap can implement that more efficiently than a std::set.

Re: Dijkstra's algorithm C++ - 2 implementations

just to throw in some info

Dijkstra *who can even pronounce that*

Dijkstra isn't Dijkstra once you weight it. ,its really more of a flood fill type algorithim anyways

typically its not used for long distances as it increases over distance by approx d^2 checks

Astar or A* is preferred in most case's as its faster and is meant for weighting its very similar

i think once you weight Dijkstra's your starting to turn it into astar anyways