Using Dijkstra algorithm to compute shortest path between two nodes - c++

Question

I am new in C++. I am trying to compute the path to travel from node start to node end using Dijkstra algorithm. I am pretty sure I am computing the shortest path in the correct way but for some reason I can't store it in my traceBack vector. It would be really helpful if anyone would help me pointing my mistake here.
My function descriptions and the part of the code where I am computing the shortest path is the following:
The function find_connected_nodes(int x) returns only the nodes connected to the given node.
the function find_travel_time(int x, int y) returns the time to travel from x to y.
void dijkstra(int start, int end) {
vector <unsigned> visited(getNumberOfNodes(), 0);
vector <double> time_weight(getNumberOfNodes(), 99999); //99999 to represent not connected
int inNode = start, pathNode = _end, nextnode = 0;
double min; //will use min to compare time between edges
vector<unsigned> traceBack(getNumberOfNodes(), inNode); //traceBack to contain the path from start to end
time_weight[inNode] = 0;
visited[inNode] = 1;
vector<unsigned> x = find_connected_nodes(start);
if (!x.empty()) {
for (unsigned i = 0; i < x.size(); i++) {
time_weight[x[i]] = find_travel_time(start, x[i]));
}
}
for (int i = 0; i < getNumberOfNodes(); i++) {
min = 99999;
for (int j = 0; j < x.size(); j++) {
if (min > time_weight[x[j]] && visited[x[j]] != 1) {
min = time_weight[x[j]];
nextnode = x[j];
}
}
visited[nextnode] = 1;
for (int j = 0; j < x.size(); j++) {
if (visited[x[j]] != 1) {
if (min + find_travel_time(nextnode, x[j]))<time_weight[x[j]]) {
time_weight[x[j]] = min + find_travel_time(nextnode, x[j]));
traceBack[x[j]] = nextnode;
}
}
}
x = find_connected_nodes(nextnode);
}
int j;
cout << "Path = " << pathNode;
j = pathNode;
do {
j = traceBack[j];
cout << "<-" << j;
} while (j != inNode);
}

Answer 1

Not a complete solution to your problem, because it’s homework and you’ll want to solve it on your own, but here is an example of how to solve the same kind of design problem you’re dealing with:
#include <cstdlib>
#include <iostream>
#include <vector>
using std::cout;
using std::endl;
using std::size_t;
std::vector<double> map_squares( const std::vector<double>& inputs )
/* Maps the square function onto the inputs. That is, returns a vector whose
* elements are the squares of the input elements.
*/
{
const size_t size = inputs.size(); // The number of inputs, and outputs.
std::vector<double> outputs(size); // We will return this.
/* (Actually, we will return a copy of the vector, and then the compiler will
* optimize the copy so it doesn't have to copy every element, just a single
* reference to the data in the vector. You'll learn more about how that
* works, and how to write classes like that yourself, in due time.)
*/
for ( size_t i = 0; i < size; ++i ) {
outputs[i] = inputs[i]*inputs[i];
}
outputs.shrink_to_fit(); // Maybe save a few bytes of memory.
return outputs;
}
std::ostream& operator<<( std::ostream& os, const std::vector<double>& v )
// Boilerplate to serialize and print a vector to a stream.
{
const size_t size = v.size();
os << '[';
if (size > 0)
os << v[0];
for ( size_t i = 1; i < size; ++i )
os << ',' << v[i];
os << ']';
return os;
}
int main(void)
{
// Out inputs:
const std::vector<double> raw_numbers = {4,2,1,0.5,0.25};
// Our results:
const std::vector<double> squares = map_squares(raw_numbers);
// Output: "[16,4,1,0.25,0.0625]"
cout << squares << endl;
return EXIT_SUCCESS;
}